@loomcore/api 0.1.59 → 0.1.62

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

@@ -1,37 +1,39 @@
 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) => {
+export const getPostgresInitialSchema = (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);
+    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: 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,
-            "isMetaOrg" BOOLEAN NOT NULL,
-            "authToken" 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,
+            "isMetaOrg" BOOLEAN NOT NULL,
+            "authToken" 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 }) => {
@@ -39,172 +41,178 @@ export const getPostgresInitialSchema = (config) => {
             }
         });
     }
-    migrations.push({
-        name: '00000000000002_schema-users',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            const uniqueConstraint = isMultiTenant
-                ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
-                : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "users" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "email" VARCHAR(255) NOT NULL,
-          "firstName" VARCHAR(255),
-          "lastName" VARCHAR(255),
-          "displayName" VARCHAR(255),
-          "password" VARCHAR(255) NOT NULL,
-          "_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}
-        )
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000002_schema-users',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                const uniqueConstraint = isMultiTenant
+                    ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
+                    : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "users" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "email" VARCHAR(255) NOT NULL,
+          "firstName" VARCHAR(255),
+          "lastName" VARCHAR(255),
+          "displayName" VARCHAR(255),
+          "password" VARCHAR(255) NOT NULL,
+          "_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 }) => {
-            await pool.query('DROP TABLE IF EXISTS "users"');
-        }
-    });
-    migrations.push({
-        name: '00000000000003_schema-refresh-tokens',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "refreshTokens" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "token" VARCHAR(255) NOT NULL,
-          "deviceId" VARCHAR(255) NOT NULL,
-          "userId" INTEGER NOT NULL,
-          "expiresOn" BIGINT NOT NULL,
-          "created" TIMESTAMPTZ NOT NULL,
-          "createdBy" INTEGER NOT NULL,
-          CONSTRAINT "fk_refreshTokens_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE
-        )
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "users"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000003_schema-refresh-tokens',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "refreshTokens" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "token" VARCHAR(255) NOT NULL,
+          "deviceId" VARCHAR(255) NOT NULL,
+          "userId" INTEGER NOT NULL,
+          "expiresOn" BIGINT NOT NULL,
+          "created" TIMESTAMPTZ NOT NULL,
+          "createdBy" INTEGER NOT NULL,
+          CONSTRAINT "fk_refreshTokens_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE
+        )
       `);
-        },
-        down: async ({ context: pool }) => {
-            await pool.query('DROP TABLE IF EXISTS "refreshTokens"');
-        }
-    });
-    migrations.push({
-        name: '00000000000004_schema-roles',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            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}
-        )
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "refreshTokens"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000004_schema-roles',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                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}
+        )
       `);
-        },
-        down: async ({ context: pool }) => {
-            await pool.query('DROP TABLE IF EXISTS "roles"');
-        }
-    });
-    migrations.push({
-        name: '00000000000005_schema-user-roles',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            const uniqueConstraint = isMultiTenant
-                ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "userId", "roleId")'
-                : 'CONSTRAINT "uk_user_roles" UNIQUE ("userId", "roleId")';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "user_roles" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "userId" INTEGER NOT NULL,
-          "roleId" 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 ("userId") REFERENCES "users"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
-          ${uniqueConstraint}
-        )
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "roles"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000005_schema-user-roles',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                const uniqueConstraint = isMultiTenant
+                    ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "userId", "roleId")'
+                    : 'CONSTRAINT "uk_user_roles" UNIQUE ("userId", "roleId")';
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "user_roles" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "userId" INTEGER NOT NULL,
+          "roleId" 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 ("userId") REFERENCES "users"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
       `);
-        },
-        down: async ({ context: pool }) => {
-            await pool.query('DROP TABLE IF EXISTS "user_roles"');
-        }
-    });
-    migrations.push({
-        name: '00000000000006_schema-features',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            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}
-        )
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "user_roles"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000006_schema-features',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                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}
+        )
       `);
