@loomcore/api 0.1.27 → 0.1.29

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

@@ -11,7 +11,10 @@ declare function initialize(database: IDatabase): void;
 declare function getRandomId(): string;
 declare function createMetaOrg(): Promise<void>;
 declare function deleteMetaOrg(): Promise<void>;
-declare function setupTestUser(): Promise<IUser>;
+declare function setupTestUsers(): Promise<{
+    metaOrgUser: IUser;
+    testOrgUser: IUser;
+}>;
 declare function deleteTestUser(): Promise<void>;
 declare function simulateloginWithTestUser(): Promise<string>;
 declare function getAuthToken(): string;
@@ -22,6 +25,7 @@ export declare class CategoryService extends GenericApiService<ICategory> {
 export declare class CategoryController extends ApiController<ICategory> {
     constructor(app: Application, database: IDatabase);
 }
+export declare function setupTestConfig(isMultiTenant?: boolean): void;
 export declare class ProductService extends GenericApiService<IProduct> {
     private db;
     constructor(database: IDatabase);
@@ -59,10 +63,11 @@ declare const testUtils: {
     deleteTestUser: typeof deleteTestUser;
     getAuthToken: typeof getAuthToken;
     initialize: typeof initialize;
+    SetupTestConfig: typeof setupTestConfig;
     loginWithTestUser: typeof loginWithTestUser;
     newUser1Email: string;
     newUser1Password: string;
-    setupTestUser: typeof setupTestUser;
+    setupTestUsers: typeof setupTestUsers;
     simulateloginWithTestUser: typeof simulateloginWithTestUser;
     verifyToken: typeof verifyToken;
 };

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

@@ -8,9 +8,12 @@ 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 { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext } from './test-objects.js';
+import * as testObjectsModule from './test-objects.js';
+const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUser, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId } = testObjectsModule;
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
+import { setBaseApiConfig } from '../config/index.js';
+import { entityUtils } from '@loomcore/common/utils';
 let deviceIdCookie;
 let authService;
 let organizationService;
@@ -52,17 +55,17 @@ async function deleteMetaOrg() {
         console.log('Error deleting meta org:', error);
     }
 }
-async function setupTestUser() {
+async function setupTestUsers() {
     try {
         await deleteTestUser();
-        return createTestUser();
+        return createTestUsers();
     }
     catch (error) {
         console.log(error);
         throw error;
     }
 }
-async function createTestUser() {
+async function createTestUsers() {
     if (!authService || !organizationService) {
         throw new Error('Database not initialized. Call initialize() first.');
     }
@@ -71,15 +74,26 @@ async function createTestUser() {
         if (!existingMetaOrg) {
             await organizationService.create(getTestMetaOrgUserContext(), getTestMetaOrg());
         }
+        else {
+            setTestMetaOrgId(existingMetaOrg._id);
+        }
         const existingTestOrg = await organizationService.findOne(getTestMetaOrgUserContext(), { filters: { _id: { eq: getTestOrg()._id } } });
         if (!existingTestOrg) {
-            await organizationService.create(getTestMetaOrgUserContext(), getTestOrg());
+            const createdTestOrg = await organizationService.create(getTestMetaOrgUserContext(), getTestOrg());
+            if (!createdTestOrg) {
+                throw new Error('Failed to create test organization');
+            }
+            setTestOrgId(createdTestOrg._id);
+        }
+        else {
+            setTestOrgId(existingTestOrg._id);
         }
-        const createdUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
-        if (!createdUser) {
+        const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser());
+        const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
+        if (!createdTestOrgUser || !createdMetaOrgUser) {
             throw new Error('Failed to create test user');
         }
-        return createdUser;
+        return { metaOrgUser: createdMetaOrgUser, testOrgUser: createdTestOrgUser };
     }
     catch (error) {
         console.log('Error in createTestUser:', error);
@@ -141,6 +155,43 @@ export class CategoryController extends ApiController {
         super('categories', app, categoryService, 'category', CategorySpec);
     }
 }
+export function setupTestConfig(isMultiTenant = true) {
+    setBaseApiConfig({
+        env: 'test',
+        hostName: 'localhost',
+        appName: 'test-app',
+        clientSecret: 'test-secret',
+        database: {
+            name: 'test-db',
+        },
+        externalPort: 4000,
+        internalPort: 8083,
+        corsAllowedOrigins: ['*'],
+        saltWorkFactor: 10,
+        jobTypes: '',
+        deployedBranch: '',
+        debug: {
+            showErrors: false
+        },
+        app: { isMultiTenant: isMultiTenant },
+        auth: {
+            jwtExpirationInSeconds: 3600,
+            refreshTokenExpirationInDays: 7,
+            deviceIdCookieMaxAgeInDays: 730,
+            passwordResetTokenExpirationInMinutes: 20
+        },
+        email: {
+            emailApiKey: 'WeDontHaveAKeyYet',
+            emailApiSecret: 'WeDontHaveASecretYet',
+            fromAddress: 'test@test.com',
+            systemEmailAddress: 'system@test.com'
+        },
+        adminUser: {
+            email: 'admin@test.com',
+            password: 'admin-password'
+        }
+    });
+}
 export class ProductService extends GenericApiService {
     db;
     constructor(database) {
@@ -172,7 +223,8 @@ export class ProductsController extends ApiController {
             }))
         ]);
         const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, ['internalNumber']);
