@loomcore/api 0.1.53 → 0.1.57

package/dist/__tests__/common-test.utils.d.ts

@@ -9,6 +9,9 @@ import { ICategory } from './models/category.model.js';
 import { IProduct } from './models/product.model.js';
 declare function initialize(database: IDatabase): void;
 declare function getRandomId(): string;
+declare function isMongoDatabase(database: IDatabase): boolean;
+declare function isPostgresDatabase(database: IDatabase): boolean;
+declare function getExpectedIdType(database: IDatabase): 'string' | 'number';
 declare function createMetaOrg(): Promise<void>;
 declare function deleteMetaOrg(): Promise<void>;
 declare function setupTestUsers(): Promise<{
@@ -33,7 +36,7 @@ export declare class ProductService extends GenericApiService<IProduct> {
         queryObject: IQueryOptions;
         operations: Operation[];
     };
-    postprocessEntity(userContext: IUserContext, single: any): any;
+    postProcessEntity(userContext: IUserContext, single: any): any;
 }
 export declare class ProductsController extends ApiController<IProduct> {
     constructor(app: Application, database: IDatabase);
@@ -45,7 +48,7 @@ export declare class MultiTenantProductService extends MultiTenantApiService<IPr
         queryObject: IQueryOptions;
         operations: Operation[];
     };
-    postprocessEntity(userContext: IUserContext, single: any): any;
+    postProcessEntity(userContext: IUserContext, single: any): any;
 }
 export declare class MultiTenantProductsController extends ApiController<IProduct> {
     constructor(app: Application, database: IDatabase);
@@ -70,5 +73,8 @@ declare const testUtils: {
     setupTestUsers: typeof setupTestUsers;
     simulateloginWithTestUser: typeof simulateloginWithTestUser;
     verifyToken: typeof verifyToken;
+    isMongoDatabase: typeof isMongoDatabase;
+    isPostgresDatabase: typeof isPostgresDatabase;
+    getExpectedIdType: typeof getExpectedIdType;
 };
 export default testUtils;

package/dist/__tests__/common-test.utils.js

@@ -1,5 +1,6 @@
 import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
+import { EmptyUserContext } from '@loomcore/common/models';
 import { Type } from '@sinclair/typebox';
 import { JwtService } from '../services/jwt.service.js';
 import { ApiController } from '../controllers/api.controller.js';
@@ -8,8 +9,10 @@ import { Join } from '../databases/operations/join.operation.js';
 import { OrganizationService } from '../services/organization.service.js';
 import { AuthService, GenericApiService } from '../services/index.js';
 import { ObjectId } from 'mongodb';
+import { MongoDBDatabase } from '../databases/mongo-db/mongo-db.database.js';
+import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
 import * as testObjectsModule from './test-objects.js';
-const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId } = testObjectsModule;
+const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId } = testObjectsModule;
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
 import { setBaseApiConfig } from '../config/index.js';
