@technomoron/apicore-server 1.0.0-beta.1

package/dist/esm/user/sequelize.js

@@ -0,0 +1,188 @@
+import { DataTypes, Model, Op, UniqueConstraintError } from 'sequelize';
+import { normalizeNumericUserId } from '../auth-api/user-id.js';
+import { integerIdType, tableOptions } from '../sequelize-utils.js';
+import { UserStore } from './base.js';
+export class AuthUserModel extends Model {
+}
+export function initAuthUserModel(sequelize, options = {}) {
+    const idType = integerIdType(sequelize);
+    AuthUserModel.init({
+        user_id: {
+            type: idType,
+            autoIncrement: true,
+            allowNull: false,
+            primaryKey: true
+        },
+        login: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            unique: true
+        },
+        email: {
+            type: DataTypes.STRING(100),
+            allowNull: false,
+            unique: true
+        },
+        password: {
+            type: DataTypes.STRING(255),
+            allowNull: false
+        }
+    }, {
+        ...tableOptions(sequelize, 'users', options.tablePrefix, { timestamps: false })
+    });
+    return AuthUserModel;
+}
+export class SequelizeUserStore extends UserStore {
+    constructor(options) {
+        super({
+            toPublic: options.toPublic,
+            bcryptRounds: options.bcryptRounds,
+            bcryptPepper: options.bcryptPepper
+        });
+        if (!options?.sequelize) {
+            throw new Error('SequelizeUserStore requires a configured Sequelize instance');
+        }
+        this.Users = options.userModel
+            ? options.userModel
+            : (options.userModelFactory ?? initAuthUserModel)(options.sequelize, {
+                tablePrefix: options.tablePrefix
+            });
+        this.recordMapper =
+            options.recordMapper ??
+                ((model) => SequelizeUserStore.mapModelToUser(model));
+    }
+    async findUser(identifier) {
+        const where = [];
+        try {
+            where.push({ user_id: this.normalizeUserId(identifier) });
+        }
+        catch {
+            // ignore
+        }
+        if (typeof identifier === 'string') {
+            where.push({ login: identifier });
+            where.push({ email: identifier });
+        }
+        if (where.length === 0) {
+            return null;
+        }
+        const model = await this.Users.findOne({ where: { [Op.or]: where } });
+        return model ? this.toUserRecord(model) : null;
+    }
+    async findById(id) {
+        try {
+            const model = await this.Users.findByPk(this.normalizeUserId(id));
+            return model ? this.toUserRecord(model) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async findByLoginOrEmail(loginOrEmail) {
+        const model = await this.Users.findOne({
+            where: { [Op.or]: [{ login: loginOrEmail }, { email: loginOrEmail }] }
+        });
+        return model ? this.toUserRecord(model) : null;
+    }
+    async createUser(input) {
+        const normalized = this.normalizeUserInput(input);
+        const { password, ...rest } = normalized;
+        const defaults = {
+            ...rest,
+            password: password ? await this.hashPassword(password) : ''
+        };
+        const providedId = input.user_id;
+        if (providedId !== undefined && providedId !== null && Number.isFinite(providedId)) {
+            defaults.user_id = Number(providedId);
+        }
+        try {
+            const model = await this.Users.create(defaults);
+            return this.toUserRecord(model);
+        }
+        catch (error) {
+            if (error instanceof UniqueConstraintError) {
+                throw new Error(`User with login ${rest.login} or email ${rest.email} already exists`);
+            }
+            throw error;
+        }
+    }
+    async upsertUser(input) {
+        const normalized = this.normalizeUserInput(input);
+        const providedId = input.user_id;
+        if (providedId !== undefined) {
+            const model = await this.Users.findByPk(Number(providedId));
+            if (!model) {
+                throw new Error(`User ${String(providedId)} not found`);
+            }
+            const next = { ...normalized };
+            if (normalized.password && normalized.password.length > 0) {
+                next.password = await this.hashPassword(normalized.password);
+            }
+            else {
+                delete next.password;
+            }
+            await model.set(next);
+            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);
+    }
+    async updateUser(id, patch) {
+        const model = await this.Users.findByPk(this.normalizeUserId(id));
+        if (!model) {
+            throw new Error(`User ${String(id)} not found`);
+        }
+        const updates = { ...patch };
+        if (patch.password && patch.password.length > 0) {
+            updates.password = await this.hashPassword(patch.password);
+        }
+        else {
+            delete updates.password;
+        }
+        await model.set(updates);
+        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) {
+        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;
+    }
+    getUserId(user) {
+        return user.user_id;
+    }
+    toUserRecord(model) {
+        return this.recordMapper(model);
+    }
+    static mapModelToUser(model) {
+        return {
+            user_id: model.get('user_id'),
+            login: model.get('login'),
+            email: model.get('email'),
+            password: model.get('password')
+        };
+    }
+    normalizeUserId(identifier) {
+        return normalizeNumericUserId(identifier);
+    }
+}

package/dist/esm/user/types.d.ts

@@ -0,0 +1,11 @@
+export interface BcryptHasherOptions {
+    rounds?: number;
+    pepper?: string;
+}
+export type CreateUserInput = Record<string, unknown> & {
+    login: string;
+    email: string;
+    password?: string;
+};
+export type UpdateUserInput = Partial<CreateUserInput>;
+export type PublicUserMapper<User, PublicUser> = (user: User) => PublicUser;

package/dist/esm/user/types.js

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