Merge pull request #9 from taylor009/master

Update dependencies and refactor code for Auth0 management models

package.json

@@ -42,22 +42,22 @@
   },
   "homepage": "https://github.com/Twirelab/nestjs-auth0#readme",
   "dependencies": {
-    "auth0": "^2.40.0",
-    "reflect-metadata": "^0.1.13",
+    "auth0": "^4.4.0",
+    "reflect-metadata": "^0.2.2",
     "rxjs": "^7.5.5"
   },
   "devDependencies": {
-    "@nestjs/common": "^8.4.4",
-    "@nestjs/core": "^8.4.4",
-    "@nestjs/testing": "^8.4.4",
-    "@types/auth0": "^2.34.19",
-    "@types/jest": "^27.5.0",
-    "jest": "^28.1.0",
-    "ts-jest": "^28.0.2",
-    "typescript": "^4.6.4"
+    "@nestjs/common": "^10.3.8",
+    "@nestjs/core": "^10.3.8",
+    "@nestjs/testing": "^10.3.8",
+    "@types/auth0": "^3.3.10",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.5"
   },
   "peerDependencies": {
     "@nestjs/common": "^8.0.0",
     "@nestjs/core": "^8.0.0"
   }
-}
+}

src/clients/management.client.ts

@@ -1,4 +1,5 @@
-import { ManagementClient, ManagementClientOptions } from "auth0";
+import { ManagementClient, ManagementClientOptionsWithClientCredentials } from "auth0";
+// import type { ManagementClientBase } from "auth0";
 
 /**
  * Get Auth0 Authentication client.
@@ -7,6 +8,6 @@ import { ManagementClient, ManagementClientOptions } from "auth0";
  * 
  * @return {mana}
  */
-export function getManagementClient(options: ManagementClientOptions): ManagementClient {
+export function getManagementClient(options: ManagementClientOptionsWithClientCredentials): ManagementClient {
     return new ManagementClient(options);
 }

src/modules/authentication-core.module.ts

@@ -1,4 +1,4 @@
-import { Global, Module, DynamicModule, Provider, ClassProvider } from "@nestjs/common";
+import { Global, Module, DynamicModule, Provider } from "@nestjs/common";
 import { AuthenticationClientOptions } from "auth0";
 import { getAuthenticationClient } from "../clients/authentication.client";
 import { AUTH_CLIENT, AUTH_MODULE } from "../constants";
@@ -8,91 +8,61 @@ import { createAuthenticationProvider } from "../providers/authentication.provid
 @Global()
 @Module({})
 export class AuthenticationCoreModule {
-    /**
-     * For root.
-     * 
-     * @param {AuthenticationClientOptions} options 
-     * 
-     * @return {DynamicModule}
-     */
     public static forRoot(options: AuthenticationClientOptions): DynamicModule {
         const provider = createAuthenticationProvider(options);
 
         return {
             exports: [provider],
             module: AuthenticationCoreModule,
             providers: [provider],
-        }
+        };
     }
 
-    /**
-     * For root async.
-     * 
-     * @param {AuthenticationAsyncOptions} options 
-     * 
-     * @return {DynamicModule} 
-     */
     static forRootAsync(options: AuthenticationAsyncOptions): DynamicModule {
-        const provider: Provider<any> = {
+        const provider: Provider = {
             inject: [AUTH_MODULE],
             provide: AUTH_CLIENT,
             useFactory: (authOptions: AuthenticationClientOptions) => getAuthenticationClient(authOptions),
-        }
+        };
 
         return {
             exports: [provider],
             imports: options.imports,
             module: AuthenticationCoreModule,
             providers: [...this.createAsyncProviders(options), provider],
-        }
+        };
     }
 
-    /**
-     * Create async options provider.
-     * 
-     * @param {AuthenticationAsyncOptions} options 
-     * 
-     * @return {Provider}
-     */
     private static createAsyncOptionsProvider(options: AuthenticationAsyncOptions): Provider {
         if (options.useFactory) {
             return {
                 inject: options.inject ?? [],
                 provide: AUTH_MODULE,
                 useFactory: options.useFactory,
             };
-        }
-
-        return {
-            inject: options.useExisting
-                ? [options.useExisting]
-                : options.useClass
-                    ? [options.useClass]
-                    : [],
-            provide: AUTH_MODULE,
-            useFactory: (optionsFactory: AuthenticationOptionsFactory) => optionsFactory.createAuth0Options(),
+        } else if (options.useExisting || options.useClass) {
+            const injectToken = options.useExisting ?? options.useClass;
+            if (!injectToken) {
+                throw new Error('A valid injection token is required for useExisting or useClass');
+            }
+            return {
+                inject: [injectToken],
+                provide: AUTH_MODULE,
+                useFactory: (optionsFactory: AuthenticationOptionsFactory) => optionsFactory.createAuth0Options(),
+            };
+        } else {
+            throw new Error('Invalid configuration for the authentication module');
         }
     }
 
