@loomcore/api 0.2.4 → 0.2.5

package/dist/__tests__/common-test.utils.d.ts

@@ -1,19 +1,19 @@
-import { Request, Response, Application, NextFunction } from 'express';
-import { IUserContext, IQueryOptions, IUser } from '@loomcore/common/models';
-import { ApiController } from '../controllers/api.controller.js';
-import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
-import { Operation } from '../databases/operations/operation.js';
-import { GenericApiService } from '../services/index.js';
-import { IDatabase } from '../databases/models/index.js';
-import { ICategory } from './models/category.model.js';
-import { IProduct } from './models/product.model.js';
-import { IProductWithCategory } from './models/product-with-category.model.js';
-import { DbType } from '../databases/db-type.type.js';
+import { IQueryOptions, IUser, IUserContext } from "@loomcore/common/models";
+import { Application, NextFunction, Request, Response } from "express";
+import { ApiController } from "../controllers/api.controller.js";
+import { IDatabase } from "../databases/models/index.js";
+import { Operation } from "../databases/operations/operation.js";
+import { GenericApiService } from "../services/index.js";
+import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { DbType } from "../databases/db-type.type.js";
+import { ICategory } from "./models/category.model.js";
+import { IProduct } from "./models/product.model.js";
+import { IProductWithCategory } from "./models/product-with-category.model.js";
 declare function initialize(database: IDatabase): void;
 declare function getRandomId(): string;
 declare function isMongoDatabase(database: IDatabase): boolean;
 declare function isPostgresDatabase(database: IDatabase): boolean;
-declare function getExpectedIdType(database: IDatabase): 'string' | 'number';
+declare function getExpectedIdType(database: IDatabase): "string" | "number";
 declare function createMetaOrg(): Promise<void>;
 declare function deleteMetaOrg(): Promise<void>;
 declare function setupTestUsers(): Promise<{

package/dist/__tests__/common-test.utils.js

@@ -1,36 +1,36 @@
-import crypto from 'crypto';
-import jwt from 'jsonwebtoken';
-import { EmptyUserContext } from '@loomcore/common/models';
-import { Type } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
-import { JwtService } from '../services/jwt.service.js';
-import { ApiController } from '../controllers/api.controller.js';
-import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
-import { LeftJoin } from '../databases/operations/left-join.operation.js';
-import { OrganizationService } from '../services/organization.service.js';
-import { AuthService, GenericApiService } from '../services/index.js';
-import { ObjectId } from 'mongodb';
-import { MongoDBDatabase } from '../databases/mongo-db/mongo-db.database.js';
-import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
-import * as testObjectsModule from './test-objects.js';
-const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId } = testObjectsModule;
-import { CategorySpec } from './models/category.model.js';
-import { ProductSpec } from './models/product.model.js';
-import { ProductWithCategoryPublicSpec, ProductWithCategorySpec } from './models/product-with-category.model.js';
-import { setBaseApiConfig, config } from '../config/index.js';
-import { entityUtils } from '@loomcore/common/utils';
-import { getTestMetaOrgUserPerson, getTestOrgUser, getTestOrgUserPerson, setTestMetaOrgUserPersonId, setTestOrgUserPersonId } from './test-objects.js';
-import { TestEmailClient } from './test-email-client.js';
-import { PersonService } from '../services/person.service.js';
-import { apiUtils } from '../utils/index.js';
+import { EmptyUserContext, } from "@loomcore/common/models";
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import crypto from "crypto";
+import jwt from "jsonwebtoken";
+import { ObjectId } from "mongodb";
+import { ApiController } from "../controllers/api.controller.js";
+import { MongoDBDatabase } from "../databases/mongo-db/mongo-db.database.js";
+import { LeftJoin } from "../databases/operations/left-join.operation.js";
+import { PostgresDatabase } from "../databases/postgres/postgres.database.js";
+import { AuthService, GenericApiService } from "../services/index.js";
+import { JwtService } from "../services/jwt.service.js";
+import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { OrganizationService } from "../services/organization.service.js";
+import * as testObjectsModule from "./test-objects.js";
+const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, } = testObjectsModule;
+import { entityUtils } from "@loomcore/common/utils";
+import { config, setBaseApiConfig } from "../config/index.js";
+import { PersonService } from "../services/person.service.js";
+import { apiUtils } from "../utils/index.js";
+import { CategorySpec } from "./models/category.model.js";
+import { ProductSpec } from "./models/product.model.js";
+import { ProductWithCategoryPublicSpec, ProductWithCategorySpec, } from "./models/product-with-category.model.js";
+import { TestEmailClient } from "./test-email-client.js";
+import { getTestMetaOrgUserPerson, getTestOrgUser, getTestOrgUserPerson, setTestMetaOrgUserPersonId, setTestOrgUserPersonId, } from "./test-objects.js";
 let deviceIdCookie;
 let authService;
 let organizationService;
 let personService;
