@technomoron/api-server-base 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/esm/{user → server/src/user}/base.d.ts

@@ -1,5 +1,6 @@
 import type { CreateUserInput, PublicUserMapper, UpdateUserInput } from './types.js';
 import type { AuthIdentifier } from '../auth-api/types.js';
+/** Base contract for user persistence backends. */
 export declare abstract class UserStore<User, PublicUser> {
     protected readonly toPublicUser: PublicUserMapper<User, PublicUser>;
     private readonly bcryptRounds;
@@ -13,14 +14,22 @@ export declare abstract class UserStore<User, PublicUser> {
     protected hashPassword(plain: string): Promise<string>;
     verifyPassword(plain: string, hashed: string): Promise<boolean>;
     protected normalizeUserInput(input: Partial<CreateUserInput>): CreateUserInput;
+    /** Find a user by id/login/email identifier. */
     abstract findUser(identifier: AuthIdentifier | string): Promise<User | null>;
+    /** Find a user by primary id only. */
     abstract findById(id: AuthIdentifier): Promise<User | null>;
+    /** Find a user by login or email value. */
     abstract findByLoginOrEmail(loginOrEmail: string): Promise<User | null>;
+    /** Create a new user record. */
     abstract createUser(input: CreateUserInput): Promise<User>;
     abstract upsertUser(input: CreateUserInput): Promise<User>;
+    /** Update selected user fields. */
     abstract updateUser(id: AuthIdentifier, patch: UpdateUserInput): Promise<User>;
+    /** Persist a password hash for the given user id. */
     abstract setPasswordHash(id: AuthIdentifier, hash: string): Promise<void>;
+    /** Extract the password hash from a user record. */
     abstract getPasswordHash(user: User): string | null;
+    /** Extract the stable user identifier from a user record. */
     abstract getUserId(user: User): AuthIdentifier;
     toPublic(user: User): PublicUser;
 }

package/dist/esm/{user → server/src/user}/base.js

@@ -1,5 +1,6 @@
 import { createHmac } from 'node:crypto';
 import bcrypt from 'bcryptjs';
+/** Base contract for user persistence backends. */
 export class UserStore {
     constructor(opts = {}) {
         this.toPublicUser = opts.toPublic ?? ((u) => u);

package/dist/esm/{user → server/src/user}/memory.js

@@ -41,11 +41,15 @@ export class MemoryUserStore extends UserStore {
             }
             const loginId = this.loginToId.get(identifier);
             if (loginId !== undefined) {
-                return cloneUser(this.usersById.get(loginId));
+                const loginUser = this.usersById.get(loginId);
+                if (loginUser)
+                    return cloneUser(loginUser);
             }
             const emailId = this.emailToId.get(identifier);
             if (emailId !== undefined) {
-                return cloneUser(this.usersById.get(emailId));
+                const emailUser = this.usersById.get(emailId);
+                if (emailUser)
+                    return cloneUser(emailUser);
             }
         }
         return null;
@@ -61,7 +65,19 @@ export class MemoryUserStore extends UserStore {
         }
     }
     async findByLoginOrEmail(loginOrEmail) {
-        return this.findUser(loginOrEmail);
+        const loginId = this.loginToId.get(loginOrEmail);
+        if (loginId !== undefined) {
+            const loginUser = this.usersById.get(loginId);
+            if (loginUser)
+                return cloneUser(loginUser);
+        }
+        const emailId = this.emailToId.get(loginOrEmail);
+        if (emailId !== undefined) {
+            const emailUser = this.usersById.get(emailId);
+            if (emailUser)
+                return cloneUser(emailUser);
+        }
+        return null;
     }
     async createUser(input) {
         const normalizedInput = this.normalizeUserInput(input);
@@ -115,9 +131,12 @@ export class MemoryUserStore extends UserStore {
                     throw new Error(`User with email ${updates.email} already exists`);
                 }
             }
-            if (normalizedInput.password) {
+            if (normalizedInput.password && normalizedInput.password.length > 0) {
                 updates.password = await this.hashPassword(normalizedInput.password);
             }
+            else {
+                updates.password = existing.password;
+            }
             this.persistUser(updates);
             return cloneUser(updates);
         }
@@ -129,9 +148,12 @@ export class MemoryUserStore extends UserStore {
             throw new Error(`User ${String(id)} not found`);
         }
         const updates = { ...user, ...patch };
-        if (patch.password) {
+        if (patch.password && patch.password.length > 0) {
             updates.password = await this.hashPassword(patch.password);
         }
+        else {
+            updates.password = user.password;
+        }
         this.persistUser(updates);
         return cloneUser(updates);
     }

package/dist/esm/{user → server/src/user}/sequelize.js

@@ -115,11 +115,22 @@ export class SequelizeUserStore extends UserStore {
                 throw new Error(`User ${String(providedId)} not found`);
             }
             const next = { ...normalized };
-            if (normalized.password) {
+            if (normalized.password && normalized.password.length > 0) {
                 next.password = await this.hashPassword(normalized.password);
             }
+            else {
+                delete next.password;
+            }
             await model.set(next);
-            await model.save();
+            try {
+                await model.save();
+            }
+            catch (error) {
+                if (error instanceof UniqueConstraintError) {
+                    throw new Error(`User with login ${normalized.login} or email ${normalized.email} already exists`);
+                }
+                throw error;
+            }
             return this.toUserRecord(model);
         }
         return this.createUser(input);
@@ -130,15 +141,29 @@ export class SequelizeUserStore extends UserStore {
             throw new Error(`User ${String(id)} not found`);
         }
         const updates = { ...patch };
-        if (patch.password) {
+        if (patch.password && patch.password.length > 0) {
             updates.password = await this.hashPassword(patch.password);
         }
+        else {
+            delete updates.password;
+        }
         await model.set(updates);
-        await model.save();
+        try {
+            await model.save();
+        }
+        catch (error) {
+            if (error instanceof UniqueConstraintError) {
+                throw new Error(`User with login or email already exists`);
+            }
+            throw error;
+        }
         return this.toUserRecord(model);
     }
     async setPasswordHash(id, hash) {
-        await this.Users.update({ password: hash }, { where: { user_id: this.normalizeUserId(id) } });
+        const [affected] = await this.Users.update({ password: hash }, { where: { user_id: this.normalizeUserId(id) } });
+        if (affected === 0) {
+            throw new Error(`User ${String(id)} not found`);
+        }
     }
     getPasswordHash(user) {
         return user.password;

package/dist/esm/server/src/user/types.js

@@ -0,0 +1 @@
+export {};