@loomcore/api 0.1.53 → 0.1.57

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -0,0 +1,436 @@
+import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext } from '@loomcore/common/models';
+import { PostgresDatabase } from '../postgres.database.js';
+import { AuthService, OrganizationService } from '../../../services/index.js';
+export const getPostgresInitialSchema = (config) => {
+    const migrations = [];
+    const isMultiTenant = config.app.isMultiTenant === true;
+    if (isMultiTenant) {
+        migrations.push({
+            name: '00000000000001_schema-organizations',
+            up: async ({ context: pool }) => {
+                await pool.query(`
+          CREATE TABLE IF NOT EXISTS "organizations" (
+            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            "name" VARCHAR(255) NOT NULL UNIQUE,
+            "code" VARCHAR(255) NOT NULL UNIQUE,
+            "description" TEXT,
+            "status" INTEGER NOT NULL,
+            "isMetaOrg" BOOLEAN NOT NULL,
+            "authToken" TEXT,
+            "_created" TIMESTAMPTZ NOT NULL,
+            "_createdBy" INTEGER NOT NULL,
+            "_updated" TIMESTAMPTZ NOT NULL,
+            "_updatedBy" INTEGER NOT NULL,
+            "_deleted" TIMESTAMPTZ,
+            "_deletedBy" INTEGER
+          )
+        `);
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "organizations"');
+            }
+        });
+    }
+    migrations.push({
+        name: '00000000000002_schema-users',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const uniqueConstraint = isMultiTenant
+                ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
+                : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "users" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "email" VARCHAR(255) NOT NULL,
+          "firstName" VARCHAR(255),
+          "lastName" VARCHAR(255),
+          "displayName" VARCHAR(255),
+          "password" VARCHAR(255) NOT NULL,
+          "_lastLoggedIn" TIMESTAMPTZ,
+          "_lastPasswordChange" TIMESTAMPTZ,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          ${uniqueConstraint}
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "users"');
+        }
+    });
+    migrations.push({
+        name: '00000000000003_schema-refresh-tokens',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "refreshTokens" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "token" VARCHAR(255) NOT NULL,
+          "deviceId" VARCHAR(255) NOT NULL,
+          "userId" INTEGER NOT NULL,
+          "expiresOn" BIGINT NOT NULL,
+          "created" TIMESTAMPTZ NOT NULL,
+          "createdBy" INTEGER NOT NULL,
+          CONSTRAINT "fk_refreshTokens_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "refreshTokens"');
+        }
+    });
+    migrations.push({
+        name: '00000000000004_schema-roles',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const uniqueConstraint = isMultiTenant
+                ? 'CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")'
+                : 'CONSTRAINT "uk_roles_name" UNIQUE ("name")';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "roles" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          ${uniqueConstraint}
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "roles"');
+        }
+    });
+    migrations.push({
+        name: '00000000000005_schema-user-roles',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const uniqueConstraint = isMultiTenant
+                ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "userId", "roleId")'
+                : 'CONSTRAINT "uk_user_roles" UNIQUE ("userId", "roleId")';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "user_roles" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "userId" INTEGER NOT NULL,
+          "roleId" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "user_roles"');
+        }
+    });
+    migrations.push({
+        name: '00000000000006_schema-features',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const uniqueConstraint = isMultiTenant
+                ? 'CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")'
+                : 'CONSTRAINT "uk_features" UNIQUE ("name")';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "features" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          ${uniqueConstraint}
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "features"');
+        }
+    });
+    migrations.push({
+        name: '00000000000007_schema-authorizations',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const uniqueConstraint = isMultiTenant
+                ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "roleId", "featureId")'
+                : 'CONSTRAINT "uk_authorizations" UNIQUE ("roleId", "featureId")';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "authorizations" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "roleId" INTEGER NOT NULL,
+          "featureId" INTEGER NOT NULL,
+          "startDate" TIMESTAMPTZ,
+          "endDate" TIMESTAMPTZ,
+          "config" JSONB,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "authorizations"');
+        }
+    });
+    if (isMultiTenant && config.app.metaOrgName && config.app.metaOrgCode) {
+        migrations.push({
+            name: '00000000000008_data-meta-org',
+            up: async ({ context: pool }) => {
+                const result = await pool.query(`
+          INSERT INTO "organizations" ("name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
+          VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
+          RETURNING "_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy"
+        `, [config.app.metaOrgName, config.app.metaOrgCode]);
+                if (result.rowCount === 0) {
+                    throw new Error('Failed to create meta organization');
+                }
+                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', result.rows[0]);
+            },
+            down: async ({ context: pool }) => {
+                await pool.query(`DELETE FROM "organizations" WHERE "isMetaOrg" = TRUE`);
+            }
+        });
+    }
+    if (config.adminUser?.email && config.adminUser?.password) {
+        migrations.push({
+            name: '00000000000009_data-admin-user',
+            up: async ({ context: pool }) => {
+                if (!config.adminUser?.email || !config.adminUser?.password) {
+                    throw new Error('Admin user email and password must be provided in config');
+                }
+                const client = await pool.connect();
+                try {
+                    const database = new PostgresDatabase(client);
+                    const authService = new AuthService(database);
+                    let systemUserContext = getSystemUserContext();
+                    if (!systemUserContext) {
+                        throw new Error('SystemUserContext has not been initialized. For non-multi-tenant setups, initialize it before running migrations.');
+                    }
+                    if (isMultiTenant) {
+                        if (!systemUserContext.organization?._id) {
+                            const organizationService = new OrganizationService(database);
+                            const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+                            if (metaOrg) {
+                                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', metaOrg);
+                                systemUserContext = getSystemUserContext();
+                            }
+                            if (!systemUserContext?.organization?._id) {
+                                throw new Error('Cannot create admin user: Multi-tenant mode is enabled but meta-org does not exist. Ensure metaOrgName and metaOrgCode are provided in config so the meta-org migration runs before the admin-user migration.');
+                            }
+                        }
+                    }
+                    const userData = {
+                        email: config.adminUser.email,
+                        password: config.adminUser.password,
+                        firstName: 'Admin',
+                        lastName: 'User',
+                        displayName: 'Admin User',
+                    };
+                    if (isMultiTenant && systemUserContext.organization?._id) {
+                        userData._orgId = systemUserContext.organization._id;
+                    }
+                    await authService.createUser(systemUserContext, userData);
+                }
+                finally {
+                    client.release();
+                }
+            },
+            down: async ({ context: pool }) => {
+                if (!config.adminUser?.email)
+                    return;
+                const result = await pool.query(`DELETE FROM "users" WHERE "email" = $1`, [config.adminUser.email]);
+            }
+        });
+    }
+    if (config.adminUser?.email) {
+        migrations.push({
+            name: '00000000000010_data-admin-authorizations',
+            up: async ({ context: pool }) => {
+                if (!config.adminUser?.email) {
+                    throw new Error('Admin user email not found in config');
+                }
+                const client = await pool.connect();
+                try {
+                    const database = new PostgresDatabase(client);
+                    const organizationService = new OrganizationService(database);
+                    const authService = new AuthService(database);
+                    const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
+                    if (isMultiTenant && !metaOrg) {
+                        throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
+                    }
+                    const adminUser = await authService.getUserByEmail(config.adminUser.email);
+                    if (!adminUser) {
+                        throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
+                    }
+                    await client.query('BEGIN');
+                    try {
+                        const roleResult = isMultiTenant
+                            ? await client.query(`
+                  INSERT INTO "roles" ("_orgId", "name")
+                  VALUES ($1, 'admin')
+                  RETURNING "_id"
+                `, [metaOrg._id])
+                            : await client.query(`
+                  INSERT INTO "roles" ("name")
+                  VALUES ('admin')
+                  RETURNING "_id"
+                `);
+                        if (roleResult.rowCount === 0) {
+                            throw new Error('Failed to create admin role');
+                        }
+                        const roleId = roleResult.rows[0]._id;
+                        const userRoleResult = isMultiTenant
+                            ? await client.query(`
+                  INSERT INTO "user_roles" ("_orgId", "userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                `, [metaOrg._id, adminUser._id, roleId])
+                            : await client.query(`
+                  INSERT INTO "user_roles" ("userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                `, [adminUser._id, roleId]);
+                        if (userRoleResult.rowCount === 0) {
+                            throw new Error('Failed to create user role');
+                        }
+                        const featureResult = isMultiTenant
+                            ? await client.query(`
+                  INSERT INTO "features" ("_orgId", "name")
+                  VALUES ($1, 'admin')
+                  RETURNING "_id"
+                `, [metaOrg._id])
+                            : await client.query(`
+                  INSERT INTO "features" ("name")
+                  VALUES ('admin')
+                  RETURNING "_id"
+                `);
+                        if (featureResult.rowCount === 0) {
+                            throw new Error('Failed to create admin feature');
+                        }
+                        const featureId = featureResult.rows[0]._id;
+                        const authorizationResult = isMultiTenant
+                            ? await client.query(`
+                  INSERT INTO "authorizations" (
+                    "_orgId", "roleId", "featureId", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                  )
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                `, [metaOrg._id, roleId, featureId])
+                            : await client.query(`
+                  INSERT INTO "authorizations" (
+                    "roleId", "featureId", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                  )
+                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                `, [roleId, featureId]);
+                        if (authorizationResult.rowCount === 0) {
+                            throw new Error('Failed to create admin authorization');
+                        }
+                        await client.query('COMMIT');
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw error;
+                    }
+                }
+                finally {
+                    client.release();
+                }
+            },
+            down: async ({ context: pool }) => {
+                const client = await pool.connect();
+                try {
+                    const database = new PostgresDatabase(client);
+                    const organizationService = new OrganizationService(database);
+                    const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
+                    if (isMultiTenant && !metaOrg)
+                        return;
+                    await client.query('BEGIN');
+                    try {
+                        if (isMultiTenant) {
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "_orgId" = $1 
+                AND "featureId" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+                AND "roleId" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+              `, [metaOrg._id]);
+                            await client.query(`
+                DELETE FROM "features" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
+              `, [metaOrg._id]);
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "_orgId" = $1 
+                AND "roleId" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+              `, [metaOrg._id]);
+                            await client.query(`
+                DELETE FROM "roles" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
+              `, [metaOrg._id]);
+                        }
+                        else {
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "featureId" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "name" = 'admin'
+                )
+                AND "roleId" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "name" = 'admin'
+                )
+              `);
+                            await client.query(`
+                DELETE FROM "features" 
+                WHERE "name" = 'admin'
+              `);
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "roleId" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "name" = 'admin'
+                )
+              `);
+                            await client.query(`
+                DELETE FROM "roles" 
+                WHERE "name" = 'admin'
+              `);
+                        }
+                        await client.query('COMMIT');
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw error;
+                    }
+                }
+                finally {
+                    client.release();
+                }
+            }
+        });
+    }
+    return migrations;
+};