-const JWT_SECRET = 'test-secret';
-const newUser1Email = 'one@test.com';
-const newUser1Password = 'testone';
-const constDeviceIdCookie = crypto.randomBytes(16).toString('hex');
+const JWT_SECRET = "test-secret";
+const newUser1Email = "one@test.com";
+const newUser1Password = "testone";
+const constDeviceIdCookie = crypto.randomBytes(16).toString("hex");
 function initialize(database) {
     authService = new AuthService(database);
     personService = new PersonService(database);
@@ -47,14 +47,14 @@ function isPostgresDatabase(database) {
     return database instanceof PostgresDatabase;
 }
 function getExpectedIdType(database) {
-    return isPostgresDatabase(database) ? 'number' : 'string';
+    return isPostgresDatabase(database) ? "number" : "string";
 }
 async function createMetaOrg() {
     if (!config.app.isMultiTenant) {
         return;
     }
     if (!organizationService) {
-        throw new Error('OrganizationService not initialized. Call initialize() first.');
+        throw new Error("OrganizationService not initialized. Call initialize() first.");
     }
     try {
         const existingMetaOrg = await organizationService.getMetaOrg(EmptyUserContext);
@@ -69,7 +69,7 @@ async function createMetaOrg() {
         }
     }
     catch (error) {
-        console.log('Error in createMetaOrg:', error);
+        console.log("Error in createMetaOrg:", error);
         throw error;
     }
 }
@@ -78,10 +78,12 @@ async function deleteMetaOrg() {
         return Promise.resolve();
     }
     try {
-        await organizationService.deleteMany(getTestMetaOrgUserContext(), { filters: { isMetaOrg: { eq: true } } });
+        await organizationService.deleteMany(getTestMetaOrgUserContext(), {
+            filters: { isMetaOrg: { eq: true } },
+        });
     }
     catch (error) {
-        console.log('Error deleting meta org:', error);
+        console.log("Error deleting meta org:", error);
     }
 }
 async function setupTestUsers() {
@@ -97,19 +99,19 @@ async function setupTestUsers() {
 }
 async function createTestUsers() {
     if (!authService || !organizationService || !personService) {
-        throw new Error('Database not initialized. Call initialize() first.');
+        throw new Error("Database not initialized. Call initialize() first.");
     }
     try {
         const existingMetaOrg = await organizationService.getMetaOrg(EmptyUserContext);
         if (!existingMetaOrg) {
-            throw new Error('Meta organization does not exist. Test setup is incorrect - meta org should be created by migrations or createMetaOrg().');
+            throw new Error("Meta organization does not exist. Test setup is incorrect - meta org should be created by migrations or createMetaOrg().");
         }
         setTestMetaOrgId(existingMetaOrg._id);
         const existingTestOrg = await organizationService.findOne(getTestMetaOrgUserContext(), { filters: { _id: { eq: getTestOrg()._id } } });
         if (!existingTestOrg) {
             const createdTestOrg = await organizationService.create(getTestMetaOrgUserContext(), getTestOrg());
             if (!createdTestOrg) {
-                throw new Error('Failed to create test organization');
+                throw new Error("Failed to create test organization");
             }
             setTestOrgId(createdTestOrg._id);
         }
@@ -118,25 +120,25 @@ async function createTestUsers() {
         }
         const createdTestOrgUserPerson = await personService.create(getTestOrgUserContext(), getTestOrgUserPerson());
         if (!createdTestOrgUserPerson) {
-            throw new Error('Failed to create test organization user person');
+            throw new Error("Failed to create test organization user person");
         }
         setTestOrgUserPersonId(createdTestOrgUserPerson._id);
         const createdMetaOrgUserPerson = await personService.create(getTestMetaOrgUserContext(), getTestMetaOrgUserPerson());
         if (!createdMetaOrgUserPerson) {
-            throw new Error('Failed to create meta organization user person');
+            throw new Error("Failed to create meta organization user person");
         }
         setTestMetaOrgUserPersonId(createdMetaOrgUserPerson._id);
         const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser());
         const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
         if (!createdTestOrgUser || !createdMetaOrgUser) {
-            throw new Error('Failed to create test user');
+            throw new Error("Failed to create test user");
         }
         setTestMetaOrgUserId(createdMetaOrgUser._id);
         setTestOrgUserId(createdTestOrgUser._id);
         return { metaOrgUser: createdMetaOrgUser, testOrgUser: createdTestOrgUser };
     }
     catch (error) {
-        console.log('Error in createTestUser:', error);
+        console.log("Error in createTestUser:", error);
         throw error;
     }
 }
