@loomcore/api 0.1.26 → 0.1.28

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(): 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() {
+    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: true },
+        auth: {
+            jwtExpirationInSeconds: 3600,
+            refreshTokenExpirationInDays: 7,
+            deviceIdCookieMaxAgeInDays: 730,
+            passwordResetTokenExpirationInMinutes: 20
+        },
+        email: {
+            emailApiKey: 'WeDontHaveAKeyYet',
+            emailApiSecret: 'WeDontHaveASecretYet',
+            fromAddress: undefined,
+            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/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/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,7 +13,8 @@ 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');
@@ -29,8 +28,9 @@ export class CreateMetaOrgMigration {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            initializeSystemUserContext(config.email.systemEmailAddress || 'system@example.com', orgResult.rows[0]._id);
             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

@@ -4,10 +4,12 @@ export declare class CreateAdminUserMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
     index: number;
-    execute(adminEmail?: string, adminPassword?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
-        adminUserId: string | undefined;
-        error: Error | null;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
     }>;
     revert(): Promise<{
         success: boolean;

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

@@ -2,13 +2,14 @@ import { PostgresDatabase } from "../index.js";
 import { randomUUID } from "crypto";
 import { getSystemUserContext } from "@loomcore/common/models";
 import { AuthService } from "../../../services/auth.service.js";
+import { config } from "../../../config/index.js";
 export class CreateAdminUserMigration {
     client;
     constructor(client) {
         this.client = client;
     }
     index = 6;
-    async execute(adminEmail, adminPassword) {
+    async execute() {
         const _id = randomUUID().toString();
         const systemUserContext = getSystemUserContext();
         let createdUser;
@@ -18,17 +19,16 @@ export class CreateAdminUserMigration {
             createdUser = await authService.createUser(systemUserContext, {
                 _id: _id,
                 _orgId: systemUserContext._orgId,
-                email: adminEmail,
-                password: adminPassword,
+                email: config.adminUser?.email,
+                password: config.adminUser?.password,
                 firstName: 'Admin',
                 lastName: 'User',
                 displayName: 'Admin User',
             });
         }
         catch (error) {
-            return {
-                success: false, adminUserId: undefined, error: new Error(`Error creating admin user: ${error.message}`)
-            };
+            console.error(`Error creating admin user: ${error.message}`);
+            return { success: false, error: new Error(`Error creating admin user: ${error.message}`) };
         }
         try {
             const result = await this.client.query(`
@@ -36,13 +36,15 @@ export class CreateAdminUserMigration {
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             if (result.rowCount === 0) {
-                return { success: false, adminUserId: undefined, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                console.error(`Error inserting migration ${this.index} to migrations table: No row returned`);
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
         }
         catch (error) {
-            return { success: false, adminUserId: undefined, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            console.error(`Error inserting migration ${this.index} to migrations table: ${error.message}`);
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
         }
-        return { success: true, adminUserId: createdUser?._id, error: null };
+        return { success: true, error: null };
     }
     async revert() {
         throw new Error('Not implemented');

package/dist/databases/postgres/migrations/007-create-roles-table.migration.d.ts

@@ -4,7 +4,7 @@ export declare class CreateRoleTableMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
     index: number;
-    execute(_orgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
         error: Error;
     } | {

package/dist/databases/postgres/migrations/007-create-roles-table.migration.js

@@ -6,7 +6,7 @@ export class CreateRoleTableMigration {
         this.client = client;
     }
     index = 7;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');

package/dist/databases/postgres/migrations/008-create-user-roles-table.migration.d.ts

@@ -4,7 +4,7 @@ export declare class CreateUserRolesTableMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
     index: number;
-    execute(_orgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
         error: Error;
     } | {

package/dist/databases/postgres/migrations/008-create-user-roles-table.migration.js

@@ -6,7 +6,7 @@ export class CreateUserRolesTableMigration {
         this.client = client;
     }
     index = 8;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');

package/dist/databases/postgres/migrations/009-create-features-table.migration.d.ts

@@ -4,7 +4,7 @@ export declare class CreateFeaturesTableMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
     index: number;
-    execute(_orgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
         error: Error;
     } | {

package/dist/databases/postgres/migrations/009-create-features-table.migration.js

@@ -6,7 +6,7 @@ export class CreateFeaturesTableMigration {
         this.client = client;
     }
     index = 9;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');

package/dist/databases/postgres/migrations/010-create-authorizations-table.migration.d.ts

@@ -4,7 +4,7 @@ export declare class CreateAuthorizationsTableMigration implements IMigration {
     private readonly client;
     constructor(client: Client);
     index: number;
-    execute(_orgId?: string): Promise<{
+    execute(): Promise<{
         success: boolean;
         error: Error;
     } | {

package/dist/databases/postgres/migrations/010-create-authorizations-table.migration.js

@@ -6,7 +6,7 @@ export class CreateAuthorizationsTableMigration {
         this.client = client;
     }
     index = 10;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');

package/dist/databases/postgres/migrations/011-create-admin-authorization.migration.d.ts

@@ -2,9 +2,9 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateAdminAuthorizationMigration implements IMigration {
     private readonly client;
-    private readonly adminUserId;
-    private readonly metaOrgId?;
-    constructor(client: Client, adminUserId: string, metaOrgId?: string | undefined);
+    constructor(client: Client);
+    private organizationService;
+    private authService;
     index: number;
     execute(): Promise<{
         success: boolean;

package/dist/databases/postgres/migrations/011-create-admin-authorization.migration.js

@@ -1,23 +1,36 @@
 import { randomUUID } from "crypto";
+import { AuthService, OrganizationService } from "../../../services/index.js";
+import { PostgresDatabase } from "../index.js";
+import { config } from "../../../config/index.js";
+import { EmptyUserContext } from "@loomcore/common/models";
 export class CreateAdminAuthorizationMigration {
     client;
-    adminUserId;
-    metaOrgId;
-    constructor(client, adminUserId, metaOrgId) {
+    constructor(client) {
         this.client = client;
-        this.adminUserId = adminUserId;
-        this.metaOrgId = metaOrgId;
+        const database = new PostgresDatabase(this.client);
+        this.organizationService = new OrganizationService(database);
+        this.authService = new AuthService(database);
     }
+    organizationService;
+    authService;
     index = 11;
     async execute() {
         const _id = randomUUID().toString();
         try {
+            const metaOrg = await this.organizationService.getMetaOrg(EmptyUserContext);
+            if (!config.adminUser?.email) {
+                return { success: false, error: new Error('Create admin authorization: Admin user email not found in config') };
+            }
+            const adminUser = await this.authService.getUserByEmail(config.adminUser?.email);
+            if (!metaOrg || !adminUser) {
+                return { success: false, error: new Error('Create admin authorization: Meta organization or admin user not found') };
+            }
             await this.client.query('BEGIN');
             const roleId = randomUUID().toString();
             const roleResult = await this.client.query(`
                 INSERT INTO "roles" ("_id", "_orgId", "name")
                 VALUES ($1, $2, 'admin')
-            `, [roleId, this.metaOrgId]);
+            `, [roleId, metaOrg?._id]);
             if (roleResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error('Failed to create admin role') };
@@ -26,7 +39,7 @@ export class CreateAdminAuthorizationMigration {
             const userRoleResult = await this.client.query(`
                 INSERT INTO "user_roles" ("_id", "_orgId", "_userId", "_roleId", "_created", "_createdBy", "_updated", "_updatedBy")
                 VALUES ($1, $2, $3, $4, NOW(), 'system', NOW(), 'system')
-            `, [userRoleId, this.metaOrgId, this.adminUserId, roleId]);
+            `, [userRoleId, metaOrg?._id, adminUser?._id, roleId]);
             if (userRoleResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error('Failed to create user role') };
@@ -35,7 +48,7 @@ export class CreateAdminAuthorizationMigration {
             const featureResult = await this.client.query(`
                 INSERT INTO "features" ("_id", "_orgId", "name")
                 VALUES ($1, $2, 'admin')
-            `, [featureId, this.metaOrgId]);
+            `, [featureId, metaOrg?._id]);
             if (featureResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error('Failed to create admin feature') };
@@ -47,7 +60,7 @@ export class CreateAdminAuthorizationMigration {
                     "_created", "_createdBy", "_updated", "_updatedBy"
                 )
                 VALUES ($1, $2, $3, $4, NOW(), 'system', NOW(), 'system')
-            `, [authorizationId, this.metaOrgId, roleId, featureId]);
+            `, [authorizationId, metaOrg?._id, roleId, featureId]);
             if (authorizationResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error('Failed to create admin authorization') };

package/dist/databases/postgres/migrations/setup-for-auth.migration.d.ts

@@ -1,5 +1,8 @@
 import { Client } from "pg";
-export declare function setupDatabaseForAuth(client: Client, adminUsername: string, adminPassword: string, metaOrgId?: string): Promise<{
+export declare function setupDatabaseForAuth(client: Client): Promise<{
     success: boolean;
-    error: Error | null;
+    error: Error;
+} | {
+    success: boolean;
+    error: null;
 }>;

package/dist/databases/postgres/migrations/setup-for-auth.migration.js

@@ -8,7 +8,7 @@ import { CreateRoleTableMigration } from "./007-create-roles-table.migration.js"
 import { CreateAuthorizationsTableMigration } from "./010-create-authorizations-table.migration.js";
 import { CreateFeaturesTableMigration } from "./009-create-features-table.migration.js";
 import { CreateAdminAuthorizationMigration } from "./011-create-admin-authorization.migration.js";
-export async function setupDatabaseForAuth(client, adminUsername, adminPassword, metaOrgId) {
+export async function setupDatabaseForAuth(client) {
     let runMigrations = [];
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
@@ -20,13 +20,12 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
             return row.index;
         });
     }
-    let adminUserId;
     if (!runMigrations.includes(1)) {
         const migration = new CreateMigrationTableMigration(client);
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating migrations table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(3)) {
@@ -34,7 +33,7 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating users table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(4)) {
@@ -42,20 +41,23 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating refresh_tokens table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(6)) {
         const migration = new CreateAdminUserMigration(client);
-        const result = await migration.execute(adminUsername, adminPassword);
-        adminUserId = result.adminUserId;
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating admin user', result.error);
+            return result;
+        }
     }
     if (!runMigrations.includes(7)) {
         const migration = new CreateRoleTableMigration(client);
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating roles table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(8)) {
@@ -63,7 +65,7 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating user_roles table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(9)) {
@@ -71,7 +73,7 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating features table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(10)) {
@@ -79,19 +81,15 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword,
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating authorizations table', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(11)) {
-        if (!adminUserId) {
-            console.error('setupDatabaseForAuth: Admin user ID is required');
-            return { success: true, error: null };
-        }
-        const migration = new CreateAdminAuthorizationMigration(client, adminUserId, metaOrgId);
+        const migration = new CreateAdminAuthorizationMigration(client);
         const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating admin authorization', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
     }
     return { success: true, error: null };

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.d.ts

@@ -1,6 +1,8 @@
 import { Client } from "pg";
-export declare function setupDatabaseForMultitenant(client: Client, metaOrgName: string, metaOrgCode: string): Promise<{
+export declare function setupDatabaseForMultitenant(client: Client): Promise<{
     success: boolean;
-    metaOrgId: string | undefined;
-    error: Error | null;
+    error: Error;
+} | {
+    success: boolean;
+    error: null;
 }>;

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.js

@@ -2,12 +2,8 @@ import { CreateMigrationTableMigration } from "./001-create-migrations-table.mig
 import { CreateOrganizationsTableMigration } from "./002-create-organizations-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
 import { CreateMetaOrgMigration } from "./005-create-meta-org.migration.js";
-import { PostgresDatabase } from "../postgres.database.js";
-import { OrganizationService } from "../../../services/index.js";
-import { EmptyUserContext } from "@loomcore/common/models";
-export async function setupDatabaseForMultitenant(client, metaOrgName, metaOrgCode) {
+export async function setupDatabaseForMultitenant(client) {
     let runMigrations = [];
-    let metaOrgId;
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
             SELECT "_id", "index"
@@ -23,7 +19,7 @@ export async function setupDatabaseForMultitenant(client, metaOrgName, metaOrgCo
         const result = await createMigrationTableMigration.execute();
         if (!result.success) {
             console.log('setupDatabaseForMultitenant: error creating migration table', result.error);
-            return { success: false, metaOrgId: metaOrgId, error: result.error };
+            return result;
         }
     }
     if (!runMigrations.includes(2)) {
@@ -31,35 +27,16 @@ export async function setupDatabaseForMultitenant(client, metaOrgName, metaOrgCo
         const result = await createOrganizationTableMigration.execute();
         if (!result.success) {
             console.log('setupDatabaseForMultitenant: error creating organizations table', result.error);
-            return { success: false, metaOrgId: metaOrgId, error: result.error };
-        }
-    }
-    else {
-        const database = new PostgresDatabase(client);
-        const organizationService = new OrganizationService(database);
-        const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
-        if (metaOrg) {
-            metaOrgId = metaOrg._id;
+            return result;
         }
     }
     if (!runMigrations.includes(5)) {
-        const createMetaOrgMigration = new CreateMetaOrgMigration(client, metaOrgName, metaOrgCode);
+        const createMetaOrgMigration = new CreateMetaOrgMigration(client);
         const result = await createMetaOrgMigration.execute();
-        if (!result.success || !result.metaOrgId) {
+        if (!result.success) {
             console.log('setupDatabaseForMultitenant: error creating meta org', result.error);
-            return { success: false, metaOrgId: result.metaOrgId, error: result.error };
-        }
-        metaOrgId = result.metaOrgId;
-    }
-    else {
-        if (!metaOrgId) {
-            const database = new PostgresDatabase(client);
-            const organizationService = new OrganizationService(database);
-            const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
-            if (metaOrg) {
-                metaOrgId = metaOrg._id;
-            }
+            return result;
         }
     }
-    return { success: true, metaOrgId: metaOrgId, error: null };
+    return { success: true, error: null };
 }

package/dist/models/base-api-config.interface.d.ts

@@ -17,6 +17,12 @@ export interface IBaseApiConfig {
     };
     app: {
         isMultiTenant: boolean;
+        metaOrgName?: string;
+        metaOrgCode?: string;
+    };
+    adminUser?: {
+        email: string;
+        password: string;
     };
     auth: {
         jwtExpirationInSeconds: number;

package/dist/utils/api.utils.d.ts

@@ -1,12 +1,11 @@
 import { Request, Response } from 'express';
-import { TSchema } from '@sinclair/typebox';
 import { IQueryOptions, IError, IPagedResult, IModelSpec } from '@loomcore/common/models';
 export interface IApiResponseOptions<T> {
     messages?: string[];
     errors?: IError[];
     data?: T;
 }
-declare function apiResponse<T>(response: Response, status: number, options?: IApiResponseOptions<T>, modelSpec?: IModelSpec, publicSchema?: TSchema): Response;
+declare function apiResponse<T>(response: Response, status: number, options?: IApiResponseOptions<T>, modelSpec?: IModelSpec, publicSpec?: IModelSpec): Response;
 declare function getQueryOptionsFromRequest(request: Request): IQueryOptions;
 declare function getPagedResult<T>(entities: T[], totalRows: number, queryOptions: IQueryOptions): IPagedResult<T>;
 export declare const apiUtils: {

package/dist/utils/api.utils.js

@@ -1,9 +1,8 @@
-import { entityUtils } from '@loomcore/common/utils';
 import { DefaultQueryOptions } from '@loomcore/common/models';
-function apiResponse(response, status, options = {}, modelSpec, publicSchema) {
+function apiResponse(response, status, options = {}, modelSpec, publicSpec) {
     const success = status >= 200 && status < 300;
     let apiResponse;
-    const specForEncoding = publicSchema ? entityUtils.getModelSpec(publicSchema) : modelSpec;
+    const specForEncoding = publicSpec ?? modelSpec;
     if (specForEncoding && options.data) {
         if (Array.isArray(options.data)) {
             options.data = options.data.map((item) => specForEncoding.encode(item));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -53,7 +53,7 @@
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.28",
+    "@loomcore/common": "^0.0.29",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.d.ts

@@ -1,21 +0,0 @@
-import { Client } from "pg";
-import { IMigration } from "../../databases/postgres/migrations/index.js";
-export declare class CreateTestUsersTableMigration implements IMigration {
-    private readonly client;
-    constructor(client: Client);
-    index: number;
-    execute(_orgId?: string): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-    revert(_orgId?: string): Promise<{
-        success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
-    }>;
-}

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.js

@@ -1,75 +0,0 @@
-import { randomUUID } from "crypto";
-export class CreateTestUsersTableMigration {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    index = 4;
-    async execute(_orgId) {
-        const _id = randomUUID().toString();
-        try {
-            await this.client.query(`
-                CREATE TABLE "testUsers" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "email" VARCHAR(255) NOT NULL,
-                    "password" VARCHAR(255) NOT NULL,
-                    "firstName" VARCHAR(255),
-                    "lastName" VARCHAR(255),
-                    "displayName" VARCHAR(255),
-                    "_lastLoggedIn" TIMESTAMP,
-                    "_lastPasswordChange" TIMESTAMP,
-                    "_created" TIMESTAMP NOT NULL,
-                    "_createdBy" VARCHAR(255) NOT NULL,
-                    "_updated" TIMESTAMP NOT NULL,
-                    "_updatedBy" VARCHAR(255) NOT NULL,
-                    "_deleted" TIMESTAMP,
-                    "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error creating test users table: ${error.message}`) };
-        }
-        if (_orgId) {
-            try {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
-                `);
-            }
-            catch (error) {
-                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-            }
-        }
-        else {
-            try {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
-                `);
-            }
-            catch (error) {
-                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
-            }
-        }
-        return { success: true, error: null };
-    }
-    async revert(_orgId) {
-        try {
-            await this.client.query(`
-                DROP TABLE "testUsers";
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping test users table: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
-            `);
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
-        }
-        return { success: true, error: null };
-    }
-}