AccountsJs TypeORM

Question

I have a bit of a problem with account and TypeORM

I've configured everything and there are no errors, but I can't seem to create users, I run the mutation but it doesn't fail and it runs in like 2ms, but when I go to the DB (MongoDB Atlas) I don't see the user collection and there are no users created.

Here is my config:

import { AccountsModule } from "@accounts/graphql-api";
import { AccountsServer } from "@accounts/server";
import { AccountsPassword } from "@accounts/password";
import AccountsTypeorm from "@accounts/typeorm";
import { Connection } from "typeorm";

export const setUpAccounts = async (connection: Connection) => {
  const db = new AccountsTypeorm({ connection, cache: 1000 });
  const password = new AccountsPassword({
    twoFactor: {
      appName: "Events"
    }
  });

  const accountsServer = new AccountsServer(
    {
      db,
      tokenSecret: "terrible secret",
      siteUrl: "http://localhost:3000"
    },
    {
      password
    }
  );

  const accounts = AccountsModule.forRoot({
    accountsServer,
    headerName: "x-events-token"
  });

  return accounts;
};

index file:

require("dotenv").config();
import "reflect-metadata";

import express, { Application } from "express";
import { ApolloServer, makeExecutableSchema } from "apollo-server-express";
import { mergeTypeDefs } from "graphql-toolkit";
import { buildTypeDefsAndResolvers } from "type-graphql";

import { resolvers } from "./graphql";
import { connectDatabase } from "./db";
import { setUpAccounts } from "./lib/accounts";
import { CategoryResolver } from "./modules/Category/CategoryResolver";

const port = process.env.PORT;

const corsOptions = {
  origin: "http://localhost:3000",
  credentials: true
};
const mount = async (app: Application): Promise<void> => {
  const connection = await connectDatabase();

  const accounts = await setUpAccounts(connection);

  const schema = await buildTypeDefsAndResolvers({
    resolvers: [resolvers, CategoryResolver, accounts.resolvers]
  });

  const server = new ApolloServer({
    schema: makeExecutableSchema({
      typeDefs: mergeTypeDefs([accounts.typeDefs, schema.typeDefs]),
      resolvers: schema.resolvers,
      schemaDirectives: {
        ...accounts.schemaDirectives
      }
    }),
    context: accounts.context,
    playground: true
  });

  server.applyMiddleware({
    app: app,
    path: "/graphql",
    cors: corsOptions
  });

  app.listen(port, () => {
    console.log(`[ app ]: running on http://localhost:${port}`);
  });
};

mount(express());

connectDatabase:

import { createConnection, Connection } from "typeorm";
import path from "path";

const user = process.env.DB_USER;
const userPassword = process.env.DB_USER_PASSWORD;
const cluster = process.env.DB_CLUSTER;

const uri = `mongodb+srv://${user}:${userPassword}@${cluster}.mongodb.net/`;

export const connectDatabase = async (): Promise<Connection> => {
  const connection = await createConnection({
    url: uri,
    type: "mongodb",
    database: "main",
    w: "majority",
    useNewUrlParser: true,
    useUnifiedTopology: true,
    logger: "advanced-console",
    logging: "all",
    entities: [
      path.join(__dirname, "/../entities/**/*.*"),
      ...require("@accounts/typeorm").entities
    ]
  });

  console.log(connection.options.entities);

  return connection;
};

Answer 1

Nvm I fixed it by moving accounts.resolvers from buildTypeDefsAndResolvers to makeExecutableSchema:

schema: makeExecutableSchema({
    typeDefs: mergeTypeDefs([accounts.typeDefs, schema.typeDefs]),
    resolvers: mergeResolvers([schema.resolvers, accounts.resolvers]),
    schemaDirectives: {
      ...accounts.schemaDirectives
    }
})

Works now :)