@@ -144,34 +146,38 @@ async function deleteTestUser() {
     if (!authService || !organizationService) {
         return;
     }
-    await authService.deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id).catch((error) => {
+    await authService
+        .deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id)
+        .catch((error) => {
         return null;
     });
-    await organizationService.deleteById(getTestMetaOrgUserContext(), getTestOrg()._id).catch((error) => {
+    await organizationService
+        .deleteById(getTestMetaOrgUserContext(), getTestOrg()._id)
+        .catch((error) => {
         return null;
     });
 }
 async function simulateloginWithTestUser() {
     const req = {
-        cookies: {}
+        cookies: {},
     };
     if (deviceIdCookie) {
-        req.cookies['deviceId'] = deviceIdCookie;
+        req.cookies["deviceId"] = deviceIdCookie;
     }
     const res = {
         cookie: function (name, value) {
-            if (name === 'deviceId') {
+            if (name === "deviceId") {
                 deviceIdCookie = value;
             }
             return res;
-        }
+        },
     };
     if (!authService) {
-        throw new Error('AuthService not initialized. Call initialize() first.');
+        throw new Error("AuthService not initialized. Call initialize() first.");
     }
     const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD);
     if (!loginResponse?.tokens?.accessToken) {
-        throw new Error('Failed to login with test user');
+        throw new Error("Failed to login with test user");
     }
     return `Bearer ${loginResponse.tokens.accessToken}`;
 }
@@ -185,13 +191,13 @@ function verifyToken(token) {
 }
 export class CategoryService extends GenericApiService {
     constructor(database) {
-        super(database, 'categories', 'category', CategorySpec);
+        super(database, "categories", "category", CategorySpec);
     }
 }
 export class CategoryController extends ApiController {
     constructor(app, database) {
         const categoryService = new CategoryService(database);
-        super('categories', app, categoryService, 'category', CategorySpec);
+        super("categories", app, categoryService, "category", CategorySpec);
     }
 }
 export function setupTestConfig(isMultiTenant = true, dbType) {
@@ -199,37 +205,37 @@ export function setupTestConfig(isMultiTenant = true, dbType) {
         app: {
             isMultiTenant: isMultiTenant,
             isAuthEnabled: true,
-            name: 'test-app',
+            name: "test-app",
             dbType: dbType,
         },
         auth: {
-            clientSecret: 'test-secret',
+            clientSecret: "test-secret",
             saltWorkFactor: 10,
             jwtExpirationInSeconds: 3600,
             refreshTokenExpirationInDays: 7,
             deviceIdCookieMaxAgeInDays: 730,
-            passwordResetTokenExpirationInMinutes: 20
+            passwordResetTokenExpirationInMinutes: 20,
         },
         database: {
-            name: 'test-db',
-            host: 'localhost',
-            password: 'test-password',
+            name: "test-db",
+            host: "localhost",
+            password: "test-password",
             port: 27017,
-            username: 'test-user'
+            username: "test-user",
         },
-        env: 'test',
+        env: "test",
         email: {
-            fromAddress: 'test@test.com',
-            systemEmailAddress: 'system@test.com'
+            fromAddress: "test@test.com",
+            systemEmailAddress: "system@test.com",
         },
         thirdPartyClients: {
-            emailClient: new TestEmailClient()
+            emailClient: new TestEmailClient(),
         },
         network: {
-            hostName: 'localhost',
+            hostName: "localhost",
             internalPort: 8083,
             externalPort: 4000,
-            corsAllowedOrigins: ['*']
+            corsAllowedOrigins: ["*"],
         },
     });
 }