@@ -30,14 +33,29 @@ function initialize(database) {
 function getRandomId() {
     return new ObjectId().toString();
 }
+function isMongoDatabase(database) {
+    return database instanceof MongoDBDatabase;
+}
+function isPostgresDatabase(database) {
+    return database instanceof PostgresDatabase;
+}
+function getExpectedIdType(database) {
+    return isPostgresDatabase(database) ? 'number' : 'string';
+}
 async function createMetaOrg() {
     if (!organizationService) {
         throw new Error('OrganizationService not initialized. Call initialize() first.');
     }
     try {
-        const existingMetaOrg = await organizationService.getMetaOrg(getTestMetaOrgUserContext());
+        const existingMetaOrg = await organizationService.getMetaOrg(EmptyUserContext);
         if (!existingMetaOrg) {
-            const metaOrgInsertResult = await organizationService.create(getTestMetaOrgUserContext(), getTestMetaOrg());
+            const metaOrgInsertResult = await organizationService.create(EmptyUserContext, getTestMetaOrg());
+            if (metaOrgInsertResult) {
+                setTestMetaOrgId(metaOrgInsertResult._id);
+            }
+        }
+        else {
+            setTestMetaOrgId(existingMetaOrg._id);
         }
     }
     catch (error) {
@@ -58,6 +76,7 @@ async function deleteMetaOrg() {
 }
 async function setupTestUsers() {
     try {
+        await createMetaOrg();
         await deleteTestUser();
         return createTestUsers();
     }
@@ -71,13 +90,11 @@ async function createTestUsers() {
         throw new Error('Database not initialized. Call initialize() first.');
     }
     try {
-        const existingMetaOrg = await organizationService.getMetaOrg(getTestMetaOrgUserContext());
+        const existingMetaOrg = await organizationService.getMetaOrg(EmptyUserContext);
         if (!existingMetaOrg) {
-            await organizationService.create(getTestMetaOrgUserContext(), getTestMetaOrg());
-        }
-        else {
-            setTestMetaOrgId(existingMetaOrg._id);
+            throw new Error('Meta organization does not exist. Test setup is incorrect - meta org should be created by migrations or createMetaOrg().');
         }
+        setTestMetaOrgId(existingMetaOrg._id);
         const existingTestOrg = await organizationService.findOne(getTestMetaOrgUserContext(), { filters: { _id: { eq: getTestOrg()._id } } });
         if (!existingTestOrg) {
             const createdTestOrg = await organizationService.create(getTestMetaOrgUserContext(), getTestOrg());
@@ -94,6 +111,8 @@ async function createTestUsers() {
         if (!createdTestOrgUser || !createdMetaOrgUser) {
             throw new Error('Failed to create test user');
         }
+        setTestMetaOrgUserId(createdMetaOrgUser._id);
+        setTestOrgUserId(createdTestOrgUser._id);
         return { metaOrgUser: createdMetaOrgUser, testOrgUser: createdTestOrgUser };
     }
     catch (error) {
@@ -102,6 +121,9 @@ async function createTestUsers() {
     }
 }
 async function deleteTestUser() {
+    if (!authService || !organizationService) {
+        return;
+    }
     await authService.deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id).catch((error) => {
         return null;
     });
@@ -124,6 +146,9 @@ async function simulateloginWithTestUser() {
             return res;
         }
     };
+    if (!authService) {
+        throw new Error('AuthService not initialized. Call initialize() first.');
+    }
     const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD);
     if (!loginResponse?.tokens?.accessToken) {
         throw new Error('Failed to login with test user');
@@ -167,7 +192,13 @@ export function setupTestConfig(isMultiTenant = true) {
         debug: {
             showErrors: false
         },
-        app: { isMultiTenant: isMultiTenant },
+        app: {
+            isMultiTenant: isMultiTenant,
+            ...(isMultiTenant && {
+                metaOrgName: 'Test Meta Organization',
+                metaOrgCode: 'TEST_META_ORG'
+            })
+        },
         auth: {
             jwtExpirationInSeconds: 3600,
             refreshTokenExpirationInDays: 7,
@@ -199,12 +230,12 @@ export class ProductService extends GenericApiService {
         ];
         return super.prepareQuery(userContext, queryObject, newOperations);
     }
-    postprocessEntity(userContext, single) {
+    postProcessEntity(userContext, single) {
         if (single && single.category) {
             const categoryService = new CategoryService(this.db);
-            single.category = categoryService.postprocessEntity(userContext, single.category);
+            single.category = categoryService.postProcessEntity(userContext, single.category);
         }
-        return super.postprocessEntity(userContext, single);
+        return super.postProcessEntity(userContext, single);
     }
 }
 export class ProductsController extends ApiController {
@@ -234,12 +265,12 @@ export class MultiTenantProductService extends MultiTenantApiService {
         ];
         return super.prepareQuery(userContext, queryObject, newOperations);
     }
-    postprocessEntity(userContext, single) {
+    postProcessEntity(userContext, single) {
         if (single && single.category) {
             const categoryService = new CategoryService(this.db);
-            single.category = categoryService.postprocessEntity(userContext, single.category);
+            single.category = categoryService.postProcessEntity(userContext, single.category);
         }
-        return super.postprocessEntity(userContext, single);
+        return super.postProcessEntity(userContext, single);
     }
 }
 export class MultiTenantProductsController extends ApiController {
@@ -303,6 +334,9 @@ const testUtils = {
     newUser1Password,
     setupTestUsers,
     simulateloginWithTestUser,
-    verifyToken
+    verifyToken,
+    isMongoDatabase,
+    isPostgresDatabase,
+    getExpectedIdType
 };
 export default testUtils;

package/dist/__tests__/index.d.ts

@@ -1,4 +1,3 @@
-export * from './postgres-test-migrations/100-create-test-entities-table.migration.js';
 export * from './models/test-entity.model.js';
 export * from './postgres.test-database.js';
 export * from './mongo-db.test-database.js';

package/dist/__tests__/index.js

@@ -1,4 +1,3 @@
-export * from './postgres-test-migrations/100-create-test-entities-table.migration.js';
 export * from './models/test-entity.model.js';
 export * from './postgres.test-database.js';
 export * from './mongo-db.test-database.js';

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.d.ts

@@ -0,0 +1,3 @@
+import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
+import { SyntheticMigration } from '../../databases/postgres/migrations/postgres-initial-schema.js';
+export declare const getPostgresTestSchema: (config: IBaseApiConfig) => SyntheticMigration[];

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -0,0 +1,97 @@
+export const getPostgresTestSchema = (config) => {
+    const migrations = [];
+    const isMultiTenant = config.app.isMultiTenant === true;
+    migrations.push({
+        name: '00000000000100_schema-test-entities',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "testEntities" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          "isActive" BOOLEAN,
+          "tags" TEXT[],
+          "count" INTEGER,
+          "_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 "testEntities"');
+        }
+    });
+    migrations.push({
+        name: '00000000000101_schema-categories',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "categories" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "categories"');
+        }
+    });
+    migrations.push({
+        name: '00000000000102_schema-products',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "products" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          "internalNumber" VARCHAR(255),
+          "categoryId" 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_products_category" FOREIGN KEY ("categoryId") REFERENCES "categories"("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "products"');
+        }
+    });
+    migrations.push({
+        name: '00000000000103_schema-test-items',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "testItems" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "value" INTEGER,
+          "eventDate" TIMESTAMPTZ,
+          "_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 "testItems"');
+        }
+    });
+    return migrations;
+};

package/dist/__tests__/postgres.test-database.js

@@ -1,9 +1,8 @@
-import { randomUUID } from 'crypto';
 import testUtils from './common-test.utils.js';
 import { newDb } from "pg-mem";
-import { testMigrations } from './postgres-test-migrations/test-migrations.js';
 import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
-import { DatabaseBuilder } from '../databases/postgres/migrations/database-builder.js';
+import { config } from '../config/base-api-config.js';
+import { runInitialSchemaMigrations, runTestSchemaMigrations } from '../databases/postgres/migrations/__tests__/test-migration-helper.js';
 export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
@@ -16,7 +15,7 @@ export class TestPostgresDatabase {
         return this.initPromise;
     }
     getRandomId() {
-        return randomUUID();
+        throw new Error('getRandomId() should not be used for PostgreSQL _id fields. PostgreSQL uses auto-generated integer IDs. Remove _id from entities and let the database generate it.');
     }
     async _performInit(adminUsername, adminPassword) {
         if (!this.database) {
@@ -26,11 +25,13 @@ export class TestPostgresDatabase {
             const testDatabase = new PostgresDatabase(postgresClient);
             this.database = testDatabase;
             this.postgresClient = postgresClient;
-            const builder = new DatabaseBuilder(postgresClient);
-            const result = await builder.withMultitenant().withAuth().withMigrations(testMigrations(postgresClient)).build();
-            if (!result.success) {
-                throw new Error('Failed to setup test database');
+            const { initializeSystemUserContext, isSystemUserContextInitialized } = await import('@loomcore/common/models');
+            if (!isSystemUserContextInitialized()) {
+                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@test.com', undefined);
             }
+            const pool = postgresClient;
+            await runInitialSchemaMigrations(pool, config);
+            await runTestSchemaMigrations(pool, config);
             testUtils.initialize(testDatabase);
             await this.createIndexes(postgresClient);
             await testUtils.createMetaOrg();

package/dist/__tests__/setup/vitest-setup.js

@@ -0,0 +1,15 @@
+import { setIdSchema } from '@loomcore/common/validation';
+import { Type } from '@sinclair/typebox';
+if (!process.env.TEST_DATABASE) {
+    process.env.TEST_DATABASE = 'postgres';
+}
+const testDatabase = process.env.TEST_DATABASE;
+if (testDatabase === 'postgres') {
+    setIdSchema(Type.Number({ title: 'ID', integer: true, minimum: 1 }));
+}
+else if (testDatabase === 'mongodb') {
+    setIdSchema(Type.String({ title: 'ID', pattern: '^[0-9a-fA-F]{24}$' }));
+}
+else {
+    throw new Error(`Invalid TEST_DATABASE value: ${testDatabase}. Must be 'postgres' or 'mongodb'`);
+}

package/dist/__tests__/test-objects.d.ts

@@ -1,11 +1,14 @@
 import { IOrganization, IUserContext, IUser } from "@loomcore/common/models";
-export declare let TEST_META_ORG_ID: string;
-export declare function setTestMetaOrgId(metaOrgId: string): void;
+export declare let TEST_META_ORG_ID: string | number;
+export declare let TEST_META_ORG_USER_ID: string | number;
+export declare function setTestMetaOrgId(metaOrgId: string | number): void;
+export declare function setTestMetaOrgUserId(userId: string | number): void;
 export declare const TEST_META_ORG_USER_PASSWORD = "test-meta-org-user-password";
 export declare function getTestMetaOrg(): IOrganization;
 export declare function getTestMetaOrgUser(): IUser;
 export declare function getTestMetaOrgUserContext(): IUserContext;
-export declare function setTestOrgId(orgId: string): void;
+export declare function setTestOrgId(orgId: string | number): void;
+export declare function setTestOrgUserId(userId: string | number): void;
 export declare function getTestOrg(): IOrganization;
 export declare const TEST_ORG_USER_PASSWORD = "test-org-user-password";
 export declare function getTestOrgUser(): IUser;

package/dist/__tests__/test-objects.js

@@ -1,7 +1,11 @@
 export let TEST_META_ORG_ID = '69261691f936c45f85da24d0';
+export let TEST_META_ORG_USER_ID = '69261672f48fb7bf76e54dfb';
 export function setTestMetaOrgId(metaOrgId) {
     TEST_META_ORG_ID = metaOrgId;
 }
+export function setTestMetaOrgUserId(userId) {
+    TEST_META_ORG_USER_ID = userId;
+}
 export const TEST_META_ORG_USER_PASSWORD = 'test-meta-org-user-password';
 export function getTestMetaOrg() {
     return {
@@ -19,7 +23,7 @@ export function getTestMetaOrg() {
 ;
 export function getTestMetaOrgUser() {
     return {
-        _id: '69261672f48fb7bf76e54dfb',
+        _id: TEST_META_ORG_USER_ID,
         _orgId: getTestMetaOrg()._id,
         email: 'test@example.com',
         firstName: 'Test',
@@ -47,9 +51,13 @@ export function getTestMetaOrgUserContext() {
 }
 ;
 let TEST_ORG_ID = '6926167d06c0073a778a124f';
+let TEST_ORG_USER_ID = '6926167d06c0073a778a1250';
 export function setTestOrgId(orgId) {
     TEST_ORG_ID = orgId;
 }
+export function setTestOrgUserId(userId) {
+    TEST_ORG_USER_ID = userId;
+}
 export function getTestOrg() {
     return {
         _id: TEST_ORG_ID,
@@ -67,7 +75,7 @@ export function getTestOrg() {
 export const TEST_ORG_USER_PASSWORD = 'test-org-user-password';
 export function getTestOrgUser() {
     return {
-        _id: '6926167d06c0073a778a1250',
+        _id: TEST_ORG_USER_ID,
         _orgId: getTestOrg()._id,
         email: 'test-org-user@example.com',
         firstName: 'Test',

package/dist/controllers/api.controller.d.ts

@@ -1,5 +1,6 @@
 import { Application, NextFunction, Request, Response } from 'express';
 import { IEntity, IModelSpec } from '@loomcore/common/models';
+import type { TSchema } from '@sinclair/typebox';
 import { IGenericApiService } from '../services/index.js';
 export declare abstract class ApiController<T extends IEntity> {
     protected app: Application;
@@ -8,6 +9,7 @@ export declare abstract class ApiController<T extends IEntity> {
     protected apiResourceName: string;
     protected modelSpec?: IModelSpec;
     protected publicSpec?: IModelSpec;
+    protected idSchema: TSchema;
     protected constructor(slug: string, app: Application, service: IGenericApiService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSpec?: IModelSpec);
     mapRoutes(app: Application): void;
     protected validate(entity: any, isPartial?: boolean): void;

package/dist/controllers/api.controller.js

@@ -1,5 +1,7 @@
 import { BadRequestError } from '../errors/index.js';
 import { entityUtils } from '@loomcore/common/utils';
+import { Value } from '@sinclair/typebox/value';
+import { getIdSchema } from '@loomcore/common/validation';
 import { apiUtils } from '../utils/index.js';
 import { isAuthorized } from '../middleware/index.js';
 export class ApiController {
@@ -9,6 +11,7 @@ export class ApiController {
     apiResourceName;
     modelSpec;
     publicSpec;
+    idSchema;
     constructor(slug, app, service, resourceName = '', modelSpec, publicSpec) {
         this.slug = slug;
         this.app = app;
@@ -16,6 +19,7 @@ export class ApiController {
         this.apiResourceName = resourceName;
         this.modelSpec = modelSpec;
         this.publicSpec = publicSpec;
+        this.idSchema = getIdSchema();
         this.mapRoutes(app);
     }
     mapRoutes(app) {
@@ -49,10 +53,19 @@ export class ApiController {
         apiUtils.apiResponse(res, 200, { data: pagedResult }, this.modelSpec, this.publicSpec);
     }
     async getById(req, res, next) {
-        let id = req.params?.id;
         res.set('Content-Type', 'application/json');
-        const entity = await this.service.getById(req.userContext, id);
-        apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSpec);
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new BadRequestError('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            const entity = await this.service.getById(req.userContext, id);
+            apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSpec);
+        }
+        catch (error) {
+            throw new BadRequestError(`Invalid ID format: ${error.message || error}`);
+        }
     }
     async getCount(req, res, next) {
         res.set('Content-Type', 'application/json');
@@ -71,25 +84,67 @@ export class ApiController {
         if (!Array.isArray(entities)) {
             throw new BadRequestError('Request body must be an array of entities.');
         }
-        this.validateMany(entities, true);
-        const updatedEntities = await this.service.batchUpdate(req.userContext, entities);
+        const convertedEntities = entities.map(entity => {
+            if (entity._id !== undefined) {
+                try {
+                    const convertedId = Value.Convert(this.idSchema, entity._id);
+                    return { ...entity, _id: convertedId };
+                }
+                catch (error) {
+                    throw new BadRequestError(`Invalid ID format for entity: ${error.message || error}`);
+                }
+            }
+            return entity;
+        });
+        this.validateMany(convertedEntities, true);
+        const updatedEntities = await this.service.batchUpdate(req.userContext, convertedEntities);
         apiUtils.apiResponse(res, 200, { data: updatedEntities }, this.modelSpec, this.publicSpec);
     }
     async fullUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body);
-        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, req.body);
-        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new BadRequestError('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            const updateResult = await this.service.fullUpdateById(req.userContext, id, req.body);
+            apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
+        }
+        catch (error) {
+            throw new BadRequestError(`Invalid ID format: ${error.message || error}`);
+        }
     }
     async partialUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body, true);
-        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, req.body);
-        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new BadRequestError('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            const updateResult = await this.service.partialUpdateById(req.userContext, id, req.body);
+            apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
+        }
+        catch (error) {
+            throw new BadRequestError(`Invalid ID format: ${error.message || error}`);
+        }
     }
     async deleteById(req, res, next) {
         res.set('Content-Type', 'application/json');
-        const deleteResult = await this.service.deleteById(req.userContext, req.params.id);
-        apiUtils.apiResponse(res, 200, { data: deleteResult }, this.modelSpec, this.publicSpec);
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new BadRequestError('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            const deleteResult = await this.service.deleteById(req.userContext, id);
+            apiUtils.apiResponse(res, 200, { data: deleteResult }, this.modelSpec, this.publicSpec);
+        }
+        catch (error) {
+            throw new BadRequestError(`Invalid ID format: ${error.message || error}`);
+        }
     }
 }

package/dist/databases/migrations/migration-runner.js

@@ -5,8 +5,8 @@ import fs from 'fs';
 import path from 'path';
 import { buildMongoUrl } from '../mongo-db/utils/build-mongo-url.util.js';
 import { buildPostgresUrl } from '../postgres/utils/build-postgres-url.util.js';
-import { getPostgresFoundational } from '../postgres/migrations/postgres-foundational.js';
-import { getMongoFoundational } from '../mongo-db/migrations/mongo-foundational.js';
+import { getPostgresInitialSchema } from '../postgres/migrations/postgres-initial-schema.js';
+import { getMongoInitialSchema } from '../mongo-db/migrations/mongo-initial-schema.js';
 export class MigrationRunner {
     config;
     dbType;
@@ -56,7 +56,7 @@ export class MigrationRunner {
             this.dbConnection = pool;
             return new Umzug({
                 migrations: async () => {
-                    const foundationals = getPostgresFoundational(this.config).map(m => ({
+                    const initialSchema = getPostgresInitialSchema(this.config).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -68,7 +68,7 @@ export class MigrationRunner {
                         }
                     }));
                     const fileMigrations = this.loadFileMigrations(this.migrationsDir, 'sql', pool);
-                    return [...foundationals, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
+                    return [...initialSchema, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
                 },
                 context: pool,
                 storage: {
@@ -95,7 +95,7 @@ export class MigrationRunner {
             console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
                 migrations: async () => {
-                    const foundationals = getMongoFoundational(this.config).map(m => ({
+                    const initialSchema = getMongoInitialSchema(this.config).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -107,7 +107,7 @@ export class MigrationRunner {
                         }
                     }));
                     const fileMigrations = this.loadFileMigrations(this.migrationsDir, 'ts', db);
-                    return [...foundationals, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
+                    return [...initialSchema, ...fileMigrations].sort((a, b) => a.name.localeCompare(b.name));
                 },
                 context: db,
                 storage: new MongoDBStorage({ collection: db.collection('migrations') }),

package/dist/databases/models/database.interface.d.ts

@@ -1,27 +1,28 @@
 import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
 import { DeleteResult } from "./delete-result.js";
 import { TSchema } from "@sinclair/typebox";
 import { Operation } from "../operations/operation.js";
 export interface IDatabase {
-    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>;