@loomcore/api 0.1.91 → 0.1.94

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -1,39 +1,34 @@
 import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
 import { PostgresDatabase } from '../postgres.database.js';
-import { AuthService, OrganizationService } from '../../../services/index.js';
-export const getPostgresInitialSchema = (config, resetConfig) => {
+import { OrganizationService } from '../../../services/index.js';
+import { passwordUtils } from '../../../utils/index.js';
+export const getPostgresInitialSchema = (dbConfig) => {
     const migrations = [];
-    const isMultiTenant = config.app.isMultiTenant;
-    if (isMultiTenant && !config.multiTenant) {
+    const isMultiTenant = dbConfig.app.isMultiTenant;
+    if (isMultiTenant && !dbConfig.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 && (!config.thirdPartyClients?.emailClient || !config.email)) {
-        throw new Error('Auth enabled without email client or email configuration');
-    }
+    const isAuthEnabled = dbConfig.app.isAuthEnabled;
     if (isMultiTenant) {
         migrations.push({
             name: '00000000000001_schema-organizations',
             up: async ({ context: pool }) => {
-                await pool.query(`
-          CREATE TABLE IF NOT EXISTS "organizations" (
-            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-            "name" VARCHAR(255) NOT NULL UNIQUE,
-            "code" VARCHAR(255) NOT NULL UNIQUE,
-            "description" TEXT,
-            "status" INTEGER NOT NULL,
-            "is_meta_org" BOOLEAN NOT NULL,
-            "auth_token" TEXT,
-            "_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 "organizations" (
+            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            "name" VARCHAR(255) NOT NULL UNIQUE,
+            "code" VARCHAR(255) NOT NULL UNIQUE,
+            "description" TEXT,
+            "status" INTEGER NOT NULL,
+            "is_meta_org" BOOLEAN NOT NULL,
+            "auth_token" TEXT,
+            "_created" TIMESTAMPTZ NOT NULL,
+            "_createdBy" INTEGER NOT NULL,
+            "_updated" TIMESTAMPTZ NOT NULL,
+            "_updatedBy" INTEGER NOT NULL,
+            "_deleted" TIMESTAMPTZ,
+            "_deletedBy" INTEGER
+          )
         `);
             },
             down: async ({ context: pool }) => {
@@ -46,26 +41,26 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
             name: '00000000000002_schema-persons',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-                await pool.query(`
-          CREATE TABLE IF NOT EXISTS "persons" (
-            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-            ${orgColumnDef}
-            "external_id" VARCHAR(255) UNIQUE,
-            "first_name" VARCHAR(255) NOT NULL,
-            "middle_name" VARCHAR(255),
-            "last_name" VARCHAR(255) NOT NULL,
-            "date_of_birth" DATE,
-            "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
-            "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
-            "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
-            "extended_types" 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 "persons" (
+            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            ${orgColumnDef}
+            "external_id" VARCHAR(255) UNIQUE,
+            "first_name" VARCHAR(255) NOT NULL,
+            "middle_name" VARCHAR(255),
+            "last_name" VARCHAR(255) NOT NULL,
+            "date_of_birth" DATE,
+            "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
+            "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
+            "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
+            "extended_types" 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 }) => {
@@ -80,27 +75,27 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 let uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
-                uniqueConstraint += `,
+                uniqueConstraint += `,
           CONSTRAINT "fk_users_person_id" FOREIGN KEY("person_id") REFERENCES "persons"("_id") ON DELETE CASCADE`;
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "users" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "external_id" VARCHAR(255) UNIQUE,
-          "email" VARCHAR(255) NOT NULL,
-          "display_name" VARCHAR(255),
-          "password" VARCHAR(255) NOT NULL,
-          "person_id" INTEGER UNIQUE,
-          "_lastLoggedIn" TIMESTAMPTZ,
-          "_lastPasswordChange" TIMESTAMPTZ,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "users" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "external_id" VARCHAR(255) UNIQUE,
+          "email" VARCHAR(255) NOT NULL,
+          "display_name" VARCHAR(255),
+          "password" VARCHAR(255) NOT NULL,
+          "person_id" INTEGER UNIQUE,
+          "_lastLoggedIn" TIMESTAMPTZ,
+          "_lastPasswordChange" TIMESTAMPTZ,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -112,18 +107,18 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
             name: '00000000000004_schema-refresh-tokens',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "refresh_tokens" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "token" VARCHAR(255) NOT NULL,
-          "device_id" VARCHAR(255) NOT NULL,
-          "user_id" INTEGER NOT NULL,
-          "expires_on" BIGINT NOT NULL,
-          "created" TIMESTAMPTZ NOT NULL,
-          "created_by" INTEGER NOT NULL,
-          CONSTRAINT "fk_refresh_tokens_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "refresh_tokens" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "token" VARCHAR(255) NOT NULL,
+          "device_id" VARCHAR(255) NOT NULL,
+          "user_id" INTEGER NOT NULL,
+          "expires_on" BIGINT NOT NULL,
+          "created" TIMESTAMPTZ NOT NULL,
+          "created_by" INTEGER NOT NULL,
+          CONSTRAINT "fk_refresh_tokens_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -138,21 +133,21 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_passwordResetTokens_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_passwordResetTokens_email" UNIQUE ("email")';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "password_reset_tokens" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "email" VARCHAR(255) NOT NULL,
-          "token" VARCHAR(255) NOT NULL,
-          "expires_on" BIGINT NOT NULL,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "password_reset_tokens" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "email" VARCHAR(255) NOT NULL,
+          "token" VARCHAR(255) NOT NULL,
+          "expires_on" BIGINT NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -167,14 +162,14 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")'
                     : 'CONSTRAINT "uk_roles_name" UNIQUE ("name")';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "roles" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL,
-          "description" TEXT,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "roles" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -189,22 +184,22 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "user_id", "role_id")'
                     : 'CONSTRAINT "uk_user_roles" UNIQUE ("user_id", "role_id")';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "user_roles" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "user_id" INTEGER NOT NULL,
-          "role_id" 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_user_roles_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "user_roles" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "user_id" INTEGER NOT NULL,
+          "role_id" 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_user_roles_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -219,14 +214,14 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")'
                     : 'CONSTRAINT "uk_features" UNIQUE ("name")';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "features" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "name" VARCHAR(255) NOT NULL,
-          "description" TEXT,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "features" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR(255) NOT NULL,
+          "description" TEXT,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -241,25 +236,25 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "role_id", "feature_id")'
                     : 'CONSTRAINT "uk_authorizations" UNIQUE ("role_id", "feature_id")';
-                await pool.query(`
-        CREATE TABLE IF NOT EXISTS "authorizations" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "role_id" INTEGER NOT NULL,
-          "feature_id" INTEGER NOT NULL,
-          "start_date" TIMESTAMPTZ,
-          "end_date" TIMESTAMPTZ,
-          "config" JSONB,
-          "_created" TIMESTAMPTZ NOT NULL,
-          "_createdBy" INTEGER NOT NULL,
-          "_updated" TIMESTAMPTZ NOT NULL,
-          "_updatedBy" INTEGER NOT NULL,
-          "_deleted" TIMESTAMPTZ,
-          "_deletedBy" INTEGER,
-          CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("feature_id") REFERENCES "features"("_id") ON DELETE CASCADE,
-          ${uniqueConstraint}
-        )
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "authorizations" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "role_id" INTEGER NOT NULL,
+          "feature_id" INTEGER NOT NULL,
+          "start_date" TIMESTAMPTZ,
+          "end_date" TIMESTAMPTZ,
+          "config" JSONB,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("feature_id") REFERENCES "features"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
       `);
             },
             down: async ({ context: pool }) => {
@@ -270,68 +265,68 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
         migrations.push({
             name: '00000000000010_data-meta-org',
             up: async ({ context: pool }) => {
-                const result = await pool.query(`
-          INSERT INTO "organizations" ("name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy")
-          VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
-          RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy"
-        `, [config.multiTenant?.metaOrgName, config.multiTenant?.metaOrgCode]);
+                const result = await pool.query(`
+          INSERT INTO "organizations" ("name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy")
+          VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
+          RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy"
+        `, [dbConfig.multiTenant?.metaOrgName, dbConfig.multiTenant?.metaOrgCode]);
                 if (result.rowCount === 0) {
                     throw new Error('Failed to create meta organization');
                 }
-                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', result.rows[0]);
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || 'system@example.com', result.rows[0]);
             },
             down: async ({ context: pool }) => {
                 await pool.query(`DELETE FROM "organizations" WHERE "is_meta_org" = TRUE`);
             }
         });
     }
-    if (isAuthEnabled && resetConfig?.adminUser) {
+    if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
             name: '00000000000011_data-admin-user',
             up: async ({ context: pool }) => {
+                if (!isSystemUserContextInitialized()) {
+                    const errorMessage = isMultiTenant
+                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. ' +
+                            'Please ensure metaOrgName and metaOrgCode are provided in your dbConfig.'
+                        : '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 orgId = isMultiTenant ? systemUserContext.organization?._id : undefined;
+                const hashedPassword = await passwordUtils.hashPassword(dbConfig.adminUser.password);
+                const email = dbConfig.adminUser.email.toLowerCase();
                 const client = await pool.connect();
                 try {
-                    const database = new PostgresDatabase(client);
-                    const authService = new AuthService(database);
-                    if (!isSystemUserContextInitialized()) {
-                        const errorMessage = isMultiTenant
-                            ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000009_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 userData = {
-                        email: resetConfig.adminUser.email,
-                        password: resetConfig.adminUser.password,
-                        displayName: 'Admin User',
-                    };
-                    if (isMultiTenant && systemUserContext.organization?._id) {
-                        userData._orgId = systemUserContext.organization._id;
+                    const personResult = isMultiTenant && orgId
+                        ? await client.query(`INSERT INTO "persons" ("_orgId", "first_name", "last_name", "is_agent", "is_client", "is_employee", "_created", "_createdBy", "_updated", "_updatedBy")
+                 VALUES ($1, 'Admin', 'User', false, false, false, NOW(), 0, NOW(), 0)
+                 RETURNING "_id"`, [orgId])
+                        : await client.query(`INSERT INTO "persons" ("first_name", "last_name", "is_agent", "is_client", "is_employee", "_created", "_createdBy", "_updated", "_updatedBy")
+                 VALUES ('Admin', 'User', false, false, false, NOW(), 0, NOW(), 0)
+                 RETURNING "_id"`);
+                    const personId = personResult.rows[0]._id;
+                    if (isMultiTenant && orgId) {
+                        await client.query(`INSERT INTO "users" ("_orgId", "email", "display_name", "password", "person_id", "_created", "_createdBy", "_updated", "_updatedBy")
+               VALUES ($1, $2, 'Admin User', $3, $4, NOW(), 0, NOW(), 0)`, [orgId, email, hashedPassword, personId]);
                     }
-                    const personData = {
-                        firstName: 'Admin',
-                        lastName: 'User',
-                    };
-                    if (isMultiTenant && systemUserContext.organization?._id) {
-                        personData._orgId = systemUserContext.organization._id;
+                    else {
+                        await client.query(`INSERT INTO "users" ("email", "display_name", "password", "person_id", "_created", "_createdBy", "_updated", "_updatedBy")
+               VALUES ($1, 'Admin User', $2, $3, NOW(), 0, NOW(), 0)`, [email, hashedPassword, personId]);
                     }
-                    await authService.createUser(systemUserContext, userData, personData);
                 }
                 finally {
                     client.release();
                 }
             },
             down: async ({ context: pool }) => {
-                if (!resetConfig?.adminUser?.email)
+                if (!dbConfig.adminUser?.email)
                     return;
-                const result = await pool.query(`DELETE FROM "users" WHERE "email" = $1`, [resetConfig.adminUser.email]);
+                await pool.query(`DELETE FROM "users" WHERE "email" = $1`, [dbConfig.adminUser.email.toLowerCase()]);
             }
         });
     }
-    if (config.auth && resetConfig) {
+    if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
             name: '00000000000012_data-admin-authorizations',
             up: async ({ context: pool }) => {
@@ -339,73 +334,75 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                 try {
                     const database = new PostgresDatabase(client);
                     const organizationService = new OrganizationService(database);
-                    const authService = new AuthService(database);
                     const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
                     if (isMultiTenant && !metaOrg) {
                         throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
                     }
-                    const adminUser = await authService.getUserByEmail(resetConfig.adminUser.email);
-                    if (!adminUser) {
+                    const email = dbConfig.adminUser.email.toLowerCase();
+                    const userResult = await client.query(`SELECT "_id" FROM "users" WHERE "email" = $1`, [email]);
+                    const adminUserRow = userResult.rows[0];
+                    if (!adminUserRow) {
                         throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                     }
+                    const adminUserId = adminUserRow._id;
                     await client.query('BEGIN');
                     try {
                         const roleResult = isMultiTenant
-                            ? await client.query(`
-                  INSERT INTO "roles" ("_orgId", "name")
-                  VALUES ($1, 'admin')
-                  RETURNING "_id"
+                            ? await client.query(`
+                  INSERT INTO "roles" ("_orgId", "name")
+                  VALUES ($1, 'admin')
+                  RETURNING "_id"
                 `, [metaOrg._id])
-                            : await client.query(`
-                  INSERT INTO "roles" ("name")
-                  VALUES ('admin')
-                  RETURNING "_id"
+                            : await client.query(`
+                  INSERT INTO "roles" ("name")
+                  VALUES ('admin')
+                  RETURNING "_id"
                 `);
                         if (roleResult.rowCount === 0) {
                             throw new Error('Failed to create admin role');
                         }
                         const roleId = roleResult.rows[0]._id;
                         const userRoleResult = isMultiTenant
-                            ? await client.query(`
-                  INSERT INTO "user_roles" ("_orgId", "user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
-                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
-                `, [metaOrg._id, adminUser._id, roleId])
-                            : await client.query(`
-                  INSERT INTO "user_roles" ("user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
-                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
-                `, [adminUser._id, roleId]);
+                            ? await client.query(`
+                  INSERT INTO "user_roles" ("_orgId", "user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                `, [metaOrg._id, adminUserId, roleId])
+                            : await client.query(`
+                  INSERT INTO "user_roles" ("user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                `, [adminUserId, roleId]);
                         if (userRoleResult.rowCount === 0) {
                             throw new Error('Failed to create user role');
                         }
                         const featureResult = isMultiTenant
-                            ? await client.query(`
-                  INSERT INTO "features" ("_orgId", "name")
-                  VALUES ($1, 'admin')
-                  RETURNING "_id"
+                            ? await client.query(`
+                  INSERT INTO "features" ("_orgId", "name")
+                  VALUES ($1, 'admin')
+                  RETURNING "_id"
                 `, [metaOrg._id])
-                            : await client.query(`
-                  INSERT INTO "features" ("name")
-                  VALUES ('admin')
-                  RETURNING "_id"
+                            : await client.query(`
+                  INSERT INTO "features" ("name")
+                  VALUES ('admin')
+                  RETURNING "_id"
                 `);
                         if (featureResult.rowCount === 0) {
                             throw new Error('Failed to create admin feature');
                         }
                         const featureId = featureResult.rows[0]._id;
                         const authorizationResult = isMultiTenant
-                            ? await client.query(`
-                  INSERT INTO "authorizations" (
-                    "_orgId", "role_id", "feature_id", 
-                    "_created", "_createdBy", "_updated", "_updatedBy"
-                  )
-                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                            ? await client.query(`
+                  INSERT INTO "authorizations" (
+                    "_orgId", "role_id", "feature_id", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                  )
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
                 `, [metaOrg._id, roleId, featureId])
-                            : await client.query(`
-                  INSERT INTO "authorizations" (
-                    "role_id", "feature_id", 
-                    "_created", "_createdBy", "_updated", "_updatedBy"
-                  )
-                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                            : await client.query(`
+                  INSERT INTO "authorizations" (
+                    "role_id", "feature_id", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                  )
+                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
                 `, [roleId, featureId]);
                         if (authorizationResult.rowCount === 0) {
                             throw new Error('Failed to create admin authorization');
@@ -432,61 +429,61 @@ export const getPostgresInitialSchema = (config, resetConfig) => {
                     await client.query('BEGIN');
                     try {
                         if (isMultiTenant) {
-                            await client.query(`
-                DELETE FROM "authorizations" 
-                WHERE "_orgId" = $1 
-                AND "feature_id" IN (
-                  SELECT "_id" FROM "features" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
-                AND "role_id" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "_orgId" = $1 
+                AND "feature_id" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+                AND "role_id" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
               `, [metaOrg._id]);
-                            await client.query(`
-                DELETE FROM "features" 
-                WHERE "_orgId" = $1 AND "name" = 'admin'
+                            await client.query(`
+                DELETE FROM "features" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
               `, [metaOrg._id]);
-                            await client.query(`
-                DELETE FROM "user_roles" 
-                WHERE "_orgId" = $1 
-                AND "role_id" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "_orgId" = $1 
+                AND "role_id" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
               `, [metaOrg._id]);
-                            await client.query(`
-                DELETE FROM "roles" 
-                WHERE "_orgId" = $1 AND "name" = 'admin'
+                            await client.query(`
+                DELETE FROM "roles" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
               `, [metaOrg._id]);
                         }
                         else {
-                            await client.query(`
-                DELETE FROM "authorizations" 
-                WHERE "feature_id" IN (
-                  SELECT "_id" FROM "features" 
-                  WHERE "name" = 'admin'
-                )
-                AND "role_id" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "feature_id" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "name" = 'admin'
+                )
+                AND "role_id" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "name" = 'admin'
+                )
               `);
-                            await client.query(`
-                DELETE FROM "features" 
-                WHERE "name" = 'admin'
+                            await client.query(`
+                DELETE FROM "features" 
+                WHERE "name" = 'admin'
               `);
-                            await client.query(`
-                DELETE FROM "user_roles" 
-                WHERE "role_id" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "role_id" IN (
+                  SELECT "_id" FROM "roles" 
+                  WHERE "name" = 'admin'
+                )
               `);
-                            await client.query(`
-                DELETE FROM "roles" 
-                WHERE "name" = 'admin'
+                            await client.query(`
+                DELETE FROM "roles" 
+                WHERE "name" = 'admin'
               `);
                         }
                         await client.query('COMMIT');