package/dist/databases/postgres/postgres.database.d.ts

@@ -1,4 +1,5 @@
 import { IQueryOptions, IModelSpec, IPagedResult, IEntity, IUserContextAuthorization } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
 import { TSchema } from "@sinclair/typebox";
 import { DeleteResult, IDatabase } from "../models/index.js";
 import { Operation } from "../operations/operation.js";
@@ -6,27 +7,27 @@ import { Client } from 'pg';
 export declare class PostgresDatabase implements IDatabase {
     private client;
     constructor(client: Client);
-    preprocessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
-    postprocessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
+    preProcessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
+    postProcessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
     getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
     get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
-    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;
     getCount(pluralResourceName: string): Promise<number>;
     create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
-        insertedId: string;
+        insertedId: AppIdType;
         entity: T;
     }>;
     createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
-        insertedIds: string[];
+        insertedIds: AppIdType[];
         entities: T[];
     }>;
     batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
-    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
-    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
     update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
-    deleteById(id: string, pluralResourceName: string): Promise<DeleteResult>;
+    deleteById(id: AppIdType, pluralResourceName: string): Promise<DeleteResult>;
     deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
     find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
     findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
-    getUserAuthorizations(userId: string, orgId?: string): Promise<IUserContextAuthorization[]>;
+    getUserAuthorizations(userId: AppIdType, orgId?: AppIdType): Promise<IUserContextAuthorization[]>;
 }

