@accounts/graphql-api mmigration.

[danyhiol]

My old code works like this:

import { AccountsModule } from '@accounts/graphql-api';
export const accountsGraphQL = AccountsModule.forRoot({ accountsServer });

This is no more possible with the new changes:

const app = createApplication({
    modules: [
      createAccountsCoreModule({ tokenSecret: 'secret' }),
      createAccountsPasswordModule({
        // This option is called when a new user create an account
        // Inside we can apply our logic to validate the user fields
        validateNewUser: (user) => {
          if (!user.firstName) {
            throw new Error('First name required');
          }
          if (!user.lastName) {
            throw new Error('Last name required');
          }

          // For example we can allow only some kind of emails
          if (user.email.endsWith('.xyz')) {
            throw new Error('Invalid email');
          }
          return user;
        },
      }),
      createAccountsMongoModule({ dbConn }),
    ],
    providers: [
      {
        provide: AuthenticationServicesToken,
        useValue: { password: AccountsPassword },
        global: true,
      },
    ],
    schemaBuilder: buildSchema({ typeDefs, resolvers }),
  });
  const { injector, createOperationController } = app;

This is a breaking change. As my app is already structured to work with accountsGraphQL.
I am using the following from accountsGraphQL:
accountsGraphQL.context, accountsGraphQL.typeDefs, accountsGraphQL.resolvers.
createAccountsCoreModule provides typeDefs:

const module = createAccountsCoreModule({ tokenSecret: 'token_secret',  });
const typeDefs = module.typeDefs. 

But it doesn't provide resolvers.
The new context:

import { context } from '@accounts/module-core';
context({ request }, { createOperationController })

Requires createOperationController coming from createApplication. This is annoying as I don't want to recompose my entire app just to have this single functionality: meaning I don't want to pack all my complex appolo stuff in createApplication.

On the other hand, I can't continue using @accounts/graphql-api as it depends on old dependencies: @accounts/magic-link@0.1.1, tedious. So I'm stuck and would rather not have to change my app to use createApplication.

[darkbasic]

I am using the following from accountsGraphQL:
accountsGraphQL.context, accountsGraphQL.typeDefs, accountsGraphQL.resolvers

app (meaning createApplication's return value) provides both typeDefs and resolvers:

const { typeDefs, resolvers } = app;

Depending on the graphql server of your choice you might be able to use them directly or not. For example with graphql-http (examples/graphql-server-typescript-basic):

import { createHandler } from 'graphql-http/lib/use/http';

const app = createApplication([...]);
const { injector, createOperationController } = app;
// Create the GraphQL over HTTP Node request handler
const handler = createHandler<Pick<IContext, keyof IContext>>({
  schema: app.schema, // schema is basically typedefs + resolvers
  execute: app.createExecution(),
  context: (request) => context({ request }, { createOperationController }),
});

As you can see you can use typedefs/resolvers from app if you also provide the custom executor.

Other graphql servers don't support custom executors in the same way, for example apollo (examples/graphql-server-typescript-apollo):

const { injector, createOperationController, createApolloGateway } = app;
const gateway = createApolloGateway();
const server = new ApolloServer({gateway});

but you can still customize the typedefs/resolvers via the schemaBuilder function:

const app = createApplication({
  [...]
  // typedefs and resolvers are the additional ones that you want to merge along with the accounts.js ones
  schemaBuilder: buildSchema({ typeDefs, resolvers }),
});

buildSchema supports directives and much more, but you can also provide your custom schemaBuilder function (look at the buildSchema source code to see how it works).

Context is a different matter. Since v1 graphql-modules is less strict about inter-module dependencies and no longer provides per-module context. That means that the context is global and you are in charge to provide it. That being said we provide another helper function called context that allows you to automatically generate the context needed by accounts.js to work. It's also customizable so you can provide your own additional context as well (look at the source code to see all the options that it provides). Continuing the previous apollo example:

import { context } from '@accounts/module-core';

const { createOperationController } = app;
const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
  context: (ctx) => context(ctx, { createOperationController }),
});

It's a breaking change for sure and a necessary one, but I honestly have an hard time understanding why it would be difficult to refactor your app: just put your custom schema inside buildSchema and your custom context logic inside context.

[danyhiol]

I managed to get it to work with minimal changes to my app with createApplication. We are missing a bit of documentation here.

[darkbasic]

Yeah I know we still lack a migration guide and you have to rely a bit on the examples ATM. Would you be willing to contribute? https://github.com/accounts-js/accounts/tree/master/website

[danyhiol]

Yes I'll gladly help on the documentation.