-    /**
-     * Create async provider.
-     * 
-     * @param {AuthenticationAsyncOptions} options 
-     * 
-     * @return {Provider[]}
-     */
     private static createAsyncProviders(options: AuthenticationAsyncOptions): Provider[] {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
-        }
-
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
+        const providers: Provider[] = [this.createAsyncOptionsProvider(options)];
+        if (options.useClass) {
+            providers.push({
                 provide: options.useClass,
-                useClass: options.useClass,
-                inject: [options.inject ?? []],
-            } as ClassProvider,
-        ];
+                useClass: options.useClass
+            });
+        }
+        return providers;
     }
-}
+}

src/modules/management-core.module.ts

@@ -1,59 +1,39 @@
 import { Global, Module, DynamicModule, Provider, ClassProvider } from "@nestjs/common";
-import { ManagementClientOptions } from "auth0";
+import { ManagementClientOptions } from "auth0/dist/cjs/management/management-client-options";
 import { getManagementClient } from "../clients/management.client";
 import { ManagementAsyncOptions, ManagementOptionsFactory } from "../auth0.options";
 import { createManagementProvider } from "../providers/management.provider";
 import { MANG_CLIENT, MANG_MODULE } from "../constants";
+import { ManagementClientOptionsWithClientCredentials } from "auth0";
 
 @Global()
 @Module({})
 export class ManagementCoreModule {
-    /**
-     * For root.
-     * 
-     * @param {ManagementClientOptions} options 
-     * 
-     * @return {DynamicModule}
-     */
-    public static forRoot(options: ManagementClientOptions): DynamicModule {
+    public static forRoot(options: ManagementClientOptions & { clientId: string; clientAssertionSigningKey: string; }): DynamicModule {
         const provider = createManagementProvider(options);
 
         return {
             exports: [provider],
             module: ManagementCoreModule,
             providers: [provider],
-        }
+        };
     }
 
-    /**
-     * For root async.
-     * 
-     * @param {ManagementAsyncOptions} options 
-     * 
-     * @return {DynamicModule} 
-     */
     static forRootAsync(options: ManagementAsyncOptions): DynamicModule {
-        const provider: Provider<any> = {
+        const provider: Provider = {
             inject: [MANG_MODULE],
             provide: MANG_CLIENT,
-            useFactory: (authOptions: ManagementClientOptions) => getManagementClient(authOptions),
-        }
+            useFactory: (authOptions: ManagementClientOptionsWithClientCredentials) => getManagementClient(authOptions),
+        };
 
         return {
             exports: [provider],
             imports: options.imports,
             module: ManagementCoreModule,
             providers: [...this.createAsyncProviders(options), provider],
-        }
+        };
     }
 
-    /**
-     * Create async options provider.
-     * 
-     * @param {ManagementAsyncOptions} options 
-     * 
-     * @return {Provider}
-     */
     private static createAsyncOptionsProvider(options: ManagementAsyncOptions): Provider {
         if (options.useFactory) {
             return {
@@ -63,36 +43,26 @@ export class ManagementCoreModule {
             };
         }
 
+        const inject = options.useExisting ? [options.useExisting] : (options.useClass ? [options.useClass] : []);
+        if (inject.length === 0) {
+            throw new Error('Invalid configuration for the management module: A valid injection token is required');
+        }
         return {
-            inject: options.useExisting
-                ? [options.useExisting]
-                : options.useClass
-                    ? [options.useClass]
-                    : [],
+            inject,
             provide: MANG_MODULE,
             useFactory: (optionsFactory: ManagementOptionsFactory) => optionsFactory.createAuth0Options(),
-        }
+        };
     }
 
-    /**
-     * Create async provider.
-     * 
-     * @param {ManagementAsyncOptions} options 
-     * 
-     * @return {Provider[]}
-     */
     private static createAsyncProviders(options: ManagementAsyncOptions): Provider[] {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
-        }
-
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
+        const providers: Provider[] = [this.createAsyncOptionsProvider(options)];
+        if (options.useClass) {
+            providers.push({
                 provide: options.useClass,
                 useClass: options.useClass,
-                inject: [options.inject ?? []],
-            } as ClassProvider,
-        ];
+                ...(options.inject ? { inject: options.inject } : {}),
+            } as ClassProvider);
+        }
+        return providers;
     }