package/dist/databases/postgres/postgres.database.js

@@ -18,10 +18,10 @@ export class PostgresDatabase {
     constructor(client) {
         this.client = client;
     }
-    preprocessEntity(entity, modelSpec) {
+    preProcessEntity(entity, modelSpec) {
         return entity;
     }
-    postprocessEntity(entity, modelSpec) {
+    postProcessEntity(entity, modelSpec) {
         return convertNullToUndefined(entity, modelSpec);
     }
     async getAll(operations, pluralResourceName) {

package/dist/databases/postgres/queries/postgres-get-by-id.query.d.ts

@@ -1,4 +1,5 @@
 import { Client } from 'pg';
 import { Operation } from "../../operations/operation.js";
 import { IQueryOptions } from '@loomcore/common/models';
-export declare function getById<T>(client: Client, operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+import type { AppIdType } from '@loomcore/common/types';
+export declare function getById<T>(client: Client, operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;

package/dist/models/refresh-token.model.d.ts

@@ -1,18 +1,19 @@
 import { IEntity } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
 export interface IRefreshToken extends IEntity {
     token: string;
     deviceId: string;
-    userId: string;
+    userId: AppIdType;
     expiresOn: number;
     created: Date;
-    createdBy: string;
+    createdBy: AppIdType;
 }
 export declare const refreshTokenSchema: import("@sinclair/typebox").TObject<{
     token: import("@sinclair/typebox").TString;
     deviceId: import("@sinclair/typebox").TString;
-    userId: import("@sinclair/typebox").TString;
+    userId: import("@sinclair/typebox").TSchema;
     expiresOn: import("@sinclair/typebox").TNumber;
     created: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>;
-    createdBy: import("@sinclair/typebox").TString;
+    createdBy: import("@sinclair/typebox").TSchema;
 }>;
 export declare const refreshTokenModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/models/refresh-token.model.js

@@ -1,13 +1,13 @@
 import { entityUtils } from "@loomcore/common/utils";
-import { TypeboxIsoDate } from "@loomcore/common/validation";
+import { TypeboxIsoDate, getIdSchema } from "@loomcore/common/validation";
 import { Type } from "@sinclair/typebox";
 ;
 export const refreshTokenSchema = Type.Object({
     token: Type.String({ minLength: 1 }),
     deviceId: Type.String({ minLength: 1 }),
-    userId: Type.String({ minLength: 1 }),
+    userId: getIdSchema(),
     expiresOn: Type.Number(),
     created: TypeboxIsoDate({ title: 'Created Date' }),
-    createdBy: Type.String({ minLength: 1 })
+    createdBy: getIdSchema()
 });
 export const refreshTokenModelSpec = entityUtils.getModelSpec(refreshTokenSchema);

package/dist/services/auth.service.d.ts

@@ -1,5 +1,6 @@
 import { Request, Response } from 'express';
 import { IUserContext, ITokenResponse, ILoginResponse, IUser } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 import { MultiTenantApiService } from './multi-tenant-api.service.js';
 import { UpdateResult } from '../databases/models/update-result.js';
 import { IRefreshToken } from '../models/refresh-token.model.js';
@@ -30,7 +31,7 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
         expiresOn: number;
     }>;
     getActiveRefreshToken(refreshToken: string, deviceId: string): Promise<IRefreshToken | null>;
-    createNewRefreshToken(userId: string, deviceId: string, orgId?: string): Promise<IRefreshToken | null>;
+    createNewRefreshToken(userId: AppIdType, deviceId: string, orgId?: AppIdType): Promise<IRefreshToken | null>;
     sendResetPasswordEmail(emailAddress: string): Promise<void>;
     resetPassword(email: string, passwordResetToken: string, password: string): Promise<UpdateResult>;
     deleteRefreshTokensForDevice(deviceId: string): Promise<import("../databases/models/delete-result.js").DeleteResult>;
@@ -42,6 +43,6 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
     getExpiresOnFromSeconds(expiresInSeconds: number): number;
     getExpiresOnFromMinutes(expiresInMinutes: number): number;
     getExpiresOnFromDays(expiresInDays: number): number;
-    preprocessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId: boolean): Promise<Partial<IUser>>;
+    preProcessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId: boolean): Promise<Partial<IUser>>;
     private updateLastLoggedIn;
 }

package/dist/services/auth.service.js

@@ -59,7 +59,7 @@ export class AuthService extends MultiTenantApiService {
             };
             this.updateLastLoggedIn(userContext.user._id)
                 .catch(err => console.log(`Error updating lastLoggedIn: ${err}`));
-            userContext.user = this.postprocessEntity(userContext, userContext.user);
+            userContext.user = this.postProcessEntity(userContext, userContext.user);
             loginResponse = { tokens: tokenResponse, userContext };
         }
         return loginResponse;
@@ -70,7 +70,7 @@ export class AuthService extends MultiTenantApiService {
         if (!rawUser) {
             return null;
         }
-        return this.database.postprocessEntity(rawUser, this.modelSpec.fullSchema);
+        return this.database.postProcessEntity(rawUser, this.modelSpec.fullSchema);
     }
     async createUser(userContext, user) {
         if (userContext.user._id === 'system') {
@@ -241,7 +241,7 @@ export class AuthService extends MultiTenantApiService {
     getExpiresOnFromDays(expiresInDays) {
         return Date.now() + expiresInDays * 24 * 60 * 60 * 1000;
     }
-    async preprocessEntity(userContext, entity, isCreate, allowId) {
+    async preProcessEntity(userContext, entity, isCreate, allowId) {
         if (entity.email) {
             entity.email = entity.email.toLowerCase();
         }
@@ -249,7 +249,7 @@ export class AuthService extends MultiTenantApiService {
             const hash = await passwordUtils.hashPassword(entity.password);
             entity.password = hash;
         }
-        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
+        const preparedEntity = await super.preProcessEntity(userContext, entity, isCreate, allowId);
         return preparedEntity;
     }
     async updateLastLoggedIn(userId) {

package/dist/services/generic-api-service/generic-api-service.interface.d.ts

@@ -1,5 +1,6 @@
 import { ValueError } from '@sinclair/typebox/errors';
 import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
 import { DeleteResult } from '../../databases/models/delete-result.js';
 import { Operation } from '../../databases/operations/operation.js';
 export interface IGenericApiService<T extends IEntity> {
@@ -9,20 +10,20 @@ export interface IGenericApiService<T extends IEntity> {
         queryObject: IQueryOptions;
         operations: Operation[];
     };
-    preprocessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId: boolean): Promise<Partial<T>>;
-    postprocessEntity(userContext: IUserContext, entity: T): T;
+    preProcessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId: boolean): Promise<Partial<T>>;
+    postProcessEntity(userContext: IUserContext, entity: T): T;
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
-    getById(userContext: IUserContext, id: string): Promise<T>;
+    getById(userContext: IUserContext, id: AppIdType): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
     createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
     batchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
-    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
-    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
-    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: string, entity: T): Promise<T>;
+    fullUpdateById(userContext: IUserContext, id: AppIdType, entity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: AppIdType, entity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutPreAndPostProcessing(userContext: IUserContext, id: AppIdType, entity: T): Promise<T>;
     update(userContext: IUserContext, queryObject: IQueryOptions, entity: Partial<T>): Promise<T[]>;
-    deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
+    deleteById(userContext: IUserContext, id: AppIdType): Promise<DeleteResult>;
     deleteMany(userContext: IUserContext, queryObject: IQueryOptions): Promise<DeleteResult>;
     find(userContext: IUserContext, queryObject: IQueryOptions, options?: any): Promise<T[]>;
     findOne(userContext: IUserContext, queryObject: IQueryOptions, options?: any): Promise<T | null>;