add entity_id and update provider

packages/authentication/integration-tests/__tests__/services/providers/username-password.spec.ts

@@ -51,7 +51,7 @@ describe("AuthenticationModuleService - AuthProvider", () => {
           provider: "usernamePassword",
           provider_metadata: {
             email,
-            password_hash: passwordHash,
+            password: passwordHash,
           },
         },
       ])

packages/authentication/src/initialize/index.ts

@@ -1,13 +1,14 @@
 import {
   ExternalModuleDeclaration,
   InternalModuleDeclaration,
-  MedusaModule,
   MODULE_PACKAGE_NAMES,
+  MedusaModule,
   Modules,
 } from "@medusajs/modules-sdk"
 import { IAuthenticationModuleService, ModulesSdkTypes } from "@medusajs/types"
-import { moduleDefinition } from "../module-definition"
+
 import { InitializeModuleInjectableDependencies } from "../types"
+import { moduleDefinition } from "../module-definition"
 
 export const initialize = async (
   options?:

packages/authentication/src/loaders/providers.ts

@@ -1,8 +1,10 @@
-import { LoaderOptions, ModulesSdkTypes } from "@medusajs/types"
-import { asClass } from "awilix"
 import * as defaultProviders from "@providers"
+
+import { LoaderOptions, ModulesSdkTypes } from "@medusajs/types"
+
 import { AuthProviderService } from "@services"
 import { ServiceTypes } from "@types"
+import { asClass } from "awilix"
 
 export default async ({
   container,
@@ -20,10 +22,18 @@ export default async ({
   const authProviderService: AuthProviderService = container.resolve(
     "authProviderService"
   )
+  let providers
 
-  const providers = await authProviderService.list({
-    provider: providersToLoad.map((p) => p.PROVIDER),
-  })
+  try {
+    providers = await authProviderService.list({
+      provider: providersToLoad.map((p) => p.PROVIDER),
+    })
+  } catch (error) {
+    if (error.name === "TableNotFoundException") {
+      // we are running loaders in migrations (or fail at a later point)
+      return
+    }
+  }
 
   const loadedProviders = new Map(providers.map((p) => [p.provider, p]))
 

packages/authentication/src/migrations/.snapshot-medusa-authentication.json

@@ -77,6 +77,15 @@
           "nullable": false,
           "mappedType": "text"
         },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "text",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": false,
+          "mappedType": "text"
+        },
         "provider_id": {
           "name": "provider_id",
           "type": "text",
@@ -117,6 +126,16 @@
       "name": "auth_user",
       "schema": "public",
       "indexes": [
+        {
+          "keyName": "IDX_auth_user_provider_entity_id",
+          "columnNames": [
+            "provider_id",
+            "entity_id"
+          ],
+          "composite": true,
+          "primary": false,
+          "unique": true
+        },
         {
           "keyName": "auth_user_pkey",
           "columnNames": [

packages/authentication/src/migrations/Migration20240115092929.ts

@@ -0,0 +1,15 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20240115092929 extends Migration {
+
+  async up(): Promise<void> {
+    this.addSql('alter table "auth_user" add column "entity_id" text not null;');
+    this.addSql('alter table "auth_user" add constraint "IDX_auth_user_provider_entity_id" unique ("provider_id", "entity_id");');
+  }
+
+  async down(): Promise<void> {
+    this.addSql('alter table "auth_user" drop constraint "IDX_auth_user_provider_entity_id";');
+    this.addSql('alter table "auth_user" drop column "entity_id";');
+  }
+
+}

packages/authentication/src/models/auth-user.ts

@@ -1,25 +1,32 @@
-import { generateEntityId } from "@medusajs/utils"
 import {
   BeforeCreate,
   Cascade,
   Entity,
+  Index,
   ManyToOne,
   OnInit,
   OptionalProps,
   PrimaryKey,
   Property,
+  Unique,
 } from "@mikro-orm/core"
+
 import AuthProvider from "./auth-provider"
+import { generateEntityId } from "@medusajs/utils"
 
 type OptionalFields = "provider_metadata" | "app_metadata" | "user_metadata"
 
 @Entity()
+@Unique({ properties: ["provider","entity_id" ], name: "IDX_auth_user_provider_entity_id" })
 export default class AuthUser {
   [OptionalProps]: OptionalFields
 
   @PrimaryKey({ columnType: "text" })
   id!: string
 
+  @Property({ columnType: "text" })
+  entity_id: string
+
   @ManyToOne(() => AuthProvider, {
     joinColumn: "provider",
     fieldName: "provider_id",

packages/authentication/src/providers/username-password.ts

@@ -1,11 +1,11 @@
-import Scrypt from "scrypt-kdf"
-
-import { AuthUserService } from "@services"
 import {
   AbstractAuthenticationModuleProvider,
   AuthenticationResponse,
 } from "@medusajs/types"
 
+import { AuthUserService } from "@services"
+import Scrypt from "scrypt-kdf"
+
 class UsernamePasswordProvider extends AbstractAuthenticationModuleProvider {
   public static PROVIDER = "usernamePassword"
   public static DISPLAY_NAME = "Username/Password Authentication"
@@ -19,9 +19,9 @@ class UsernamePasswordProvider extends AbstractAuthenticationModuleProvider {
   }
 
   async authenticate(
-    userData: Record<string, unknown>
+    userData: Record<string, any>
   ): Promise<AuthenticationResponse> {
-    const { email, password } = userData
+    const { email, password } = userData.body
 
     if (typeof password !== "string") {
       return {
@@ -37,11 +37,10 @@ class UsernamePasswordProvider extends AbstractAuthenticationModuleProvider {
       }
     }
 
-    const [authUser] = await this.authUserSerivce_.list({
-      provider_metadata: {
-        email,
-      },
-    })
+    const authUser = await this.authUserSerivce_.retrieveByProviderAndEntityId(
+      email,
+      UsernamePasswordProvider.PROVIDER
+    )
 
     const password_hash = authUser.provider_metadata?.password_hash
 

packages/authentication/src/services/auth-user.ts

@@ -25,19 +25,45 @@ export default class AuthUserService<TEntity extends AuthUser = AuthUser> {
 
   @InjectManager("authUserRepository_")
   async retrieve(
-    provider: string,
+    id: string,
     config: FindConfig<ServiceTypes.AuthUserDTO> = {},
     @MedusaContext() sharedContext: Context = {}
   ): Promise<TEntity> {
     return (await retrieveEntity<AuthUser, ServiceTypes.AuthUserDTO>({
-      id: provider,
+      id,
       entityName: AuthUser.name,
       repository: this.authUserRepository_,
       config,
       sharedContext,
     })) as TEntity
   }
 
+  @InjectManager("authUserRepository_")
+  async retrieveByProviderAndEntityId(
+    entityId: string,
+    provider: string,
+    config: FindConfig<ServiceTypes.AuthUserDTO> = {},
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<TEntity> {
+    const queryConfig = ModulesSdkUtils.buildQuery<AuthUser>(
+      { entity_id: entityId, provider },
+      { ...config, take: 1 }
+    )
+    const [result] = await this.authUserRepository_.find(
+      queryConfig,
+      sharedContext
+    )
+
+    if (!result) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `AuthUser with entity_id: "${entityId}" and provider: "${provider}" not found`
+      )
+    }
+
+    return result
+  }
+
   @InjectManager("authUserRepository_")
   async list(
     filters: ServiceTypes.FilterableAuthProviderProps = {},

packages/authentication/src/services/authentication-module.ts

@@ -367,11 +367,15 @@ export default class AuthenticationModuleService<
     provider: string,
     authenticationData: Record<string, unknown>,
     @MedusaContext() sharedContext: Context = {}
-  ): Promise<AuthenticationResponse> {
-    await this.retrieveAuthProvider(provider, {})
-
-    const registeredProvider =
-      this.getRegisteredAuthenticationProvider(provider)
+  ): Promise<AuthenticationResponse> {    
+    let registeredProvider 
+    try { 
+      await this.retrieveAuthProvider(provider, {})
+
+      registeredProvider = this.getRegisteredAuthenticationProvider(provider)
+    } catch (error) { 
+      return { success: false, error: error.message }
+    }
 
     return await registeredProvider.authenticate(authenticationData)
   }