@deplois/api 0.0.0-stage → 0.0.1

package/dist/database/identity.store.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMIdentityStore = void 0;
+const user_entity_1 = require("./user.entity");
+const session_entity_1 = require("./session.entity");
+const metadata_1 = require("./metadata");
+class TypeORMIdentityStore {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async createUser(user) {
+        await this.database.getRepository(user_entity_1.UserEntity).save(this.database.getRepository(user_entity_1.UserEntity).create(user));
+    }
+    async getUser(id) {
+        return this.database.getRepository(user_entity_1.UserEntity).findOneBy({ id, isActive: true });
+    }
+    async updateUser(id, patch, now) {
+        return this.database.transaction(async (manager) => {
+            const repository = manager.getRepository(user_entity_1.UserEntity);
+            const user = await repository.findOne({ where: { id, isActive: true }, lock: { mode: 'pessimistic_write' } });
+            if (!user)
+                return null;
+            if (patch.profile)
+                user.profile = (0, metadata_1.mergeMetadata)(user.profile, patch.profile);
+            if (patch.metadata)
+                user.metadata = (0, metadata_1.mergeMetadata)(user.metadata, patch.metadata);
+            if (patch.isActive === false)
+                Object.assign(user, { isActive: false, deletedDate: now });
+            await repository.save(user);
+            return user;
+        });
+    }
+    async createSession(session) {
+        const { userIds, ...data } = session;
+        // Newly issued sessions are anonymous. User attachment requires the locked mutation below.
+        if (userIds.length)
+            throw new Error('Create an anonymous session before attaching users.');
+        await this.database.getRepository(session_entity_1.SessionEntity).save(this.database.getRepository(session_entity_1.SessionEntity).create(data));
+    }
+    async getSession(tokenHash) {
+        const session = await this.database.getRepository(session_entity_1.SessionEntity).findOne({ where: { tokenHash }, relations: { users: true } });
+        if (!session)
+            return null;
+        const { users, ...data } = session;
+        return { ...data, tokenHash, userIds: users.filter(user => user.isActive).map(user => user.id) };
+    }
+    async updateSession(id, update, now, tokenHash) {
+        return this.database.transaction(async (manager) => {
+            const repository = manager.getRepository(session_entity_1.SessionEntity);
+            // Lock only the session row; outer-joined nullable relations cannot be FOR UPDATE locked in PostgreSQL.
+            const session = await repository.createQueryBuilder('session').addSelect('session.tokenHash').where('session.id = :id', { id }).setLock('pessimistic_write').getOne();
+            if (!session || (tokenHash !== undefined && tokenHash !== session.tokenHash))
+                return null;
+            if (update.type === 'revoke') {
+                if (!session.revokedDate) {
+                    session.revokedDate = now;
+                    await repository.save(session);
+                }
+            }
+            else {
+                if (session.revokedDate || session.expiresDate.getTime() <= now.getTime())
+                    return null;
+                switch (update.type) {
+                    case 'touch':
+                        session.lastUsedDate = new Date(Math.max(session.lastUsedDate.getTime(), now.getTime()));
+                        session.expiresDate = new Date(Math.max(session.expiresDate.getTime(), update.expiresDate.getTime()));
+                        await repository.save(session);
+                        break;
+                    case 'addUser': {
+                        const user = await manager.getRepository(user_entity_1.UserEntity).findOne({ where: { id: update.userId, isActive: true }, lock: { mode: 'pessimistic_read' } });
+                        if (!user)
+                            return null;
+                        const existing = await manager.createQueryBuilder().relation(session_entity_1.SessionEntity, 'users').of(id).loadMany();
+                        if (!existing.some(item => item.id === user.id))
+                            await manager.createQueryBuilder().relation(session_entity_1.SessionEntity, 'users').of(id).add(user.id);
+                        Object.assign(session, { tokenHash: update.tokenHash });
+                        await repository.save(session);
+                        break;
+                    }
+                    case 'removeUser':
+                        await manager.createQueryBuilder().relation(session_entity_1.SessionEntity, 'users').of(id).remove(update.userId);
+                        break;
+                }
+            }
+            const users = await manager.createQueryBuilder().relation(session_entity_1.SessionEntity, 'users').of(id).loadMany();
+            return { ...session, userIds: users.filter(user => user.isActive && !user.deletedDate).map(user => user.id) };
+        });
+    }
+}
+exports.TypeORMIdentityStore = TypeORMIdentityStore;

