@loomcore/api 0.1.91 → 0.1.94

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

@@ -78,9 +78,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) {
@@ -91,11 +91,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/config/base-api-config.d.ts

@@ -1,5 +1,5 @@
 import { IBaseApiConfig } from '../models/index.js';
 import { IDatabase } from '../databases/models/index.js';
 export declare let config: IBaseApiConfig;
-export declare function setBaseApiConfig(apiConfig: IBaseApiConfig): void;
+export declare function setBaseApiConfig(theConfig: IBaseApiConfig): void;
 export declare function initSystemUserContext(database: IDatabase): Promise<void>;

package/dist/config/base-api-config.js

@@ -2,16 +2,21 @@ import { EmptyUserContext, initializeSystemUserContext } from '@loomcore/common/
 export let config;
 let isConfigSet = false;
 let isSystemUserContextSet = false;
-function copyOnlyBaseApiConfigProperties(obj) {
-    const baseConfig = {};
-    Object.keys(obj).forEach((key) => {
-        baseConfig[key] = obj[key];
+const BASE_API_CONFIG_KEYS = [
+    'app', 'auth', 'database', 'debug', 'email', 'env', 'network', 'thirdPartyClients'
+];
+function copyOnlySpecifiedConfigProperties(obj, allowedKeys) {
+    const result = {};
+    allowedKeys.forEach((key) => {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
     });
-    return baseConfig;
+    return result;
 }
-export function setBaseApiConfig(apiConfig) {
+export function setBaseApiConfig(theConfig) {
     if (!isConfigSet) {
-        config = copyOnlyBaseApiConfigProperties(apiConfig);
+        config = copyOnlySpecifiedConfigProperties(theConfig, BASE_API_CONFIG_KEYS);
         isConfigSet = true;
     }
     else if (config.env !== 'test') {

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

@@ -1,14 +1,12 @@
-import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
-import { IResetApiConfig } from '../../models/reset-api-config.interface.js';
+import { IInitialDbMigrationConfig } from '../../models/initial-database-config.interface.js';
 export declare class MigrationRunner {
-    private config;
-    private resetConfig?;
+    private dbMigrationConfig;
     private dbType;
     private dbUrl;
     private migrationsDir;
     private primaryTimezone;
     private dbConnection;
-    constructor(config: IBaseApiConfig, resetConfig?: IResetApiConfig);
+    constructor(dbMigrationConfig: IInitialDbMigrationConfig, resetConfig?: IInitialDbMigrationConfig);
     private getTimestamp;
     private parseSql;
     private getMigrator;

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

@@ -1,7 +1,6 @@
 import { Umzug, MongoDBStorage } from 'umzug';
 import { Pool } from 'pg';
 import { MongoClient } from 'mongodb';
-import { setBaseApiConfig } from '../../config/index.js';
 import fs from 'fs';
 import path from 'path';
 import { buildMongoUrl } from '../mongo-db/utils/build-mongo-url.util.js';
@@ -9,21 +8,18 @@ import { buildPostgresUrl } from '../postgres/utils/build-postgres-url.util.js';
 import { getPostgresInitialSchema } from '../postgres/migrations/postgres-initial-schema.js';
 import { getMongoInitialSchema } from '../mongo-db/migrations/mongo-initial-schema.js';
 export class MigrationRunner {
-    config;
-    resetConfig;
+    dbMigrationConfig;
     dbType;
     dbUrl;
     migrationsDir;
     primaryTimezone;
     dbConnection;
-    constructor(config, resetConfig) {
-        setBaseApiConfig(config);
-        this.config = config;
-        this.resetConfig = resetConfig;
-        this.dbType = config.app.dbType;
-        this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);
+    constructor(dbMigrationConfig, resetConfig) {
+        this.dbMigrationConfig = dbMigrationConfig;
+        this.dbType = dbMigrationConfig.app.dbType;
+        this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(dbMigrationConfig) : buildMongoUrl(dbMigrationConfig);
         this.migrationsDir = path.join(process.cwd(), 'database', 'migrations');
-        this.primaryTimezone = config.app.primaryTimezone || 'UTC';
+        this.primaryTimezone = dbMigrationConfig.app.primaryTimezone || 'UTC';
     }
     getTimestamp() {
         const now = new Date();
@@ -57,16 +53,16 @@ export class MigrationRunner {
         }
         if (this.dbType === 'postgres') {
             const pool = new Pool({
-                host: this.config.database.host,
-                user: this.config.database.username,
-                password: this.config.database.password,
-                port: this.config.database.port,
-                database: this.config.database.name
+                host: this.dbMigrationConfig.database.host,
+                user: this.dbMigrationConfig.database.username,
+                password: this.dbMigrationConfig.database.password,
+                port: this.dbMigrationConfig.database.port,
+                database: this.dbMigrationConfig.database.name
             });
             this.dbConnection = pool;
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getPostgresInitialSchema(this.config, this.resetConfig).map(m => ({
+                    const initialSchema = getPostgresInitialSchema(this.dbMigrationConfig).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -105,7 +101,7 @@ export class MigrationRunner {
             console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getMongoInitialSchema(this.config, this.resetConfig).map(m => ({
+                    const initialSchema = getMongoInitialSchema(this.dbMigrationConfig).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -165,11 +161,11 @@ export class MigrationRunner {
         console.log(`⚠️  Wiping ${this.dbType} database...`);
         if (this.dbType === 'postgres') {
             const pool = new Pool({
-                host: this.config.database.host,
-                user: this.config.database.username,
-                password: this.config.database.password,
-                port: this.config.database.port,
-                database: this.config.database.name
+                host: this.dbMigrationConfig.database.host,
+                user: this.dbMigrationConfig.database.username,
+                password: this.dbMigrationConfig.database.password,
+                port: this.dbMigrationConfig.database.port,
+                database: this.dbMigrationConfig.database.name
             });
             try {
                 await pool.query('DROP SCHEMA public CASCADE; CREATE SCHEMA public;');
@@ -188,7 +184,7 @@ export class MigrationRunner {
     async run(command = 'up', target) {
         try {
             if (command === 'reset') {
-                if (!this.resetConfig) {
+                if (!this.dbMigrationConfig) {
                     throw new Error('Reset configuration not found');
                 }
                 await this.wipeDatabase();
@@ -256,31 +252,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,5 @@
 import { Db } from 'mongodb';
-import { IBaseApiConfig } from '../../../models/base-api-config.interface.js';
-import { IResetApiConfig } from '../../../models/reset-api-config.interface.js';
+import { IInitialDbMigrationConfig } from '../../../models/initial-database-config.interface.js';
 export interface ISyntheticMigration {
     name: string;
     up: (context: {
@@ -10,4 +9,4 @@ export interface ISyntheticMigration {
         context: Db;
     }) => Promise<void>;
 }
-export declare const getMongoInitialSchema: (config: IBaseApiConfig, resetConfig?: IResetApiConfig) => ISyntheticMigration[];
+export declare const getMongoInitialSchema: (dbConfig: IInitialDbMigrationConfig) => ISyntheticMigration[];

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

@@ -1,20 +1,14 @@
-import { randomUUID } from 'crypto';
-import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized, personModelSpec } from '@loomcore/common/models';
+import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
 import { MongoDBDatabase } from '../mongo-db.database.js';
-import { AuthService, GenericApiService, OrganizationService } from '../../../services/index.js';
-export const getMongoInitialSchema = (config, resetConfig) => {
+import { OrganizationService } from '../../../services/index.js';
+import { passwordUtils } from '../../../utils/index.js';
+export const getMongoInitialSchema = (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',
@@ -30,10 +24,27 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000002_schema-users',
+            name: '00000000000002_schema-persons',
+            up: async ({ context: db }) => {
+                await db.createCollection('persons');
+                if (isMultiTenant) {
+                    await db.collection('persons').createIndex({ _orgId: 1 });
+                    await db.collection('persons').createIndex({ _orgId: 1, externalId: 1 }, { unique: true, sparse: true });
+                }
+                else {
+                    await db.collection('persons').createIndex({ externalId: 1 }, { unique: true, sparse: true });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('persons').drop();
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000003_schema-users',
             up: async ({ context: db }) => {
                 await db.createCollection('users');
-                if (config.app.isMultiTenant) {
+                if (dbConfig.app.isMultiTenant) {
                     await db.collection('users').createIndex({ _orgId: 1, email: 1 }, { unique: true });
                     await db.collection('users').createIndex({ _orgId: 1 });
                 }
@@ -47,7 +58,7 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000003_schema-refresh-tokens',
+            name: '00000000000004_schema-refresh-tokens',
             up: async ({ context: db }) => {
                 await db.createCollection('refresh_tokens');
                 await db.collection('refresh_tokens').createIndex({ token: 1 }, { unique: true });
@@ -63,7 +74,24 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000004_schema-roles',
+            name: '00000000000005_schema-password-reset-tokens',
+            up: async ({ context: db }) => {
+                await db.createCollection('password_reset_tokens');
+                if (isMultiTenant) {
+                    await db.collection('password_reset_tokens').createIndex({ _orgId: 1, email: 1 }, { unique: true });
+                    await db.collection('password_reset_tokens').createIndex({ _orgId: 1 });
+                }
+                else {
+                    await db.collection('password_reset_tokens').createIndex({ email: 1 }, { unique: true });
+                }
+            },
+            down: async ({ context: db }) => {
+                await db.collection('password_reset_tokens').drop();
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000006_schema-roles',
             up: async ({ context: db }) => {
                 await db.createCollection('roles');
                 if (isMultiTenant) {
@@ -80,7 +108,7 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000005_schema-user-roles',
+            name: '00000000000007_schema-user-roles',
             up: async ({ context: db }) => {
                 await db.createCollection('user_roles');
                 if (isMultiTenant) {
@@ -99,7 +127,7 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000006_schema-features',
+            name: '00000000000008_schema-features',
             up: async ({ context: db }) => {
                 await db.createCollection('features');
                 if (isMultiTenant) {
@@ -116,7 +144,7 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000007_schema-authorizations',
+            name: '00000000000009_schema-authorizations',
             up: async ({ context: db }) => {
                 await db.createCollection('authorizations');
                 if (isMultiTenant) {
@@ -135,13 +163,11 @@ export const getMongoInitialSchema = (config, resetConfig) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: '00000000000008_data-meta-org',
+            name: '00000000000010_data-meta-org',
             up: async ({ context: db }) => {
-                const _id = randomUUID().toString();
-                const metaOrg = {
-                    _id,
-                    name: config.multiTenant.metaOrgName,
-                    code: config.multiTenant.metaOrgCode,
+                const metaOrgDoc = {
+                    name: dbConfig.multiTenant.metaOrgName,
+                    code: dbConfig.multiTenant.metaOrgCode,
                     description: undefined,
                     status: 1,
                     isMetaOrg: true,
@@ -153,36 +179,33 @@ export const getMongoInitialSchema = (config, resetConfig) => {
                     _deleted: undefined,
                     _deletedBy: undefined
                 };
-                await db.collection('organizations').insertOne(metaOrg);
-                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', metaOrg);
+                const result = await db.collection('organizations').insertOne(metaOrgDoc);
+                const metaOrg = { ...metaOrgDoc, _id: result.insertedId };
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || 'system@example.com', metaOrg);
             },
             down: async ({ context: db }) => {
                 await db.collection('organizations').deleteMany({ isMetaOrg: true });
             }
         });
     }
-    if (isAuthEnabled && resetConfig) {
+    if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000009_data-admin-user',
+            name: '00000000000011_data-admin-user',
             up: async ({ context: db }) => {
-                const database = new MongoDBDatabase(db);
-                const authService = new AuthService(database);
-                const personService = new GenericApiService(database, 'persons', 'person', personModelSpec);
                 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.'
+                        ? '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 _id = randomUUID().toString();
-                const personId = randomUUID().toString();
-                const person = {
-                    _id: personId,
-                    _orgId: systemUserContext.organization?._id,
+                const orgDoc = isMultiTenant && systemUserContext.organization?._id ? { _orgId: systemUserContext.organization._id } : {};
+                const hashedPassword = await passwordUtils.hashPassword(dbConfig.adminUser.password);
+                const email = dbConfig.adminUser.email.toLowerCase();
+                const personResult = await db.collection('persons').insertOne({
+                    ...orgDoc,
                     externalId: 'admin-user-person-external-id',
                     firstName: 'Admin',
                     lastName: 'User',
@@ -193,50 +216,51 @@ export const getMongoInitialSchema = (config, resetConfig) => {
                     _createdBy: 'system',
                     _updated: new Date(),
                     _updatedBy: 'system'
-                };
-                await authService.createUser(systemUserContext, {
-                    _id: _id,
-                    _orgId: systemUserContext.organization?._id,
+                });
+                await db.collection('users').insertOne({
+                    ...orgDoc,
                     externalId: 'admin-user-external-id',
-                    email: resetConfig.adminUser.email,
-                    password: resetConfig.adminUser.password,
+                    email,
+                    password: hashedPassword,
                     displayName: 'Admin User',
-                }, person);
+                    personId: personResult.insertedId,
+                    _created: new Date(),
+                    _createdBy: 'system',
+                    _updated: new Date(),
+                    _updatedBy: 'system'
+                });
             },
             down: async ({ context: db }) => {
-                if (!resetConfig?.adminUser?.email)
+                if (!dbConfig?.adminUser?.email)
                     return;
-                await db.collection('users').deleteOne({ email: resetConfig.adminUser.email });
+                await db.collection('users').deleteOne({ email: dbConfig.adminUser.email.toLowerCase() });
             }
         });
     }
-    if (resetConfig?.adminUser?.email && isMultiTenant) {
+    if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000010_data-admin-authorizations',
+            name: '00000000000012_data-admin-authorizations',
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const authService = new AuthService(database);
-                const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
-                if (!metaOrg) {
+                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);
+                const email = dbConfig.adminUser.email.toLowerCase();
+                const adminUser = await db.collection('users').findOne({ email });
                 if (!adminUser) {
                     throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
                 }
-                const roleId = randomUUID().toString();
-                await db.collection('roles').insertOne({
-                    _id: roleId,
-                    _orgId: metaOrg._id,
+                const orgDoc = isMultiTenant && metaOrg ? { _orgId: metaOrg._id } : {};
+                const roleResult = await db.collection('roles').insertOne({
+                    ...orgDoc,
                     name: 'admin'
                 });
-                const userRoleId = randomUUID().toString();
                 await db.collection('user_roles').insertOne({
-                    _id: userRoleId,
-                    _orgId: metaOrg._id,
+                    ...orgDoc,
                     userId: adminUser._id,
-                    roleId: roleId,
+                    roleId: roleResult.insertedId,
                     _created: new Date(),
                     _createdBy: 'system',
                     _updated: new Date(),
@@ -244,18 +268,14 @@ export const getMongoInitialSchema = (config, resetConfig) => {
                     _deleted: undefined,
                     _deletedBy: undefined
                 });
-                const featureId = randomUUID().toString();
-                await db.collection('features').insertOne({
-                    _id: featureId,
-                    _orgId: metaOrg._id,
+                const featureResult = await db.collection('features').insertOne({
+                    ...orgDoc,
                     name: 'admin'
                 });
-                const authorizationId = randomUUID().toString();
                 await db.collection('authorizations').insertOne({
-                    _id: authorizationId,
-                    _orgId: metaOrg._id,
-                    roleId: roleId,
-                    featureId: featureId,
+                    ...orgDoc,
+                    roleId: roleResult.insertedId,
+                    featureId: featureResult.insertedId,
                     startDate: undefined,
                     endDate: undefined,
                     config: undefined,
@@ -270,26 +290,27 @@ export const getMongoInitialSchema = (config, resetConfig) => {
             down: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
-                if (!metaOrg)
+                const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
+                if (isMultiTenant && !metaOrg)
                     return;
-                const adminRole = await db.collection('roles').findOne({ _orgId: metaOrg._id, name: 'admin' });
-                const adminFeature = await db.collection('features').findOne({ _orgId: metaOrg._id, name: 'admin' });
+                const orgFilter = isMultiTenant && metaOrg ? { _orgId: metaOrg._id } : {};
+                const adminRole = await db.collection('roles').findOne({ ...orgFilter, name: 'admin' });
+                const adminFeature = await db.collection('features').findOne({ ...orgFilter, name: 'admin' });
                 if (adminRole && adminFeature) {
                     await db.collection('authorizations').deleteMany({
-                        _orgId: metaOrg._id,
+                        ...orgFilter,
                         roleId: adminRole._id,
                         featureId: adminFeature._id
                     });
                 }
-                await db.collection('features').deleteMany({ _orgId: metaOrg._id, name: 'admin' });
+                await db.collection('features').deleteMany({ ...orgFilter, name: 'admin' });
                 if (adminRole) {
                     await db.collection('user_roles').deleteMany({
-                        _orgId: metaOrg._id,
+                        ...orgFilter,
                         roleId: adminRole._id
                     });
                 }
-                await db.collection('roles').deleteMany({ _orgId: metaOrg._id, name: 'admin' });
+                await db.collection('roles').deleteMany({ ...orgFilter, name: 'admin' });
             }
         });
     }

package/dist/databases/mongo-db/utils/build-mongo-url.util.d.ts

@@ -1,2 +1,4 @@
-import { IBaseApiConfig } from "../../../models/base-api-config.interface.js";
-export declare function buildMongoUrl(config: IBaseApiConfig): string;
+import { IDatabaseConfig } from "../../../models/database-config.interface.js";
+export declare function buildMongoUrl(config: {
+    database: IDatabaseConfig;
+}): string;