-        super('products', app, productService, 'product', ProductSpec, PublicAggregatedProductSchema);
+        const PublicAggregatedProductSpec = entityUtils.getModelSpec(PublicAggregatedProductSchema);
+        super('products', app, productService, 'product', ProductSpec, PublicAggregatedProductSpec);
     }
 }
 export class MultiTenantProductService extends MultiTenantApiService {
@@ -206,7 +258,8 @@ export class MultiTenantProductsController extends ApiController {
             }))
         ]);
         const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, ['internalNumber']);
-        super('multi-tenant-products', app, productService, 'product', ProductSpec, PublicAggregatedProductSchema);
+        const PublicAggregatedProductSpec = entityUtils.getModelSpec(PublicAggregatedProductSchema);
+        super('multi-tenant-products', app, productService, 'product', ProductSpec, PublicAggregatedProductSpec);
     }
 }
 function configureJwtSecret() {
@@ -250,10 +303,11 @@ const testUtils = {
     deleteTestUser,
     getAuthToken,
     initialize,
+    SetupTestConfig: setupTestConfig,
     loginWithTestUser,
     newUser1Email,
     newUser1Password,
-    setupTestUser,
+    setupTestUsers,
     simulateloginWithTestUser,
     verifyToken
 };

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

@@ -1,14 +1,12 @@
 import { CreateTestEntitiesTableMigration } from "./001-create-test-entities-table.migration.js";
 import { CreateCategoriesTableMigration } from "./002-create-categories-table.migration.js";
 import { CreateProductsTableMigration } from "./003-create-products-table.migration.js";
-import { CreateTestUsersTableMigration } from "./004-create-test-users-table.migration.js";
 import { CreateTestItemsTableMigration } from "./005-create-test-items-table.migration.js";
 export async function runTestMigrations(client, _orgId) {
     const migrations = [
         new CreateTestEntitiesTableMigration(client),
         new CreateCategoriesTableMigration(client),
         new CreateProductsTableMigration(client),
-        new CreateTestUsersTableMigration(client),
         new CreateTestItemsTableMigration(client),
     ];
     try {

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

@@ -6,8 +6,8 @@ import { setupDatabaseForMultitenant } from '../databases/postgres/migrations/se
 import { setupDatabaseForAuth } from '../databases/postgres/migrations/setup-for-auth.migration.js';
 import { runTestMigrations } from './postgres-test-migrations/run-test-migrations.js';
 import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
-import { getTestMetaOrg, setTestMetaOrgId } from './test-objects.js';
 import { getSystemUserContext } from '@loomcore/common/models';
+import { setTestMetaOrgId } from './test-objects.js';
 export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
@@ -30,19 +30,20 @@ export class TestPostgresDatabase {
             const testDatabase = new PostgresDatabase(postgresClient);
             this.database = testDatabase;
             this.postgresClient = postgresClient;
-            const metaOrg = getTestMetaOrg();
-            const multitenantResult = await setupDatabaseForMultitenant(postgresClient, metaOrg.name, metaOrg.code);
+            const multitenantResult = await setupDatabaseForMultitenant(postgresClient);
             let success = multitenantResult.success;
-            if (!success || !multitenantResult.metaOrgId) {
+            if (!success) {
                 throw new Error('Failed to setup for multitenant');
             }
-            setTestMetaOrgId(multitenantResult.metaOrgId);
             await initSystemUserContext(this.database);
-            success = (await setupDatabaseForAuth(postgresClient, adminUsername || 'admin', adminPassword || 'password')).success;
+            success = (await setupDatabaseForAuth(postgresClient)).success;
             if (!success) {
                 throw new Error('Failed to setup for auth');
             }
             const systemUserContext = getSystemUserContext();
+            if (systemUserContext._orgId) {
+                setTestMetaOrgId(systemUserContext._orgId);
+            }
             success = (await runTestMigrations(postgresClient, systemUserContext._orgId)).success;
             if (!success) {
                 throw new Error('Failed to run test migrations');

package/dist/__tests__/test-express-app.js

@@ -3,11 +3,11 @@ import bodyParser from 'body-parser';
 import cookieParser from 'cookie-parser';
 import supertest from 'supertest';
 import { initializeTypeBox } from '@loomcore/common/validation';
-import { setBaseApiConfig } from '../config/base-api-config.js';
 import { errorHandler } from '../middleware/error-handler.js';
 import { ensureUserContext } from '../middleware/ensure-user-context.js';
 import { TestMongoDatabase } from './mongo-db.test-database.js';
 import { TestPostgresDatabase } from './postgres.test-database.js';
+import { setupTestConfig } from './common-test.utils.js';
 export class TestExpressApp {
     static app;
     static database;
@@ -26,36 +26,7 @@ export class TestExpressApp {
         return this.initPromise;
     }
     static async _performInit(useMongoDb) {
-        setBaseApiConfig({
-            env: 'test',
-            hostName: 'localhost',
-            appName: 'test-app',
-            clientSecret: 'test-secret',
-            database: {
-                name: this.databaseName,
-            },
-            externalPort: 4000,
-            internalPort: 8083,
-            corsAllowedOrigins: ['*'],
-            saltWorkFactor: 10,
-            jobTypes: '',
-            deployedBranch: '',
-            debug: {
-                showErrors: false
-            },
-            app: { isMultiTenant: true },
-            auth: {
-                jwtExpirationInSeconds: 3600,
-                refreshTokenExpirationInDays: 7,
-                deviceIdCookieMaxAgeInDays: 730,
-                passwordResetTokenExpirationInMinutes: 20
-            },
-            email: {
-                emailApiKey: 'WeDontHaveAKeyYet',
-                emailApiSecret: 'WeDontHaveASecretYet',
-                fromAddress: undefined
-            }
-        });
+        setupTestConfig();
         initializeTypeBox();
         if (!this.database) {
             if (useMongoDb) {

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

@@ -4,6 +4,7 @@ export declare function setTestMetaOrgId(metaOrgId: string): void;
 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 getTestOrg(): IOrganization;
 export declare function getTestOrgUser(): IUser;
 export declare function getTestOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -51,9 +51,13 @@ export function getTestMetaOrgUserContext() {
     };
 }
 ;
+let TEST_ORG_ID = '6926167d06c0073a778a124f';
+export function setTestOrgId(orgId) {
+    TEST_ORG_ID = orgId;
+}
 export function getTestOrg() {
     return {
-        _id: '6926167d06c0073a778a124f',
+        _id: TEST_ORG_ID,
         name: 'Test Organization',
         code: 'test-org',
         status: 1,

package/dist/config/base-api-config.js

@@ -23,7 +23,7 @@ export async function initSystemUserContext(database) {
         throw new Error('BaseApiConfig has not been set. Call setBaseApiConfig first.');
     }
     if (!isSystemUserContextSet) {
-        const systemEmail = config.email.systemEmailAddress || 'system@example.com';
+        const systemEmail = config.email?.systemEmailAddress || 'system@example.com';
         let metaOrgId = undefined;
         if (config.app.isMultiTenant) {
             const { OrganizationService } = await import('../services/organization.service.js');

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

@@ -1,5 +1,4 @@
 import { Application, NextFunction, Request, Response } from 'express';
-import { TSchema } from '@sinclair/typebox';
 import { IEntity, IModelSpec } from '@loomcore/common/models';
 import { IGenericApiService } from '../services/index.js';
 export declare abstract class ApiController<T extends IEntity> {
@@ -8,8 +7,8 @@ export declare abstract class ApiController<T extends IEntity> {
     protected slug: string;
     protected apiResourceName: string;
     protected modelSpec?: IModelSpec;
-    protected publicSchema?: TSchema;
-    protected constructor(slug: string, app: Application, service: IGenericApiService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSchema?: TSchema);
+    protected publicSpec?: IModelSpec;
+    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;
     protected validateMany(entities: any[], isPartial?: boolean): void;

package/dist/controllers/api.controller.js

@@ -8,14 +8,14 @@ export class ApiController {
     slug;
     apiResourceName;
     modelSpec;
-    publicSchema;
-    constructor(slug, app, service, resourceName = '', modelSpec, publicSchema) {
+    publicSpec;
+    constructor(slug, app, service, resourceName = '', modelSpec, publicSpec) {
         this.slug = slug;
         this.app = app;
         this.service = service;
         this.apiResourceName = resourceName;
         this.modelSpec = modelSpec;
-        this.publicSchema = publicSchema;
+        this.publicSpec = publicSpec;
         this.mapRoutes(app);
     }
     mapRoutes(app) {
@@ -40,30 +40,30 @@ export class ApiController {
     async getAll(req, res, next) {
         res.set('Content-Type', 'application/json');
         const entities = await this.service.getAll(req.userContext);
-        apiUtils.apiResponse(res, 200, { data: entities }, this.modelSpec, this.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: entities }, this.modelSpec, this.publicSpec);
     }
     async get(req, res, next) {
         res.set('Content-Type', 'application/json');
         const queryOptions = apiUtils.getQueryOptionsFromRequest(req);
         const pagedResult = await this.service.get(req.userContext, queryOptions);
-        apiUtils.apiResponse(res, 200, { data: pagedResult }, this.modelSpec, this.publicSchema);
+        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.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSpec);
     }
     async getCount(req, res, next) {
         res.set('Content-Type', 'application/json');
         const count = await this.service.getCount(req.userContext);
-        apiUtils.apiResponse(res, 200, { data: count }, this.modelSpec, this.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: count }, this.modelSpec, this.publicSpec);
     }
     async create(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body);
         const entity = await this.service.create(req.userContext, req.body);
-        apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSchema);
+        apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSpec);
     }
     async batchUpdate(req, res, next) {
         res.set('Content-Type', 'application/json');
@@ -73,23 +73,23 @@ export class ApiController {
         }
         this.validateMany(entities, true);
         const updatedEntities = await this.service.batchUpdate(req.userContext, entities);
-        apiUtils.apiResponse(res, 200, { data: updatedEntities }, this.modelSpec, this.publicSchema);
+        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.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
     }
     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.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSpec);
     }
     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.publicSchema);
+        apiUtils.apiResponse(res, 200, { data: deleteResult }, this.modelSpec, this.publicSpec);
     }
 }

package/dist/controllers/auth.controller.js

@@ -1,4 +1,4 @@
-import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, passwordValidator, PublicUserContextSpec, } from '@loomcore/common/models';
+import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSpec, passwordValidator, PublicUserContextSpec, } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 import { isAuthenticated } from '../middleware/index.js';
@@ -35,7 +35,7 @@ export class AuthController {
             throw new BadRequestError('Missing required fields: userContext is required.');
         }
         const user = await this.authService.createUser(userContext, body);
-        apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
+        apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSpec);
     }
     async requestTokenUsingRefreshToken(req, res, next) {
         const refreshToken = req.query.refreshToken;

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

@@ -1,9 +1,10 @@
 import { Application } from 'express';
 import { IUser } from '@loomcore/common/models';
 import { ApiController } from './api.controller.js';
+import { UserService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
 export declare class UsersController extends ApiController<IUser> {
-    private userService;
+    userService: UserService;
     constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
 }

package/dist/controllers/users.controller.js

@@ -1,4 +1,4 @@
-import { UserSpec, PublicUserSchema } from '@loomcore/common/models';
+import { UserSpec, PublicUserSpec } from '@loomcore/common/models';
 import { ApiController } from './api.controller.js';
 import { isAuthenticated } from '../middleware/index.js';
 import { UserService } from '../services/index.js';
@@ -6,7 +6,7 @@ export class UsersController extends ApiController {
     userService;
     constructor(app, database) {
         const userService = new UserService(database);
-        super('users', app, userService, 'user', UserSpec, PublicUserSchema);
+        super('users', app, userService, 'user', UserSpec, PublicUserSpec);
         this.userService = userService;
     }
     mapRoutes(app) {

package/dist/databases/postgres/migrations/003-create-users-table.migration.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateUsersTableMigration {
     client;
     constructor(client) {
@@ -12,6 +13,9 @@ export class CreateUsersTableMigration {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'users');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? ',\n                            CONSTRAINT "fk_users_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "users" (
                         "_id" VARCHAR(255) PRIMARY KEY,
@@ -29,8 +33,7 @@ export class CreateUsersTableMigration {
                         "_updatedBy" VARCHAR(255) NOT NULL,
                         "_deleted" TIMESTAMP,
                         "_deletedBy" VARCHAR(255),
-                        CONSTRAINT "fk_users_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
-                        CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")
+                        CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")${fkConstraint}
                     )
                 `);
             }

package/dist/databases/postgres/migrations/004-create-refresh-tokens-table.migration.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateRefreshTokenTableMigration {
     client;
     constructor(client) {
@@ -12,6 +13,9 @@ export class CreateRefreshTokenTableMigration {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'refreshTokens');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? ',\n                        CONSTRAINT "fk_refreshTokens_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "refreshTokens" (
                         "_id" VARCHAR(255) PRIMARY KEY,
@@ -21,7 +25,7 @@ export class CreateRefreshTokenTableMigration {
                         "userId" VARCHAR(255) NOT NULL,
                         "expiresOn" BIGINT NOT NULL,
                         "created" TIMESTAMP NOT NULL,
-                        "createdBy" VARCHAR(255) NOT NULL
+                        "createdBy" VARCHAR(255) NOT NULL${fkConstraint}
                     )
                 `);
             }

package/dist/databases/postgres/migrations/005-create-meta-org.migration.d.ts

@@ -2,17 +2,13 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateMetaOrgMigration implements IMigration {
     private readonly client;
-    private readonly orgName;
-    private readonly orgCode;
-    constructor(client: Client, orgName: string, orgCode: string);
+    constructor(client: Client);
     index: number;
     execute(): Promise<{
         success: boolean;
         error: Error;
-        metaOrgId?: undefined;
     } | {
         success: boolean;
-        metaOrgId: string;
         error: null;
     }>;
     revert(): Promise<{

package/dist/databases/postgres/migrations/005-create-meta-org.migration.js

@@ -1,12 +1,10 @@
 import { randomUUID } from "crypto";
+import { config } from "../../../config/index.js";
+import { initializeSystemUserContext } from "@loomcore/common/models";
 export class CreateMetaOrgMigration {
     client;
-    orgName;
-    orgCode;
-    constructor(client, orgName, orgCode) {
+    constructor(client) {
         this.client = client;
-        this.orgName = orgName;
-        this.orgCode = orgCode;
     }
     index = 5;
     async execute() {
@@ -15,12 +13,14 @@ export class CreateMetaOrgMigration {
             await this.client.query('BEGIN');
             const orgResult = await this.client.query(`
                 INSERT INTO "organizations" ("_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
-                VALUES ('${_id}', '${this.orgName}', '${this.orgCode}', 1, true, NOW(), 'system', NOW(), 'system');
+                VALUES ('${_id}', '${config.app.metaOrgName}', '${config.app.metaOrgCode}', 1, true, NOW(), 'system', NOW(), 'system')
+                RETURNING "_id";
             `);
             if (orgResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error creating meta org: No row returned`) };
             }
+            initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', orgResult.rows[0]._id);
             const migrationResult = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
@@ -30,7 +30,7 @@ export class CreateMetaOrgMigration {
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
             await this.client.query('COMMIT');
-            return { success: true, metaOrgId: _id, error: null };
+            return { success: true, error: null };
         }
         catch (error) {
             await this.client.query('ROLLBACK');

package/dist/databases/postgres/migrations/006-create-admin-user.migration.d.ts

@@ -3,11 +3,14 @@ import { IMigration } from "../index.js";
 export declare class CreateAdminUserMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
+    private authService;
     index: number;
-    execute(adminEmail?: string, adminPassword?: string, metaOrgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
-        adminUserId: string | undefined;
-        error: Error | null;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
     }>;
     revert(): Promise<{
         success: boolean;