-}
+}

src/modules/management.module.ts

@@ -1,7 +1,7 @@
 import { DynamicModule, Global, Module } from "@nestjs/common";
-import { ManagementClientOptions } from "auth0";
 import { ManagementAsyncOptions } from "../auth0.options";
 import { ManagementCoreModule } from "./management-core.module";
+import {ManagementClientOptions} from "auth0";
 
 @Global()
 @Module({})
@@ -13,7 +13,7 @@ export class ManagementModule {
      * 
      * @return {DynamicModule}
      */
-    public static forRoot(options: ManagementClientOptions): DynamicModule {
+    public static forRoot(options: ManagementClientOptions & { clientId: string; clientAssertionSigningKey: string; }): DynamicModule {
         return {
             module: ManagementModule,
             imports: [ManagementCoreModule.forRoot(options)],

src/providers/management.provider.ts

@@ -1,16 +1,17 @@
 import { Provider } from "@nestjs/common";
-import { ManagementClient, ManagementClientOptions } from "auth0";
+import { ManagementClientOptions } from "auth0";
+import { ManagementClientBase as ManagementClient } from "auth0/dist/cjs/management/__generated/index";
 import { getManagementClient } from "../clients/management.client";
 import { MANG_CLIENT } from "../constants";
 
 /**
  * Create Auth0 Management provider.
- * 
- * @param {ManagementClientOptions} options
- * 
+ *
+ * @param {ManagementClientOptions & { clientId: string, clientAssertionSigningKey: string }} options
+ *
  * @return
  */
-export function createManagementProvider(options: ManagementClientOptions): Provider<ManagementClient> {
+export function createManagementProvider(options: ManagementClientOptions & { clientId: string, clientAssertionSigningKey: string }): Provider<ManagementClient> {
     return {
         provide: MANG_CLIENT,
         useValue: getManagementClient(options),

test/clients/authentication.client.test.ts

@@ -4,8 +4,9 @@ import { ManagementClient } from "auth0";
 describe("Get ManagementClient Client", () => {
     it("Returns managementClient client", () => {
         const client = getManagementClient({
-            token: "test",
             domain: "test.com",
+            clientId: "yourClientId",
+            clientAssertionSigningKey: "yourClientAssertionSigningKey"
         });
 
         expect(client).toBeInstanceOf(ManagementClient);

test/inject/authentication.inject.test.ts

@@ -1,8 +1,8 @@
 import { Injectable } from "@nestjs/common";
 import { Test, TestingModule } from "@nestjs/testing";
 import { AuthenticationClient } from "auth0";
-import { InjectAuthentication } from "../../src/inject/authentication.inject"
-import { AuthenticationModule } from "../../src/modules/authentication.module";
+import { InjectAuthentication } from "../../src"
+import { AuthenticationModule } from "../../src";
 
 describe("Inject Authentication", () => {
     let module: TestingModule;
@@ -14,7 +14,7 @@ describe("Inject Authentication", () => {
 
     beforeEach(async () => {
         module = await Test.createTestingModule({
-            imports: [AuthenticationModule.forRoot({ domain: "test.com" })],
+            imports: [AuthenticationModule.forRoot({ domain: "test.com", clientId: "yourClientId" })],
             providers: [TestService],
         }).compile();
     });

test/inject/management.inject.test.ts

@@ -1,8 +1,8 @@
 import { Injectable } from "@nestjs/common";
 import { Test, TestingModule } from "@nestjs/testing";
 import { ManagementClient } from "auth0";
-import { InjectManagement } from "../../src/inject/management.inject"
-import { ManagementModule } from "../../src/modules/management.module";
+import { InjectManagement } from "../../src"
+import { ManagementModule } from "../../src";
 
 describe("Inject Management", () => {
     let module: TestingModule;
@@ -14,7 +14,12 @@ describe("Inject Management", () => {
 
     beforeEach(async () => {
         module = await Test.createTestingModule({
-            imports: [ManagementModule.forRoot({ domain: "test.com", clientId: "testId", clientSecret: "testSecret" })],
+            imports: [ManagementModule.forRoot({
+                domain: 'test.com',
+                audience: 'test',
+                clientId: 'yourClientId',
+                clientAssertionSigningKey: 'yourClientAssertionSigningKey'
+            })],
             providers: [TestService],
         }).compile();
     });