@loomcore/api 0.1.27 → 0.1.29

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

@@ -2,33 +2,34 @@ 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;
+        const database = new PostgresDatabase(this.client);
+        this.authService = new AuthService(database);
     }
+    authService;
     index = 6;
-    async execute(adminEmail, adminPassword, metaOrgId) {
+    async execute() {
         const _id = randomUUID().toString();
         const systemUserContext = getSystemUserContext();
         let createdUser;
         try {
-            const database = new PostgresDatabase(this.client);
-            const authService = new AuthService(database);
-            createdUser = await authService.createUser(systemUserContext, {
+            createdUser = await this.authService.createUser(systemUserContext, {
                 _id: _id,
-                _orgId: metaOrgId,
-                email: adminEmail,
-                password: adminPassword,
+                _orgId: systemUserContext._orgId,
+                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 +37,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

@@ -1,24 +1,27 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateRoleTableMigration {
     client;
     constructor(client) {
         this.client = client;
     }
     index = 7;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'roles');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? ',\n                            CONSTRAINT "fk_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "roles" (
                         "_id" VARCHAR(255) PRIMARY KEY,
                         "_orgId" VARCHAR(255),
                         "name" VARCHAR(255) NOT NULL,
-                        CONSTRAINT "fk_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
-                        CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")
+                        CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")${fkConstraint}
                     )
                 `);
             }

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

@@ -1,17 +1,21 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateUserRolesTableMigration {
     client;
     constructor(client) {
         this.client = client;
     }
     index = 8;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'user_roles');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? '\n                        CONSTRAINT "fk_user_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "user_roles" (
                         "_id" VARCHAR(255) PRIMARY KEY,
@@ -24,7 +28,7 @@ export class CreateUserRolesTableMigration {
                         "_updatedBy" VARCHAR(255) NOT NULL,
                         "_deleted" TIMESTAMP,
                         "_deletedBy" VARCHAR(255),
-                        CONSTRAINT "fk_user_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
+                        ${fkConstraint}
                         CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("_userId") REFERENCES "users"("_id") ON DELETE CASCADE,
                         CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("_roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
                         CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "_userId", "_roleId")

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

@@ -1,24 +1,27 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateFeaturesTableMigration {
     client;
     constructor(client) {
         this.client = client;
     }
     index = 9;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'features');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? ',\n                            CONSTRAINT "fk_features_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "features" (
                         "_id" VARCHAR(255) PRIMARY KEY,
                         "_orgId" VARCHAR(255),
                         "name" VARCHAR(255) NOT NULL,
-                        CONSTRAINT "fk_features_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
-                        CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")
+                        CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")${fkConstraint}
                     )
                 `);
             }

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

@@ -1,17 +1,21 @@
 import { randomUUID } from "crypto";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { config } from "../../../config/index.js";
 export class CreateAuthorizationsTableMigration {
     client;
     constructor(client) {
         this.client = client;
     }
     index = 10;
-    async execute(_orgId) {
+    async execute() {
         const _id = randomUUID().toString();
         try {
             await this.client.query('BEGIN');
             const tableExists = await doesTableExist(this.client, 'authorizations');
             if (!tableExists) {
+                const fkConstraint = config.app.isMultiTenant
+                    ? ',\n                            CONSTRAINT "fk_authorizations_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE'
+                    : '';
                 await this.client.query(`
                     CREATE TABLE "authorizations" (
                         "_id" VARCHAR(255) PRIMARY KEY,
@@ -27,10 +31,9 @@ export class CreateAuthorizationsTableMigration {
                         "_updatedBy" VARCHAR(255) NOT NULL,
                         "_deleted" TIMESTAMP,
                         "_deletedBy" VARCHAR(255),
-                        CONSTRAINT "fk_authorizations_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
                         CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("_roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
                         CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("_featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
-                        CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "_roleId", "_featureId")
+                        CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "_roleId", "_featureId")${fkConstraint}
                     )
                 `);
             }

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).catch(() => null);
+            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 (!adminUser) {
+                return { success: false, error: new Error('Create admin authorization: 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 ?? null]);
             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 ?? null, 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 ?? null]);
             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 ?? null, 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/database-builder.d.ts

@@ -0,0 +1,15 @@
+import { Client } from "pg";
+import { IDatabaseBuilder } from "./database-builder.interface.js";
+import { IMigration } from "./migration.interface.js";
+export declare class DatabaseBuilder implements IDatabaseBuilder {
+    private client;
+    private migrationsToRun;
+    constructor(client: Client);
+    withAuth(): IDatabaseBuilder;
+    withMultitenant(): IDatabaseBuilder;
+    withMigrations(migrations: IMigration[]): IDatabaseBuilder;
+    build(): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
+}

package/dist/databases/postgres/migrations/database-builder.interface.d.ts

@@ -0,0 +1,10 @@
+import { IMigration } from "./migration.interface.js";
+export interface IDatabaseBuilder {
+    withAuth(): IDatabaseBuilder;
+    withMultitenant(): IDatabaseBuilder;
+    withMigrations(migrations: IMigration[]): IDatabaseBuilder;
+    build(): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
+}

package/dist/databases/postgres/migrations/database-builder.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/postgres/migrations/database-builder.js

@@ -0,0 +1,62 @@
+import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
+import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
+import { CreateAdminUserMigration } from "./006-create-admin-user.migration.js";
+import { CreateUserRolesTableMigration } from "./008-create-user-roles-table.migration.js";
+import { CreateAuthorizationsTableMigration } from "./010-create-authorizations-table.migration.js";
+import { CreateFeaturesTableMigration } from "./009-create-features-table.migration.js";
+import { CreateRoleTableMigration } from "./007-create-roles-table.migration.js";
+import { CreateRefreshTokenTableMigration } from "./004-create-refresh-tokens-table.migration.js";
+import { CreateAdminAuthorizationMigration } from "./011-create-admin-authorization.migration.js";
+import { CreateMetaOrgMigration } from "./005-create-meta-org.migration.js";
+import { CreateOrganizationsTableMigration } from "./002-create-organizations-table.migration.js";
+import { doesTableExist } from "../utils/index.js";
+export class DatabaseBuilder {
+    client;
+    migrationsToRun = [];
+    constructor(client) {
+        this.client = client;
+    }
+    withAuth() {
+        this.migrationsToRun.push(new CreateMigrationTableMigration(this.client));
+        this.migrationsToRun.push(new CreateUsersTableMigration(this.client));
+        this.migrationsToRun.push(new CreateRefreshTokenTableMigration(this.client));
+        this.migrationsToRun.push(new CreateAdminUserMigration(this.client));
+        this.migrationsToRun.push(new CreateRoleTableMigration(this.client));
+        this.migrationsToRun.push(new CreateUserRolesTableMigration(this.client));
+        this.migrationsToRun.push(new CreateFeaturesTableMigration(this.client));
+        this.migrationsToRun.push(new CreateAuthorizationsTableMigration(this.client));
+        this.migrationsToRun.push(new CreateAdminAuthorizationMigration(this.client));
+        return this;
+    }
+    withMultitenant() {
+        this.migrationsToRun.push(new CreateMigrationTableMigration(this.client));
+        this.migrationsToRun.push(new CreateOrganizationsTableMigration(this.client));
+        this.migrationsToRun.push(new CreateMetaOrgMigration(this.client));
+        return this;
+    }
+    withMigrations(migrations) {
+        this.migrationsToRun.push(...migrations);
+        return this;
+    }
+    async build() {
+        let runMigrations = [];
+        if (await doesTableExist(this.client, 'migrations')) {
+            const migrations = await this.client.query(`
+                SELECT "_id", "index"
+                FROM migrations
+                WHERE "hasRun" = TRUE AND "reverted" = FALSE
+            `);
+            runMigrations = migrations.rows.map((row) => {
+                return row.index;
+            });
+        }
+        const orderedMigrations = this.migrationsToRun.filter((migration) => !runMigrations.includes(migration.index)).sort((migration) => migration.index);
+        for (const migration of orderedMigrations) {
+            const result = await migration.execute();
+            if (!result.success) {
+                return result;
+            }
+        }
+        return { success: true, error: null };
+    }
+}

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, adminEmail: 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, adminEmail, 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, adminEmail, adminPassword, me
             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, adminEmail, adminPassword, me
         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,24 +41,23 @@ export async function setupDatabaseForAuth(client, adminEmail, adminPassword, me
         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(adminEmail, adminPassword, metaOrgId);
+        const result = await migration.execute();
         if (!result.success) {
             console.error('setupDatabaseForAuth: error creating admin user', result.error);
-            return { success: false, error: result.error };
+            return result;
         }
-        adminUserId = result.adminUserId;
     }
     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)) {
@@ -67,7 +65,7 @@ export async function setupDatabaseForAuth(client, adminEmail, adminPassword, me
         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)) {
@@ -75,7 +73,7 @@ export async function setupDatabaseForAuth(client, adminEmail, adminPassword, me
         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)) {
@@ -83,19 +81,15 @@ export async function setupDatabaseForAuth(client, adminEmail, adminPassword, me
         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: false, error: new Error('Admin user ID is required') };
-        }
-        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,9 +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";
-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"
@@ -20,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)) {
@@ -28,17 +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 };
+            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 };
+            return result;
         }
-        metaOrgId = result.metaOrgId;
     }
-    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;
@@ -24,10 +30,10 @@ export interface IBaseApiConfig {
         deviceIdCookieMaxAgeInDays: number;
         passwordResetTokenExpirationInMinutes: number;
     };
-    email: {
-        emailApiKey?: string;
-        emailApiSecret?: string;
-        fromAddress?: string;
-        systemEmailAddress?: string;
+    email?: {
+        emailApiKey: string;
+        emailApiSecret: string;
+        fromAddress: string;
+        systemEmailAddress: string;
     };
 }

package/dist/services/email.service.js

@@ -5,16 +5,19 @@ export class EmailService {
     mailjet;
     constructor() {
         this.mailjet = new Mailjet.default({
-            apiKey: config.email.emailApiKey || '',
-            apiSecret: config.email.emailApiSecret || ''
+            apiKey: config.email?.emailApiKey || '',
+            apiSecret: config.email?.emailApiSecret || ''
         });
     }
     async sendHtmlEmail(emailAddress, subject, body) {
+        if (!config.email?.fromAddress) {
+            throw new ServerError('From address is not set in the config');
+        }
         const messageData = {
             Messages: [
                 {
                     From: {
-                        Email: config.email.fromAddress,
+                        Email: config.email?.fromAddress,
                         Name: config.appName || 'Application'
                     },
                     To: [