feat: port oauth to the new architecture

Author: darkbasic

packages/oauth/package.json

@@ -29,8 +29,13 @@
     "@accounts/server": "^0.33.1",
     "@types/jest": "27.5.2",
     "@types/node": "20.2.3",
+    "graphql-modules": "2.1.2",
     "jest": "27.3.1",
     "rimraf": "5.0.1",
     "ts-jest": "27.1.5"
+  },
+  "peerDependencies": {
+    "@accounts/server": "^0.32.0 || ^0.33.0",
+    "graphql-modules": "^2.0.0"
   }
 }

packages/oauth/src/accounts-oauth.ts

@@ -1,34 +1,87 @@
-import { User, DatabaseInterface, AuthenticationService } from '@accounts/types';
-import { AccountsServer, ServerHooks } from '@accounts/server';
-import { OAuthOptions } from './types/oauth-options';
+import {
+  User,
+  DatabaseInterface,
+  AuthenticationService,
+  DatabaseInterfaceSessions,
+  DatabaseInterfaceUser,
+} from '@accounts/types';
+import {
+  AccountsServer,
+  /*DatabaseInterfaceSessionsToken,*/ DatabaseInterfaceUserToken,
+  ServerHooks,
+} from '@accounts/server';
+import { OAuthProviders } from './types/oauth-providers';
 import { OAuthUser } from './types/oauth-user';
+import { ExecutionContext, Inject, Injectable } from 'graphql-modules';
+import { OAuthProvidersToken } from './types/OAuthProviders.symbol';
 
 const getRegistrationPayloadDefault = async (oauthUser: OAuthUser) => {
   return {
     email: oauthUser.email,
   };
 };
 
-export class AccountsOauth implements AuthenticationService {
+@Injectable({
+  global: true,
+})
+export class AccountsOauth<CustomUser extends User = User>
+  implements AuthenticationService<CustomUser>
+{
+  @ExecutionContext() public context!: ExecutionContext;
   public server!: AccountsServer;
   public serviceName = 'oauth';
-  private db!: DatabaseInterface;
-  private options: OAuthOptions;
+  private db!: DatabaseInterfaceUser<CustomUser>;
+  // private dbSessions!: DatabaseInterfaceSessions;
+
+  constructor(
+    @Inject(OAuthProvidersToken) public oauthProviders: OAuthProviders,
+    @Inject(DatabaseInterfaceUserToken)
+    db?: DatabaseInterface<CustomUser> | DatabaseInterfaceUser<CustomUser>,
+    // @Inject(DatabaseInterfaceSessionsToken) dbSessions?: DatabaseInterfaceSessions,
+    server?: AccountsServer
+  ) {
+    if (db) {
+      this.db = db;
+      // this.dbSessions = dbSessions ?? (db as DatabaseInterfaceSessions);
+    }
+
+    if (server) {
+      this.server = server;
+    }
+  }
 
-  constructor(options: OAuthOptions) {
-    this.options = options;
+  private getOAuthProvider(providerName: string) {
+    const instanceOrCtor = this.oauthProviders[providerName];
+    // If it's a constructor we use dependency injection (GraphQL), otherwise we already have an instance (REST)
+    const provider =
+      typeof instanceOrCtor === 'function'
+        ? this.context.injector.get(instanceOrCtor)
+        : instanceOrCtor;
+    if (!provider) {
+      throw new Error(`No OAuth provider with the name ${providerName} was registered.`);
+    }
+    return provider;
   }
 
-  public setStore(store: DatabaseInterface) {
+  public getOAuthProviders(): OAuthProviders {
+    return this.oauthProviders;
+  }
+
+  public setUserStore(store: DatabaseInterfaceUser<CustomUser>) {
     this.db = store;
   }
 
-  public async authenticate(params: any): Promise<User | null> {
-    if (!params.provider || !this.options[params.provider]) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public setSessionsStore(store: DatabaseInterfaceSessions) {
+    //this.dbSessions = store;
+  }
+
+  public async authenticate(params: any): Promise<CustomUser | null> {
+    if (!params.provider || !this.getOAuthProvider(params.provider)) {
       throw new Error('Invalid provider');
     }
 
-    const userProvider = this.options[params.provider];
+    const userProvider = this.getOAuthProvider(params.provider);
 
     if (typeof userProvider.authenticate !== 'function') {
       throw new Error('Invalid provider');
@@ -49,7 +102,11 @@ export class AccountsOauth implements AuthenticationService {
 
         const userId = await this.db.createUser(userData);
 
-        user = (await this.db.findUserById(userId)) as User;
+        user = await this.db.findUserById(userId);
+
+        if (user == null) {
+          throw new Error(`Cannot find user ${userId}`);
+        }
 
         if (this.server) {
           await this.server.getHooks().emit(ServerHooks.CreateUserSuccess, user);
@@ -69,7 +126,7 @@ export class AccountsOauth implements AuthenticationService {
   }
 
   public async unlink(userId: string, provider: string) {
-    if (!provider || !this.options[provider]) {
+    if (!provider || !this.getOAuthProvider(provider)) {
       throw new Error('Invalid provider');
     }
 

packages/oauth/src/index.ts

@@ -3,5 +3,5 @@ export default AccountsOauth;
 
 export { AccountsOauth } from './accounts-oauth';
 export { OAuthProvider } from './types/oauth-provider';
-export { OAuthOptions } from './types/oauth-options';
+export { OAuthProviders } from './types/oauth-providers';
 export { OAuthUser } from './types/oauth-user';

packages/oauth/src/types/OAuthProviders.symbol.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from 'graphql-modules';
+import { OAuthProviders } from './oauth-providers';
+
+export const OAuthProvidersToken = new InjectionToken<OAuthProviders>('OauthProviders');

packages/oauth/src/types/oauth-options.ts

@@ -0,0 +1,5 @@
+import { OAuthProvider } from './oauth-provider';
+
+export interface OAuthProviders {
+  [key: string]: (new (args: any) => OAuthProvider) | OAuthProvider | undefined;
+}

packages/oauth/src/types/oauth-providers.ts

@@ -1,6 +1,8 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "outDir": "./lib",
     "importHelpers": true
   },

packages/oauth/tsconfig.json

@@ -180,7 +180,7 @@ const defaultOptions = {
   global: true,
 })
 export default class AccountsPassword<CustomUser extends User = User>
-  implements AuthenticationService
+  implements AuthenticationService<CustomUser>
 {
   public serviceName = 'password';
   public server!: AccountsServer;