package/dist/database/index.d.ts

@@ -0,0 +1,5 @@
+export * from './user.entity';
+export * from './session.entity';
+export * from './identity.store';
+export * from './client';
+export * from './metadata';

package/dist/database/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./user.entity"), exports);
+__exportStar(require("./session.entity"), exports);
+__exportStar(require("./identity.store"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./metadata"), exports);

package/dist/database/metadata.d.ts

@@ -0,0 +1 @@
+export declare function mergeMetadata(current: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;

package/dist/database/metadata.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMetadata = mergeMetadata;
+// Merge object patches. An explicit undefined removes a key; null is a stored value.
+function mergeMetadata(current, patch) {
+    const result = { ...current };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            delete result[key];
+        else {
+            const previous = result[key];
+            Object.defineProperty(result, key, {
+                value: value != null && Object.getPrototypeOf(value) === Object.prototype
+                    ? mergeMetadata(previous != null && Object.getPrototypeOf(previous) === Object.prototype ? previous : {}, value)
+                    : value,
+                writable: true, configurable: true, enumerable: true
+            });
+        }
+    }
+    return result;
+}

package/dist/database/session.entity.d.ts

@@ -0,0 +1,11 @@
+import { UserEntity } from './user.entity';
+export declare class SessionEntity {
+    readonly id: string;
+    readonly tokenHash: string;
+    users: UserEntity[];
+    metadata: Record<string, unknown>;
+    readonly createdDate: Date;
+    lastUsedDate: Date;
+    expiresDate: Date;
+    revokedDate: Date | null;
+}

package/dist/database/session.entity.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionEntity = void 0;
+const typeorm_1 = require("typeorm");
+const user_entity_1 = require("./user.entity");
+let SessionEntity = class SessionEntity {
+    id;
+    tokenHash;
+    users;
+    metadata;
+    createdDate;
+    lastUsedDate;
+    expiresDate;
+    revokedDate;
+};
+exports.SessionEntity = SessionEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], SessionEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'token_hash', type: 'varchar', length: 64, unique: true, select: false }),
+    __metadata("design:type", String)
+], SessionEntity.prototype, "tokenHash", void 0);
+__decorate([
+    (0, typeorm_1.ManyToMany)(() => user_entity_1.UserEntity),
+    (0, typeorm_1.JoinTable)({ name: 'api_session_users', joinColumn: { name: 'session_id' }, inverseJoinColumn: { name: 'user_id' } }),
+    __metadata("design:type", Array)
+], SessionEntity.prototype, "users", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', default: {} }),
+    __metadata("design:type", Object)
+], SessionEntity.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ name: 'created_date', type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], SessionEntity.prototype, "createdDate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'last_used_date', type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], SessionEntity.prototype, "lastUsedDate", void 0);
+__decorate([
+    (0, typeorm_1.Index)(),
+    (0, typeorm_1.Column)({ name: 'expires_date', type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], SessionEntity.prototype, "expiresDate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'revoked_date', type: 'timestamptz', nullable: true, default: null }),
+    __metadata("design:type", Object)
+], SessionEntity.prototype, "revokedDate", void 0);
+exports.SessionEntity = SessionEntity = __decorate([
+    (0, typeorm_1.Entity)('api_session')
+], SessionEntity);

package/dist/database/user.entity.d.ts

@@ -0,0 +1,10 @@
+import type { User } from '../identity/interface';
+export declare class UserEntity {
+    readonly id: string;
+    profile: User['profile'];
+    metadata: Record<string, unknown>;
+    isActive: boolean;
+    readonly createdDate: Date;
+    readonly updatedDate: Date;
+    readonly deletedDate: Date | null;
+}

package/dist/database/user.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEntity = void 0;
+const typeorm_1 = require("typeorm");
+let UserEntity = class UserEntity {
+    id;
+    profile;
+    metadata;
+    isActive;
+    createdDate;
+    updatedDate;
+    deletedDate;
+};
+exports.UserEntity = UserEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], UserEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', default: {} }),
+    __metadata("design:type", Object)
+], UserEntity.prototype, "profile", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', default: {} }),
+    __metadata("design:type", Object)
+], UserEntity.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'is_active', type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], UserEntity.prototype, "isActive", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ name: 'created_date', type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], UserEntity.prototype, "createdDate", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ name: 'updated_date', type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], UserEntity.prototype, "updatedDate", void 0);
+__decorate([
+    (0, typeorm_1.DeleteDateColumn)({ name: 'deleted_date', type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Object)
+], UserEntity.prototype, "deletedDate", void 0);
+exports.UserEntity = UserEntity = __decorate([
+    (0, typeorm_1.Entity)('api_user')
+], UserEntity);

package/dist/identity/identity.plugin.d.ts

@@ -0,0 +1,31 @@
+import type { PluginResult } from '../interface';
+import type { IdentityOptions, IdentityStore, Session, User } from './interface';
+export declare function createIdentityPlugins(store: IdentityStore, options?: IdentityOptions): {
+    userPlugin: {
+        pluginName: string;
+        create(input?: {
+            profile?: User["profile"];
+            metadata?: User["metadata"];
+        }): Promise<PluginResult<User>>;
+        get(userId: string): Promise<PluginResult<User>>;
+        update(userId: string, patch: Pick<Partial<User>, "profile" | "metadata">): Promise<PluginResult<User>>;
+        disable(userId: string): Promise<PluginResult<null>>;
+    };
+    sessionPlugin: {
+        pluginName: string;
+        create(input?: {
+            userId?: string;
+            metadata?: Record<string, unknown>;
+        }): Promise<PluginResult<{
+            token: string;
+            session: Omit<Session, "tokenHash">;
+        }>>;
+        get(token: string): Promise<PluginResult<Omit<Session, "tokenHash">>>;
+        addUser(token: string, userId: string): Promise<PluginResult<{
+            token: string;
+            session: Omit<Session, "tokenHash">;
+        }>>;
+        removeUser(token: string, userId: string): Promise<PluginResult<null>>;
+        revoke(token: string): Promise<PluginResult<null>>;
+    };
+};

package/dist/identity/identity.plugin.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentityPlugins = createIdentityPlugins;
+const node_crypto_1 = require("node:crypto");
+const app_exception_1 = require("../system/error/app.exception");
+const error_plugin_1 = __importDefault(require("../system/error/error.plugin"));
+const hash = (token) => (0, node_crypto_1.createHash)('sha256').update(token).digest('hex');
+function createIdentityPlugins(store, options = {}) {
+    const sessionDuration = options.sessionDuration ?? 60 * 60 * 24;
+    const now = options.now ?? (() => new Date());
+    if (!Number.isSafeInteger(sessionDuration) || sessionDuration <= 0) {
+        throw new Error('Durations must be positive integers in seconds.');
+    }
+    const userPlugin = {
+        pluginName: 'user.plugin',
+        async create(input = {}) {
+            try {
+                const date = now();
+                const user = {
+                    id: (0, node_crypto_1.randomUUID)(), profile: input.profile ?? {}, metadata: input.metadata ?? {},
+                    isActive: true, createdDate: date, updatedDate: date, deletedDate: null
+                };
+                await store.createUser(user);
+                return { success: true, data: user };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async get(userId) {
+            try {
+                const user = await store.getUser(userId);
+                if (!user?.isActive)
+                    throw error_plugin_1.default.createException('USER_NOT_FOUND', 'User not found.', 404);
+                return { success: true, data: user };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async update(userId, patch) {
+            try {
+                const user = await store.updateUser(userId, patch, now());
+                if (!user?.isActive)
+                    throw error_plugin_1.default.createException('USER_NOT_FOUND', 'User not found.', 404);
+                return { success: true, data: user };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async disable(userId) {
+            try {
+                const date = now();
+                const user = await store.updateUser(userId, { isActive: false }, date);
+                if (!user)
+                    throw error_plugin_1.default.createException('USER_NOT_FOUND', 'User not found.', 404);
+                return { success: true, data: null };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        }
+    };
+    const sessionPlugin = {
+        pluginName: 'session.plugin',
+        async create(input = {}) {
+            try {
+                const token = (0, node_crypto_1.randomBytes)(96).toString('base64url');
+                const date = now();
+                const session = {
+                    id: (0, node_crypto_1.randomUUID)(), tokenHash: hash(token), userIds: [], metadata: input.metadata ?? {},
+                    createdDate: date, lastUsedDate: date, expiresDate: new Date(date.getTime() + sessionDuration * 1000), revokedDate: null
+                };
+                await store.createSession(session);
+                if (input.userId) {
+                    const result = await sessionPlugin.addUser(token, input.userId);
+                    if (!result.success) {
+                        await store.updateSession(session.id, { type: 'revoke' }, now(), hash(token));
+                        throw result.error;
+                    }
+                    return result;
+                }
+                const { tokenHash, ...data } = session;
+                return { success: true, data: { token, session: data } };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async get(token) {
+            try {
+                const session = await store.getSession(hash(token));
+                const date = now();
+                if (!session || session.revokedDate)
+                    throw error_plugin_1.default.createException('WRONG_SESSION', 'Wrong session.');
+                if (session.expiresDate.getTime() <= date.getTime())
+                    throw error_plugin_1.default.createException('EXPIRED_SESSION', 'Session expired.', 401);
+                const updated = await store.updateSession(session.id, { type: 'touch', expiresDate: new Date(date.getTime() + sessionDuration * 1000) }, date, hash(token));
+                if (!updated)
+                    throw error_plugin_1.default.createException('WRONG_SESSION', 'Session is no longer active.');
+                const { tokenHash, ...data } = updated;
+                return { success: true, data };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        // Call only after another module has authenticated this user.
+        async addUser(token, userId) {
+            try {
+                const user = await userPlugin.get(userId);
+                if (!user.success)
+                    throw user.error;
+                const session = await sessionPlugin.get(token);
+                if (!session.success)
+                    throw session.error;
+                const newToken = (0, node_crypto_1.randomBytes)(96).toString('base64url');
+                const updated = await store.updateSession(session.data.id, { type: 'addUser', userId, tokenHash: hash(newToken) }, now(), hash(token));
+                if (!updated)
+                    throw error_plugin_1.default.createException('WRONG_SESSION', 'Session is no longer active.');
+                const { tokenHash, ...data } = updated;
+                return { success: true, data: { token: newToken, session: data } };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async removeUser(token, userId) {
+            try {
+                const session = await sessionPlugin.get(token);
+                if (!session.success)
+                    throw session.error;
+                if (!await store.updateSession(session.data.id, { type: 'removeUser', userId }, now(), hash(token)))
+                    throw error_plugin_1.default.createException('WRONG_SESSION', 'Session is no longer active.');
+                return { success: true, data: null };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        },
+        async revoke(token) {
+            try {
+                const session = await store.getSession(hash(token));
+                if (session)
+                    await store.updateSession(session.id, { type: 'revoke' }, now(), hash(token));
+                return { success: true, data: null };
+            }
+            catch (error) {
+                return { success: false, error: toError(error) };
+            }
+        }
+    };
+    return { userPlugin, sessionPlugin };
+}
+function toError(error) {
+    return error instanceof Error ? error : new app_exception_1.AppException({ code: 'INTERNAL_SERVER_ERROR', message: 'An internal server error occurred.' }, 500, { cause: error });
+}

package/dist/identity/identity.service.d.ts

@@ -0,0 +1,33 @@
+import { APIOptions } from '../options';
+export declare class IdentityService {
+    private readonly options;
+    constructor(options: APIOptions);
+    get userPlugin(): {
+        pluginName: string;
+        create(input?: {
+            profile?: import("./interface").User["profile"];
+            metadata?: import("./interface").User["metadata"];
+        }): Promise<import("..").PluginResult<import("./interface").User>>;
+        get(userId: string): Promise<import("..").PluginResult<import("./interface").User>>;
+        update(userId: string, patch: Pick<Partial<import("./interface").User>, "profile" | "metadata">): Promise<import("..").PluginResult<import("./interface").User>>;
+        disable(userId: string): Promise<import("..").PluginResult<null>>;
+    };
+    get sessionPlugin(): {
+        pluginName: string;
+        create(input?: {
+            userId?: string;
+            metadata?: Record<string, unknown>;
+        }): Promise<import("..").PluginResult<{
+            token: string;
+            session: Omit<import("./interface").Session, "tokenHash">;
+        }>>;
+        get(token: string): Promise<import("..").PluginResult<Omit<import("./interface").Session, "tokenHash">>>;
+        addUser(token: string, userId: string): Promise<import("..").PluginResult<{
+            token: string;
+            session: Omit<import("./interface").Session, "tokenHash">;
+        }>>;
+        removeUser(token: string, userId: string): Promise<import("..").PluginResult<null>>;
+        revoke(token: string): Promise<import("..").PluginResult<null>>;
+    };
+    private get plugins();
+}

package/dist/identity/identity.service.js

@@ -0,0 +1,36 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityService = void 0;
+const common_1 = require("@nestjs/common");
+const options_1 = require("../options");
+let IdentityService = class IdentityService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get userPlugin() { return this.plugins.userPlugin; }
+    get sessionPlugin() { return this.plugins.sessionPlugin; }
+    get plugins() {
+        if (!this.options.identity)
+            throw new Error('Identity store is not configured.');
+        return this.options.identity;
+    }
+};
+exports.IdentityService = IdentityService;
+exports.IdentityService = IdentityService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(options_1.API_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], IdentityService);

package/dist/identity/interface.d.ts

@@ -0,0 +1,49 @@
+export interface User {
+    id: string;
+    profile: {
+        fullName?: string;
+        emailAddress?: string;
+        phoneNumber?: string;
+        imageUrl?: string;
+    };
+    metadata: Record<string, unknown>;
+    isActive: boolean;
+    createdDate: Date;
+    updatedDate: Date;
+    deletedDate: Date | null;
+}
+export interface Session {
+    id: string;
+    tokenHash: string;
+    userIds: string[];
+    metadata: Record<string, unknown>;
+    createdDate: Date;
+    lastUsedDate: Date;
+    expiresDate: Date;
+    revokedDate: Date | null;
+}
+export type SessionUpdate = {
+    type: 'touch';
+    expiresDate: Date;
+} | {
+    type: 'addUser';
+    userId: string;
+    tokenHash: string;
+} | {
+    type: 'removeUser';
+    userId: string;
+} | {
+    type: 'revoke';
+};
+export interface IdentityStore {
+    createUser(user: User): Promise<void>;
+    getUser(id: string): Promise<User | null>;
+    updateUser(id: string, patch: Pick<Partial<User>, 'profile' | 'metadata' | 'isActive'>, now: Date): Promise<User | null>;
+    createSession(session: Session): Promise<void>;
+    getSession(tokenHash: string): Promise<Session | null>;
+    updateSession(id: string, update: SessionUpdate, now: Date, tokenHash?: string): Promise<Session | null>;
+}
+export interface IdentityOptions {
+    sessionDuration?: number;
+    now?: () => Date;
+}

package/dist/identity/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './api.module';
+export * from './options';
+export * from './interface';
+export * from './system/error/app.exception';
+export * from './system/error/error-code.enum';
+export { default as errorPlugin } from './system/error/error.plugin';
+export * from './system/filter/http-exception.filter';
+export * from './system/interceptor/response.interceptor';
+export * from './system/pipe/body-validation.pipe';
+export * from './system/logger/request.logger';
+export * from './system/guard/session.guard';
+export * from './system/decorator/raw-response.decorator';
+export * from './identity/interface';
+export * from './identity/identity.plugin';
+export * from './identity/identity.service';
+export * from './system/guard/user.guard';
+export * from './session.module';
+export * from './create-api';
+export * from './system/logger/file.logger';