@@ -238,54 +244,54 @@ const prepareQueryCustom = (userContext, queryObject, operations) => {
         queryObject: queryObject,
         operations: [
             ...operations,
-            new LeftJoin('categories', 'category_id', '_id', 'category')
-        ]
+            new LeftJoin("categories", "category_id", "_id", "category"),
+        ],
     };
 };
 const postProcessEntityCustom = (userContext, entity) => {
     return {
         ...entity,
-        category: entity._joinData?.category
+        category: entity._joinData?.category,
     };
 };
 export class ProductService extends GenericApiService {
     constructor(database) {
-        super(database, 'products', 'product', ProductSpec);
+        super(database, "products", "product", ProductSpec);
     }
 }
 export class ProductsController extends ApiController {
     constructor(app, database) {
         const productService = new ProductService(database);
-        super('products', app, productService, 'product', ProductSpec);
+        super("products", app, productService, "product", ProductSpec);
     }
     async get(req, res, next) {
-        res.set('Content-Type', 'application/json');
+        res.set("Content-Type", "application/json");
         const userContext = req.userContext;
         if (!userContext) {
-            throw new Error('User context not found');
+            throw new Error("User context not found");
         }
         const queryOptions = apiUtils.getQueryOptionsFromRequest(req);
         const pagedResult = await this.service.get(userContext, queryOptions, prepareQueryCustom, postProcessEntityCustom);
         apiUtils.apiResponse(res, 200, { data: pagedResult }, ProductWithCategorySpec, ProductWithCategoryPublicSpec);
     }
     async getAll(req, res, next) {
-        res.set('Content-Type', 'application/json');
+        res.set("Content-Type", "application/json");
         const userContext = req.userContext;
         if (!userContext) {
-            throw new Error('User context not found');
+            throw new Error("User context not found");
         }
         const entities = await this.service.getAll(userContext, prepareQueryCustom, postProcessEntityCustom);
         apiUtils.apiResponse(res, 200, { data: entities }, ProductWithCategorySpec, ProductWithCategoryPublicSpec);
     }
     async getById(req, res, next) {
-        res.set('Content-Type', 'application/json');
+        res.set("Content-Type", "application/json");
         const userContext = req.userContext;
         if (!userContext) {
-            throw new Error('User context not found');
+            throw new Error("User context not found");
         }
         const idParam = req.params?.id;
         if (!idParam) {
-            throw new Error('ID parameter is required');
+            throw new Error("ID parameter is required");
         }
         try {
             const id = Value.Convert(this.idSchema, idParam);
@@ -300,13 +306,13 @@ export class ProductsController extends ApiController {
 export class MultiTenantProductService extends MultiTenantApiService {
     db;
     constructor(database) {
-        super(database, 'products', 'product', ProductSpec);
+        super(database, "products", "product", ProductSpec);
         this.db = database;
     }
     prepareQuery(userContext, queryObject, operations) {
         const newOperations = [
             ...operations,
-            new LeftJoin('categories', 'categoryId', '_id', 'category')
+            new LeftJoin("categories", "categoryId", "_id", "category"),
         ];
         return super.prepareQuery(userContext, queryObject, newOperations);
     }
@@ -324,12 +330,14 @@ export class MultiTenantProductsController extends ApiController {
         const AggregatedProductSchema = Type.Intersect([
             ProductSpec.fullSchema,
             Type.Partial(Type.Object({
-                category: CategorySpec.fullSchema
-            }))
+                category: CategorySpec.fullSchema,
+            })),
+        ]);
+        const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, [
+            "internalNumber",
         ]);
-        const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, ['internalNumber']);
         const PublicAggregatedProductSpec = entityUtils.getModelSpec(PublicAggregatedProductSchema);
-        super('multi-tenant-products', app, productService, 'product', ProductSpec, PublicAggregatedProductSpec);
+        super("multi-tenant-products", app, productService, "product", ProductSpec, PublicAggregatedProductSpec);
     }
 }
 function configureJwtSecret() {
@@ -339,17 +347,15 @@ function configureJwtSecret() {
     };
 }
 async function loginWithTestUser(agent) {
-    agent.set('Cookie', [`deviceId=${deviceIdCookie}`]);
+    agent.set("Cookie", [`deviceId=${deviceIdCookie}`]);
     const testUser = getTestMetaOrgUser();
-    const response = await agent
-        .post('/api/auth/login')
-        .send({
+    const response = await agent.post("/api/auth/login").send({
         email: testUser.email,
         password: testUser.password,
     });
     if (!response.body?.data?.tokens?.accessToken) {
-        console.error('Login failed:', response.body);
-        throw new Error('Failed to login with test user');
+        console.error("Login failed:", response.body);
+        throw new Error("Failed to login with test user");
     }
     const authorizationHeaderValue = `Bearer ${response.body?.data?.tokens?.accessToken}`;
     return authorizationHeaderValue;
@@ -360,7 +366,7 @@ async function cleanup() {
         await deleteMetaOrg();
     }
     catch (error) {
-        console.log('Error during cleanup:', error);
+        console.log("Error during cleanup:", error);
     }
 }
 const testUtils = {
@@ -382,6 +388,6 @@ const testUtils = {
     verifyToken,
     isMongoDatabase,
     isPostgresDatabase,
-    getExpectedIdType
+    getExpectedIdType,
 };
 export default testUtils;

package/dist/__tests__/postgres.test-database.d.ts

@@ -1,5 +1,5 @@
-import { ITestDatabase } from './test-database.interface.js';
-import { IDatabase } from '../databases/models/index.js';
+import type { IDatabase } from "../databases/models/index.js";
+import type { ITestDatabase } from "./test-database.interface.js";
 export declare class TestPostgresDatabase implements ITestDatabase {
     private database;
     private postgresClient;

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

@@ -1,10 +1,10 @@
-import testUtils from './common-test.utils.js';
+import { Pool } from "pg";
 import { newDb } from "pg-mem";
-import { Pool } from 'pg';
-import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
-import { config } from '../config/base-api-config.js';
-import { runInitialSchemaMigrations, runTestSchemaMigrations } from '../databases/postgres/migrations/__tests__/test-migration-helper.js';
-const USE_REAL_POSTGRES = process.env.USE_REAL_POSTGRES === 'true';
+import { config } from "../config/base-api-config.js";
+import { runInitialSchemaMigrations, runTestSchemaMigrations, } from "../databases/postgres/migrations/__tests__/test-migration-helper.js";
+import { PostgresDatabase } from "../databases/postgres/postgres.database.js";
+import testUtils from "./common-test.utils.js";
+const USE_REAL_POSTGRES = process.env.USE_REAL_POSTGRES === "true";
 export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
@@ -18,7 +18,7 @@ export class TestPostgresDatabase {
         return this.initPromise;
     }
     getRandomId() {
-        throw new Error('getRandomId() should not be used for PostgreSQL _id fields. PostgreSQL uses auto-generated integer IDs. Remove _id from entities and let the database generate it.');
+        throw new Error("getRandomId() should not be used for PostgreSQL _id fields. PostgreSQL uses auto-generated integer IDs. Remove _id from entities and let the database generate it.");
     }
     async _performInit() {
         if (!this.database) {
@@ -32,13 +32,14 @@ export class TestPostgresDatabase {
                 });
                 this.migrationPool = pool;
                 try {
-                    await pool.query('SELECT now(), current_database()');
+                    await pool.query("SELECT now(), current_database()");
                 }
                 catch (error) {
                     await pool.end();
                     this.migrationPool = null;
                     const errorMessage = error.message || String(error);
-                    const isPermissionError = errorMessage.includes('permission denied') || errorMessage.includes('operation not permitted');
+                    const isPermissionError = errorMessage.includes("permission denied") ||
+                        errorMessage.includes("operation not permitted");
                     if (isPermissionError) {
                         throw new Error(`Docker permission error. Please ensure:\n` +
                             `1. Docker Desktop is running\n` +
@@ -64,9 +65,9 @@ export class TestPostgresDatabase {
             }
             this.database = new PostgresDatabase(connection);
             this.postgresClient = connection;
-            const { initializeSystemUserContext, isSystemUserContextInitialized } = await import('@loomcore/common/models');
+            const { initializeSystemUserContext, isSystemUserContextInitialized } = await import("@loomcore/common/models");
             if (!isSystemUserContextInitialized()) {
-                initializeSystemUserContext(config.email?.systemEmailAddress || 'system@test.com', undefined);
+                initializeSystemUserContext(config.email?.systemEmailAddress || "system@test.com", undefined);
             }
             await runInitialSchemaMigrations(pool, config);
             await runTestSchemaMigrations(pool, config);
@@ -84,12 +85,12 @@ export class TestPostgresDatabase {
       `);
         }
         catch (error) {
-            console.log('Note: Indexes may be created later when tables are initialized:', error.message);
+            console.log("Note: Indexes may be created later when tables are initialized:", error.message);
         }
     }
     async clearCollections() {
         if (!this.postgresClient) {
-            throw new Error('Database not initialized');
+            throw new Error("Database not initialized");
         }
         const result = await this.postgresClient.query(`
       SELECT "table_name" 
@@ -98,7 +99,7 @@ export class TestPostgresDatabase {
       AND "table_type" = 'BASE TABLE'
     `);
         if (USE_REAL_POSTGRES) {
-            await this.postgresClient.query(`TRUNCATE TABLE ${result.rows.map(row => `"${row.table_name}"`).join(', ')} RESTART IDENTITY CASCADE`);
+            await this.postgresClient.query(`TRUNCATE TABLE ${result.rows.map((row) => `"${row.table_name}"`).join(", ")} RESTART IDENTITY CASCADE`);
         }
         else {
             result.rows.forEach(async (row) => {
@@ -120,7 +121,7 @@ export class TestPostgresDatabase {
                 }
             }
             catch (error) {
-                console.warn('Error closing PostgreSQL connection:', error);
+                console.warn("Error closing PostgreSQL connection:", error);
             }
         }
         this.migrationPool = null;

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';
+import { IDatabase } from "../databases/models/index.js";
+import { IBaseApiConfig } from "../models/index.js";
 export declare let config: IBaseApiConfig;
 export declare function setBaseApiConfig(theConfig: IBaseApiConfig): void;
 export declare function initSystemUserContext(database: IDatabase): Promise<void>;

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

@@ -1,9 +1,16 @@
-import { EmptyUserContext, initializeSystemUserContext } from '@loomcore/common/models';
+import { EmptyUserContext, initializeSystemUserContext, } from "@loomcore/common/models";
 export let config;
 let isConfigSet = false;
 let isSystemUserContextSet = false;
 const BASE_API_CONFIG_KEYS = [
-    'app', 'auth', 'database', 'debug', 'email', 'env', 'network', 'thirdPartyClients'
+    "app",
+    "auth",
+    "database",
+    "debug",
+    "email",
+    "env",
+    "network",
+    "thirdPartyClients",
 ];
 function copyOnlySpecifiedConfigProperties(obj, allowedKeys) {
     const result = {};
@@ -19,29 +26,29 @@ export function setBaseApiConfig(theConfig) {
         config = copyOnlySpecifiedConfigProperties(theConfig, BASE_API_CONFIG_KEYS);
         isConfigSet = true;
     }
-    else if (config.env !== 'test') {
-        console.warn('BaseApiConfig data has already been set. Ignoring subsequent calls to setBaseApiConfig.');
+    else if (config.env !== "test") {
+        console.warn("BaseApiConfig data has already been set. Ignoring subsequent calls to setBaseApiConfig.");
     }
 }
 export async function initSystemUserContext(database) {
     if (!isConfigSet) {
-        throw new Error('BaseApiConfig has not been set. Call setBaseApiConfig first.');
+        throw new Error("BaseApiConfig has not been set. Call setBaseApiConfig first.");
     }
     if (!isSystemUserContextSet) {
-        const systemEmail = config.email?.systemEmailAddress || 'system@example.com';
+        const systemEmail = config.email?.systemEmailAddress || "system@example.com";
         let metaOrg = undefined;
         if (config.app.isMultiTenant) {
-            const { OrganizationService } = await import('../services/organization.service.js');
+            const { OrganizationService } = await import("../services/organization.service.js");
             const organizationService = new OrganizationService(database);
             metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
             if (!metaOrg) {
-                throw new Error('Meta organization not found. Please create an organization with isMetaOrg=true before starting the API.');
+                throw new Error("Meta organization not found. Please create an organization with isMetaOrg=true before starting the API.");
             }
         }
         initializeSystemUserContext(systemEmail, metaOrg);
         isSystemUserContextSet = true;
     }
-    else if (config.env !== 'test') {
-        console.warn('SystemUserContext has already been set. Ignoring subsequent calls to initSystemUserContext.');
+    else if (config.env !== "test") {
+        console.warn("SystemUserContext has already been set. Ignoring subsequent calls to initSystemUserContext.");
     }
 }

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

@@ -1,5 +1,5 @@
-import { Db } from 'mongodb';
-import { IInitialDbMigrationConfig } from '../../../models/initial-database-config.interface.js';
+import { Db } from "mongodb";
+import { IInitialDbMigrationConfig } from "../../../models/initial-database-config.interface.js";
 export interface ISyntheticMigration {
     name: string;
     up: (context: {