@loomcore/api 0.1.59 → 0.1.62

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

@@ -5,22 +5,22 @@ export const getPostgresTestSchema = (config) => {
         name: '00000000000100_schema-test-entities',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "testEntities" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL,
-          "description" TEXT,
-          "isActive" BOOLEAN,
-          "tags" TEXT[],
-          "count" INTEGER,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER
-        )
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "testEntities" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          "isActive" BOOLEAN,
+          "tags" TEXT[],
+          "count" INTEGER,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER
+        )
       `);
         },
         down: async ({ context: pool }) => {
@@ -31,12 +31,12 @@ export const getPostgresTestSchema = (config) => {
         name: '00000000000101_schema-categories',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "categories" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL
-        )
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "categories" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL
+        )
       `);
         },
         down: async ({ context: pool }) => {
@@ -47,22 +47,22 @@ export const getPostgresTestSchema = (config) => {
         name: '00000000000102_schema-products',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "products" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL,
-          "description" TEXT,
-          "internalNumber" VARCHAR(255),
-          "categoryId" INTEGER NOT NULL,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER,
-          CONSTRAINT "fk_products_category" FOREIGN KEY ("categoryId") REFERENCES "categories"("_id") ON DELETE CASCADE
-        )
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "products" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          "internalNumber" VARCHAR(255),
+          "categoryId" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT "fk_products_category" FOREIGN KEY ("categoryId") REFERENCES "categories"("_id") ON DELETE CASCADE
+        )
       `);
         },
         down: async ({ context: pool }) => {
@@ -73,20 +73,20 @@ export const getPostgresTestSchema = (config) => {
         name: '00000000000103_schema-test-items',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "testItems" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL,
-          "value" INTEGER,
-          "eventDate" TIMESTAMPTZ,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER
-        )
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "testItems" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "value" INTEGER,
+          "eventDate" TIMESTAMPTZ,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER
+        )
       `);
         },
         down: async ({ context: pool }) => {

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

@@ -40,9 +40,9 @@ export class TestPostgresDatabase {
     }
     async createIndexes(client) {
         try {
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS email_index ON users (LOWER(email));
-        CREATE UNIQUE INDEX IF NOT EXISTS email_unique_index ON users (LOWER(email));
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS email_index ON users (LOWER(email));
+        CREATE UNIQUE INDEX IF NOT EXISTS email_unique_index ON users (LOWER(email));
       `);
         }
         catch (error) {
@@ -53,11 +53,11 @@ export class TestPostgresDatabase {
         if (!this.postgresClient) {
             throw new Error('Database not initialized');
         }
-        const result = await this.postgresClient.query(`
-      SELECT "table_name" 
-      FROM information_schema.tables 
-      WHERE "table_schema" = 'public'
-      AND "table_type" = 'BASE TABLE'
+        const result = await this.postgresClient.query(`
+      SELECT "table_name" 
+      FROM information_schema.tables 
+      WHERE "table_schema" = 'public'
+      AND "table_type" = 'BASE TABLE'
     `);
         result.rows.forEach(async (row) => {
             await this.postgresClient?.query(`TRUNCATE TABLE "${row.table_name}" RESTART IDENTITY CASCADE`);

package/dist/__tests__/test-email-client.d.ts

@@ -0,0 +1,4 @@
+import { IEmailClient } from "../models/email-client.interface.js";
+export declare class TestEmailClient implements IEmailClient {
+    sendHtmlEmail(toEmailAddress: string, subject: string, body: string): Promise<void>;
+}

package/dist/__tests__/test-email-client.js

@@ -0,0 +1,6 @@
+export class TestEmailClient {
+    sendHtmlEmail(toEmailAddress, subject, body) {
+        console.log(`Sending email to ${toEmailAddress} with subject ${subject} and body ${body}`);
+        return Promise.resolve();
+    }
+}

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

@@ -1,9 +1,10 @@
 import { Application, Request, Response, NextFunction } from 'express';
 import { AuthService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
+import { IEmailClient } from '../models/email-client.interface.js';
 export declare class AuthController {
     authService: AuthService;
-    constructor(app: Application, database: IDatabase);
+    constructor(app: Application, database: IDatabase, emailClient: IEmailClient);
     mapRoutes(app: Application): void;
     login(req: Request, res: Response, next: NextFunction): Promise<void>;
     registerUser(req: Request, res: Response): Promise<void>;

package/dist/controllers/auth.controller.js

@@ -6,9 +6,8 @@ import { AuthService } from '../services/index.js';
 import { isAuthorized } from '../middleware/index.js';
 export class AuthController {
     authService;
-    constructor(app, database) {
-        const authService = new AuthService(database);
-        this.authService = authService;
+    constructor(app, database, emailClient) {
+        this.authService = new AuthService(database, emailClient);
         this.mapRoutes(app);
     }
     mapRoutes(app) {

package/dist/databases/migrations/migration-runner.d.ts

@@ -1,4 +1,5 @@
 import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
+import { IEmailClient } from '../../models/email-client.interface.js';
 export declare class MigrationRunner {
     private config;
     private dbType;
@@ -6,7 +7,8 @@ export declare class MigrationRunner {
     private migrationsDir;
     private primaryTimezone;
     private dbConnection;
-    constructor(config: IBaseApiConfig);
+    private emailClient?;
+    constructor(config: IBaseApiConfig, emailClient?: IEmailClient);
     private getTimestamp;
     private parseSql;
     private getMigrator;

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

@@ -15,13 +15,15 @@ export class MigrationRunner {
     migrationsDir;
     primaryTimezone;
     dbConnection;
-    constructor(config) {
+    emailClient;
+    constructor(config, emailClient) {
         setBaseApiConfig(config);
         this.config = config;
-        this.dbType = config.app.dbType || 'mongodb';
+        this.dbType = config.app.dbType;
         this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);
         this.migrationsDir = path.join(process.cwd(), 'database', 'migrations');
         this.primaryTimezone = config.app.primaryTimezone || 'UTC';
+        this.emailClient = emailClient;
     }
     getTimestamp() {
         const now = new Date();
@@ -58,7 +60,7 @@ export class MigrationRunner {
             this.dbConnection = pool;
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getPostgresInitialSchema(this.config).map(m => ({
+                    const initialSchema = getPostgresInitialSchema(this.config, this.emailClient).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -97,7 +99,7 @@ export class MigrationRunner {
             console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getMongoInitialSchema(this.config).map(m => ({
+                    const initialSchema = getMongoInitialSchema(this.config, this.emailClient).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -239,31 +241,31 @@ export class MigrationRunner {
         let content = '';
         if (this.dbType === 'postgres') {
             extension = 'sql';
-            content = `-- Migration: ${safeName}
--- Created: ${new Date().toISOString()}
-
--- up
--- Write your CREATE/ALTER statements here...
-
-
--- down
--- Write your DROP/UNDO statements here...
+            content = `-- Migration: ${safeName}
+-- Created: ${new Date().toISOString()}
+
+-- up
+-- Write your CREATE/ALTER statements here...
+
+
+-- down
+-- Write your DROP/UNDO statements here...
 `;
         }
         else {
             extension = 'ts';
-            content = `import { Db } from 'mongodb';
-
-// Migration: ${safeName}
-// Created: ${new Date().toISOString()}
-
-export const up = async ({ context: db }: { context: Db }) => {
-  // await db.collection('...')....
-};
-
-export const down = async ({ context: db }: { context: Db }) => {
-  // await db.collection('...')....
-};
+            content = `import { Db } from 'mongodb';
+
+// Migration: ${safeName}
+// Created: ${new Date().toISOString()}
+
+export const up = async ({ context: db }: { context: Db }) => {
+  // await db.collection('...')....
+};
+
+export const down = async ({ context: db }: { context: Db }) => {
+  // await db.collection('...')....
+};
 `;
         }
         const fullPath = path.join(this.migrationsDir, `${filename}.${extension}`);

package/dist/databases/mongo-db/migrations/mongo-initial-schema.d.ts

@@ -1,6 +1,7 @@
 import { Db } from 'mongodb';
 import { IBaseApiConfig } from '../../../models/base-api-config.interface.js';
-export interface SyntheticMigration {
+import { IEmailClient } from '../../../models/email-client.interface.js';
+export interface ISyntheticMigration {
     name: string;
     up: (context: {
         context: Db;
@@ -9,4 +10,4 @@ export interface SyntheticMigration {
         context: Db;
     }) => Promise<void>;
 }
-export declare const getMongoInitialSchema: (config: IBaseApiConfig) => SyntheticMigration[];
+export declare const getMongoInitialSchema: (config: IBaseApiConfig, emailClient?: IEmailClient) => ISyntheticMigration[];

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -2,18 +2,20 @@ import { randomUUID } from 'crypto';
 import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
 import { MongoDBDatabase } from '../mongo-db.database.js';
 import { AuthService, OrganizationService } from '../../../services/index.js';
-export const getMongoInitialSchema = (config) => {
+export const getMongoInitialSchema = (config, emailClient) => {
     const migrations = [];
-    const isMultiTenant = config.app.isMultiTenant === true;
-    console.log('📋 Migration Config Diagnostic:');
-    console.log('  isMultiTenant:', isMultiTenant);
-    console.log('  config.app.metaOrgName:', config.app.metaOrgName ?? '(undefined)');
-    console.log('  config.app.metaOrgCode:', config.app.metaOrgCode ?? '(undefined)');
-    console.log('  config.auth?.adminUser?.email:', config.auth?.adminUser?.email ?? '(undefined)');
-    console.log('  config.auth?.adminUser?.password:', config.auth?.adminUser?.password ? '(set)' : '(undefined)');
-    console.log('  Will add meta-org migration:', isMultiTenant && !!config.app.metaOrgName && !!config.app.metaOrgCode);
-    console.log('  Will add admin-user migration:', !!config.auth?.adminUser?.email && !!config.auth?.adminUser?.password);
-    if (isMultiTenant) {
+    const isMultiTenant = config.app.isMultiTenant;
+    if (isMultiTenant && !config.multiTenant) {
+        throw new Error('Multi-tenant configuration is enabled but multi-tenant configuration is not provided');
+    }
+    const isAuthEnabled = config.app.isAuthEnabled;
+    if (isAuthEnabled && !config.auth) {
+        throw new Error('Auth enabled without auth configuration');
+    }
+    if (isAuthEnabled && (!emailClient || !config.email)) {
+        throw new Error('Auth enabled without email client or email configuration');
+    }
+    if (isMultiTenant)
         migrations.push({
             name: '00000000000001_schema-organizations',
             up: async ({ context: db }) => {
@@ -26,115 +28,120 @@ export const getMongoInitialSchema = (config) => {
                 await db.collection('organizations').drop();
             }
         });
-    }
-    migrations.push({
-        name: '00000000000002_schema-users',
-        up: async ({ context: db }) => {
-            await db.createCollection('users');
-            if (isMultiTenant) {
-                await db.collection('users').createIndex({ _orgId: 1, email: 1 }, { unique: true });
-                await db.collection('users').createIndex({ _orgId: 1 });
-            }
-            else {
-                await db.collection('users').createIndex({ email: 1 }, { unique: true });
-            }
-        },
-        down: async ({ context: db }) => {
-            await db.collection('users').drop();
-        }
-    });
-    migrations.push({
-        name: '00000000000003_schema-refresh-tokens',
-        up: async ({ context: db }) => {
-            await db.createCollection('refreshTokens');
-            await db.collection('refreshTokens').createIndex({ token: 1 }, { unique: true });
-            await db.collection('refreshTokens').createIndex({ userId: 1 });
-            await db.collection('refreshTokens').createIndex({ deviceId: 1 });
-            if (isMultiTenant) {
-                await db.collection('refreshTokens').createIndex({ _orgId: 1 });
-            }
-        },
-        down: async ({ context: db }) => {
-            await db.collection('refreshTokens').drop();
-        }
-    });
-    migrations.push({
-        name: '00000000000004_schema-roles',
-        up: async ({ context: db }) => {
-            await db.createCollection('roles');
-            if (isMultiTenant) {
-                await db.collection('roles').createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                await db.collection('roles').createIndex({ _orgId: 1 });
-            }
-            else {
-                await db.collection('roles').createIndex({ name: 1 }, { unique: true });
-            }
-        },
-        down: async ({ context: db }) => {
-            await db.collection('roles').drop();
-        }
-    });
-    migrations.push({
-        name: '00000000000005_schema-user-roles',
-        up: async ({ context: db }) => {
-            await db.createCollection('user_roles');
-            if (isMultiTenant) {
-                await db.collection('user_roles').createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
-                await db.collection('user_roles').createIndex({ _orgId: 1 });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000002_schema-users',
+            up: async ({ context: db }) => {
+                await db.createCollection('users');
+                if (config.app.isMultiTenant) {
+                    await db.collection('users').createIndex({ _orgId: 1, email: 1 }, { unique: true });
+                    await db.collection('users').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('users').createIndex({ email: 1 }, { unique: true });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('users').drop();
             }
-            else {
-                await db.collection('user_roles').createIndex({ userId: 1, roleId: 1 }, { unique: true });
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000003_schema-refresh-tokens',
+            up: async ({ context: db }) => {
+                await db.createCollection('refreshTokens');
+                await db.collection('refreshTokens').createIndex({ token: 1 }, { unique: true });
+                await db.collection('refreshTokens').createIndex({ userId: 1 });
+                await db.collection('refreshTokens').createIndex({ deviceId: 1 });
+                if (isMultiTenant) {
+                    await db.collection('refreshTokens').createIndex({ _orgId: 1 });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('refreshTokens').drop();
             }
-            await db.collection('user_roles').createIndex({ userId: 1 });
-            await db.collection('user_roles').createIndex({ roleId: 1 });
-        },
-        down: async ({ context: db }) => {
-            await db.collection('user_roles').drop();
-        }
-    });
-    migrations.push({
-        name: '00000000000006_schema-features',
-        up: async ({ context: db }) => {
-            await db.createCollection('features');
-            if (isMultiTenant) {
-                await db.collection('features').createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                await db.collection('features').createIndex({ _orgId: 1 });
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000004_schema-roles',
+            up: async ({ context: db }) => {
+                await db.createCollection('roles');
+                if (isMultiTenant) {
+                    await db.collection('roles').createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                    await db.collection('roles').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('roles').createIndex({ name: 1 }, { unique: true });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('roles').drop();
             }
-            else {
-                await db.collection('features').createIndex({ name: 1 }, { unique: true });
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000005_schema-user-roles',
+            up: async ({ context: db }) => {
+                await db.createCollection('user_roles');
+                if (isMultiTenant) {
+                    await db.collection('user_roles').createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
+                    await db.collection('user_roles').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('user_roles').createIndex({ userId: 1, roleId: 1 }, { unique: true });
+                }
+                await db.collection('user_roles').createIndex({ userId: 1 });
+                await db.collection('user_roles').createIndex({ roleId: 1 });
+            },
+            down: async ({ context: db }) => {
+                await db.collection('user_roles').drop();
             }
-        },
-        down: async ({ context: db }) => {
-            await db.collection('features').drop();
-        }
-    });
-    migrations.push({
-        name: '00000000000007_schema-authorizations',
-        up: async ({ context: db }) => {
-            await db.createCollection('authorizations');
-            if (isMultiTenant) {
-                await db.collection('authorizations').createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
-                await db.collection('authorizations').createIndex({ _orgId: 1 });
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000006_schema-features',
+            up: async ({ context: db }) => {
+                await db.createCollection('features');
+                if (isMultiTenant) {
+                    await db.collection('features').createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                    await db.collection('features').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('features').createIndex({ name: 1 }, { unique: true });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('features').drop();
             }
-            else {
-                await db.collection('authorizations').createIndex({ roleId: 1, featureId: 1 }, { unique: true });
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000007_schema-authorizations',
+            up: async ({ context: db }) => {
+                await db.createCollection('authorizations');
+                if (isMultiTenant) {
+                    await db.collection('authorizations').createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
+                    await db.collection('authorizations').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('authorizations').createIndex({ roleId: 1, featureId: 1 }, { unique: true });
+                }
+                await db.collection('authorizations').createIndex({ roleId: 1 });
+                await db.collection('authorizations').createIndex({ featureId: 1 });
+            },
+            down: async ({ context: db }) => {
+                await db.collection('authorizations').drop();
             }
-            await db.collection('authorizations').createIndex({ roleId: 1 });
-            await db.collection('authorizations').createIndex({ featureId: 1 });
-        },
-        down: async ({ context: db }) => {
-            await db.collection('authorizations').drop();
-        }
-    });
-    if (isMultiTenant && config.app.metaOrgName && config.app.metaOrgCode) {
+        });
+    if (isMultiTenant) {
         migrations.push({
             name: '00000000000008_data-meta-org',
             up: async ({ context: db }) => {
                 const _id = randomUUID().toString();
                 const metaOrg = {
                     _id,
-                    name: config.app.metaOrgName,
-                    code: config.app.metaOrgCode,
+                    name: config.multiTenant.metaOrgName,
+                    code: config.multiTenant.metaOrgCode,
                     description: undefined,
                     status: 1,
                     isMetaOrg: true,
@@ -154,22 +161,20 @@ export const getMongoInitialSchema = (config) => {
             }
         });
     }
-    if (config.auth && config.auth.adminUser) {
+    if (isAuthEnabled) {
         migrations.push({
             name: '00000000000009_data-admin-user',
             up: async ({ context: db }) => {
-                if (!config.auth?.adminUser?.email || !config.auth?.adminUser?.password) {
-                    throw new Error('Admin user email and password must be provided in config');
-                }
                 const database = new MongoDBDatabase(db);
-                const authService = new AuthService(database);
-                if (isMultiTenant && !isSystemUserContextInitialized()) {
-                    throw new Error('SystemUserContext has not been initialized. The meta-org migration (00000000000008_data-meta-org) should have run before this migration. ' +
-                        'This migration only runs if config.app.metaOrgName and config.app.metaOrgCode are provided. ' +
-                        'Please ensure both values are set in your config.');
-                }
-                if (!isMultiTenant && !isSystemUserContextInitialized()) {
-                    initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', undefined);
+                const authService = new AuthService(database, emailClient);
+                if (!isSystemUserContextInitialized()) {
+                    const errorMessage = isMultiTenant
+                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000008_data-meta-org) should have run before this migration. ' +
+                            'This migration only runs if config.app.metaOrgName and config.app.metaOrgCode are provided. ' +
+                            'Please ensure both values are set in your config.'
+                        : 'BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.';
+                    console.error('❌ Migration Error:', errorMessage);
+                    throw new Error(errorMessage);
                 }
                 const systemUserContext = getSystemUserContext();
                 const _id = randomUUID().toString();
@@ -194,17 +199,14 @@ export const getMongoInitialSchema = (config) => {
         migrations.push({
             name: '00000000000010_data-admin-authorizations',
             up: async ({ context: db }) => {
-                if (!config.auth?.adminUser?.email) {
-                    throw new Error('Admin user email not found in config');
-                }
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const authService = new AuthService(database);
+                const authService = new AuthService(database, emailClient);
                 const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
                 if (!metaOrg) {
                     throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                 }
-                const adminUser = await authService.getUserByEmail(config.auth?.adminUser?.email);
+                const adminUser = await authService.getUserByEmail(config.auth.adminUser.email);
                 if (!adminUser) {
                     throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                 }