-        },
-        down: async ({ context: pool }) => {
-            await pool.query('DROP TABLE IF EXISTS "features"');
-        }
-    });
-    migrations.push({
-        name: '00000000000007_schema-authorizations',
-        up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-            const uniqueConstraint = isMultiTenant
-                ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "roleId", "featureId")'
-                : 'CONSTRAINT "uk_authorizations" UNIQUE ("roleId", "featureId")';
-            await pool.query(`
-        CREATE TABLE IF NOT EXISTS "authorizations" (
-          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-          ${orgColumnDef}
-          "roleId" INTEGER NOT NULL,
-          "featureId" INTEGER NOT NULL,
-          "startDate" TIMESTAMPTZ,
-          "endDate" 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 ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
-          ${uniqueConstraint}
-        )
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "features"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000007_schema-authorizations',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                const uniqueConstraint = isMultiTenant
+                    ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "roleId", "featureId")'
+                    : 'CONSTRAINT "uk_authorizations" UNIQUE ("roleId", "featureId")';
+                await pool.query(`
+        CREATE TABLE IF NOT EXISTS "authorizations" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "roleId" INTEGER NOT NULL,
+          "featureId" INTEGER NOT NULL,
+          "startDate" TIMESTAMPTZ,
+          "endDate" 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 ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
+          ${uniqueConstraint}
+        )
       `);
-        },
-        down: async ({ context: pool }) => {
-            await pool.query('DROP TABLE IF EXISTS "authorizations"');
-        }
-    });
-    if (isMultiTenant && config.app.metaOrgName && config.app.metaOrgCode) {
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "authorizations"');
+            }
+        });
+    if (isMultiTenant) {
         migrations.push({
             name: '00000000000008_data-meta-org',
             up: async ({ context: pool }) => {
-                const result = await pool.query(`
-          INSERT INTO "organizations" ("name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
-          VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
-          RETURNING "_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy"
-        `, [config.app.metaOrgName, config.app.metaOrgCode]);
+                const result = await pool.query(`
+          INSERT INTO "organizations" ("name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
+          VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
+          RETURNING "_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy"
+        `, [config.multiTenant?.metaOrgName, config.multiTenant?.metaOrgCode]);
                 if (result.rowCount === 0) {
                     throw new Error('Failed to create meta organization');
                 }
@@ -215,24 +223,22 @@ export const getPostgresInitialSchema = (config) => {
             }
         });
     }
-    if (config.auth?.adminUser?.email && config.auth?.adminUser?.password) {
+    if (isAuthEnabled) {
         migrations.push({
             name: '00000000000009_data-admin-user',
             up: async ({ context: pool }) => {
-                if (!config.auth?.adminUser?.email || !config.auth?.adminUser?.password) {
-                    throw new Error('Admin user email and password must be provided in config');
-                }
                 const client = await pool.connect();
                 try {
                     const database = new PostgresDatabase(client);
-                    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 userData = {
@@ -258,84 +264,81 @@ export const getPostgresInitialSchema = (config) => {
             }
         });
     }
-    if (config.auth?.adminUser?.email) {
+    if (config.auth) {
         migrations.push({
             name: '00000000000010_data-admin-authorizations',
             up: async ({ context: pool }) => {
-                if (!config.auth?.adminUser?.email) {
-                    throw new Error('Admin user email not found in config');
-                }
                 const client = await pool.connect();
                 try {
                     const database = new PostgresDatabase(client);
                     const organizationService = new OrganizationService(database);
-                    const authService = new AuthService(database);
+                    const authService = new AuthService(database, emailClient);
                     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(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.');
                     }
                     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", "userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
-                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                            ? await client.query(`
+                  INSERT INTO "user_roles" ("_orgId", "userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
                 `, [metaOrg._id, adminUser._id, roleId])
-                            : await client.query(`
-                  INSERT INTO "user_roles" ("userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
-                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                            : await client.query(`
+                  INSERT INTO "user_roles" ("userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
                 `, [adminUser._id, 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", "roleId", "featureId", 
-                    "_created", "_createdBy", "_updated", "_updatedBy"
-                  )
-                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
+                            ? await client.query(`
+                  INSERT INTO "authorizations" (
+                    "_orgId", "roleId", "featureId", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                  )
+                  VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
                 `, [metaOrg._id, roleId, featureId])
-                            : await client.query(`
-                  INSERT INTO "authorizations" (
-                    "roleId", "featureId", 
-                    "_created", "_createdBy", "_updated", "_updatedBy"
-                  )
-                  VALUES ($1, $2, NOW(), 0, NOW(), 0)
+                            : await client.query(`
+                  INSERT INTO "authorizations" (
+                    "roleId", "featureId", 
+                    "_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');
@@ -362,61 +365,61 @@ export const getPostgresInitialSchema = (config) => {
                     await client.query('BEGIN');
                     try {
                         if (isMultiTenant) {
-                            await client.query(`
-                DELETE FROM "authorizations" 
-                WHERE "_orgId" = $1 
-                AND "featureId" IN (
-                  SELECT "_id" FROM "features" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
-                AND "roleId" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "_orgId" = $1 
+                AND "featureId" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+                AND "roleId" 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 "roleId" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "_orgId" = $1 AND "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "_orgId" = $1 
+                AND "roleId" 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 "featureId" IN (
-                  SELECT "_id" FROM "features" 
-                  WHERE "name" = 'admin'
-                )
-                AND "roleId" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "featureId" IN (
+                  SELECT "_id" FROM "features" 
+                  WHERE "name" = 'admin'
+                )
+                AND "roleId" 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 "roleId" IN (
-                  SELECT "_id" FROM "roles" 
-                  WHERE "name" = 'admin'
-                )
+                            await client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "roleId" 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');