Revamp the authentication setup (#7419)

* feat: Add email pass authentication provider package

* feat: Revamp auth module and remove concept of scope

* feat: Revamp the auth module to be more standardized in how providers are loaded

* feat: Switch from scope to actor type for authentication

* feat: Add support for per-actor auth methods

* feat: Add emailpass auth provider by default

* fix: Add back app_metadata in auth module

packages/modules/auth/src/loaders/providers.ts

@@ -1,21 +1,26 @@
-import * as defaultProviders from "@providers"
+import EmailPassProvider from "@medusajs/auth-emailpass"
 
+import { LoaderOptions, ModulesSdkTypes, ModuleProvider } from "@medusajs/types"
+import { Lifetime, asFunction, asValue } from "awilix"
+import { moduleProviderLoader } from "@medusajs/modules-sdk"
 import {
-  AuthModuleProviderConfig,
-  AuthProviderScope,
-  LoaderOptions,
-  ModulesSdkTypes,
-} from "@medusajs/types"
-import {
-  AwilixContainer,
-  ClassOrFunctionReturning,
-  Constructor,
-  Resolver,
-  asClass,
-} from "awilix"
+  AuthIdentifiersRegistrationName,
+  AuthProviderRegistrationPrefix,
+} from "@types"
 
-type AuthModuleProviders = {
-  providers: AuthModuleProviderConfig[]
+const registrationFn = async (klass, container, pluginOptions) => {
+  Object.entries(pluginOptions.config || []).map(([name, config]) => {
+    container.register({
+      [AuthProviderRegistrationPrefix + name]: asFunction(
+        (cradle) => new klass(cradle, config),
+        {
+          lifetime: klass.LIFE_TIME || Lifetime.SINGLETON,
+        }
+      ),
+    })
+
+    container.registerAdd(AuthIdentifiersRegistrationName, asValue(name))
+  })
 }
 
 export default async ({
@@ -25,48 +30,28 @@ export default async ({
   (
     | ModulesSdkTypes.ModuleServiceInitializeOptions
     | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  ) &
-    AuthModuleProviders
+  ) & { providers: ModuleProvider[] }
 >): Promise<void> => {
-  const providerMap = new Map(
-    options?.providers?.map((provider) => [provider.name, provider.scopes]) ??
-      []
-  )
+  // TODO: Temporary settings used by the starter, remove once the auth module is updated
+  const isLegacyOptions =
+    options?.providers?.length && !!(options?.providers[0] as any)?.name
 
-  // if(options?.providers?.length) {
-  // TODO: implement plugin provider registration
-  // }
+  // Note: For now we want to inject some providers out of the box
+  const providerConfig = [
+    {
+      resolve: EmailPassProvider,
+      options: {
+        config: {
+          emailpass: {},
+        },
+      },
+    },
+    ...(isLegacyOptions ? [] : options?.providers ?? []),
+  ]
 
-  const providersToLoad = Object.values(defaultProviders)
-
-  for (const provider of providersToLoad) {
-    container.register({
-      [`auth_provider_${provider.PROVIDER}`]: asClass(
-        provider as Constructor<any>
-      )
-        .singleton()
-        .inject(() => ({ scopes: providerMap.get(provider.PROVIDER) ?? {} })),
-    })
-  }
-
-  container.register({
-    [`auth_providers`]: asArray(providersToLoad, providerMap),
+  await moduleProviderLoader({
+    container,
+    providers: providerConfig,
+    registerServiceFn: registrationFn,
   })
 }
-
-function asArray(
-  resolvers: (ClassOrFunctionReturning<unknown> | Resolver<unknown>)[],
-  providerScopeMap: Map<string, Record<string, AuthProviderScope>>
-): { resolve: (container: AwilixContainer) => unknown[] } {
-  return {
-    resolve: (container: AwilixContainer) =>
-      resolvers.map((resolver) =>
-        asClass(resolver as Constructor<any>)
-          .inject(() => ({
-            // @ts-ignore
-            scopes: providerScopeMap.get(resolver.PROVIDER) ?? {},
-          }))
-          .resolve(container)
-      ),
-  }
-}