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/core/utils/src/auth/abstract-auth-provider.ts

@@ -1,17 +1,15 @@
-import { AuthProviderScope, AuthenticationResponse } from "@medusajs/types"
+import {
+  AuthIdentityProviderService,
+  AuthenticationInput,
+  AuthenticationResponse,
+  IAuthProvider,
+} from "@medusajs/types"
 
-import { MedusaError } from "../common"
-
-export abstract class AbstractAuthModuleProvider {
-  public static PROVIDER: string
-  public static DISPLAY_NAME: string
+export abstract class AbstractAuthModuleProvider implements IAuthProvider {
+  private static PROVIDER: string
+  private static DISPLAY_NAME: string
 
   protected readonly container_: any
-  protected scopeConfig_: AuthProviderScope
-  protected scope_: string
-
-  private readonly scopes_: Record<string, AuthProviderScope>
-
   public get provider() {
     return (this.constructor as typeof AbstractAuthModuleProvider).PROVIDER
   }
@@ -20,43 +18,22 @@ export abstract class AbstractAuthModuleProvider {
     return (this.constructor as typeof AbstractAuthModuleProvider).DISPLAY_NAME
   }
 
-  protected constructor(
-    { scopes },
-    config: { provider: string; displayName: string }
-  ) {
+  protected constructor({}, config: { provider: string; displayName: string }) {
     this.container_ = arguments[0]
-    this.scopes_ = scopes
     ;(this.constructor as typeof AbstractAuthModuleProvider).PROVIDER ??=
       config.provider
     ;(this.constructor as typeof AbstractAuthModuleProvider).DISPLAY_NAME ??=
       config.displayName
   }
 
-  private validateScope(scope) {
-    if (!this.scopes_[scope]) {
-      throw new MedusaError(
-        MedusaError.Types.INVALID_ARGUMENT,
-        `Scope "${scope}" is not valid for provider ${this.provider}`
-      )
-    }
-  }
-
-  public withScope(scope: string) {
-    this.validateScope(scope)
-
-    const cloned = new (this.constructor as any)(this.container_)
-    cloned.scope_ = scope
-    cloned.scopeConfig_ = this.scopes_[scope]
-
-    return cloned
-  }
-
   abstract authenticate(
-    data: Record<string, unknown>
+    data: AuthenticationInput,
+    authIdentityProviderService: AuthIdentityProviderService
   ): Promise<AuthenticationResponse>
 
-  public validateCallback(
-    data: Record<string, unknown>
+  validateCallback(
+    data: AuthenticationInput,
+    authIdentityProviderService: AuthIdentityProviderService
   ): Promise<AuthenticationResponse> {
     throw new Error(
       `Callback authentication not implemented for provider ${this.provider}`