@loomcore/api 0.1.21 → 0.1.24

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

@@ -1,16 +1,14 @@
 import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
-import { getSystemUserContext } from '@loomcore/common/models';
 import { Type } from '@sinclair/typebox';
 import { JwtService } from '../services/jwt.service.js';
 import { ApiController } from '../controllers/api.controller.js';
 import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
 import { Join } from '../databases/operations/join.operation.js';
 import { OrganizationService } from '../services/organization.service.js';
-import { IdNotFoundError } from '../errors/index.js';
 import { AuthService, GenericApiService } from '../services/index.js';
 import { ObjectId } from 'mongodb';
-import { testMetaOrg, testOrg, getTestMetaOrgUser, testMetaOrgUserContext } from './test-objects.js';
+import { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext } from './test-objects.js';
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
 let deviceIdCookie;
@@ -33,9 +31,9 @@ async function createMetaOrg() {
         throw new Error('OrganizationService not initialized. Call initialize() first.');
     }
     try {
-        const existingMetaOrg = await organizationService.findOne(testMetaOrgUserContext, { filters: { isMetaOrg: { eq: true } } });
+        const existingMetaOrg = await organizationService.getMetaOrg(getTestMetaOrgUserContext());
         if (!existingMetaOrg) {
-            const metaOrgInsertResult = await organizationService.create(testMetaOrgUserContext, testMetaOrg);
+            const metaOrgInsertResult = await organizationService.create(getTestMetaOrgUserContext(), getTestMetaOrg());
         }
     }
     catch (error) {
@@ -48,7 +46,7 @@ async function deleteMetaOrg() {
         return Promise.resolve();
     }
     try {
-        await organizationService.deleteMany(testMetaOrgUserContext, { filters: { isMetaOrg: { eq: true } } });
+        await organizationService.deleteMany(getTestMetaOrgUserContext(), { filters: { isMetaOrg: { eq: true } } });
     }
     catch (error) {
         console.log('Error deleting meta org:', error);
@@ -69,23 +67,15 @@ async function createTestUser() {
         throw new Error('Database not initialized. Call initialize() first.');
     }
     try {
-        let existingMetaOrg;
-        try {
-            existingMetaOrg = await organizationService.getMetaOrg(testMetaOrgUserContext);
-        }
-        catch (error) {
-            if (error instanceof IdNotFoundError) {
-                existingMetaOrg = null;
-            }
-            else {
-                throw error;
-            }
-        }
+        const existingMetaOrg = await organizationService.getMetaOrg(getTestMetaOrgUserContext());
         if (!existingMetaOrg) {
-            await organizationService.create(testMetaOrgUserContext, testMetaOrg);
+            await organizationService.create(getTestMetaOrgUserContext(), getTestMetaOrg());
+        }
+        const existingTestOrg = await organizationService.findOne(getTestMetaOrgUserContext(), { filters: { _id: { eq: getTestOrg()._id } } });
+        if (!existingTestOrg) {
+            await organizationService.create(getTestMetaOrgUserContext(), getTestOrg());
         }
-        const systemUserContext = getSystemUserContext();
-        const createdUser = await authService.createUser(systemUserContext, getTestMetaOrgUser());
+        const createdUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
         if (!createdUser) {
             throw new Error('Failed to create test user');
         }
@@ -97,10 +87,10 @@ async function createTestUser() {
     }
 }
 async function deleteTestUser() {
-    await authService.deleteById(testMetaOrgUserContext, getTestMetaOrgUser()._id).catch((error) => {
+    await authService.deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id).catch((error) => {
         return null;
     });
-    await organizationService.deleteById(testMetaOrgUserContext, testOrg._id).catch((error) => {
+    await organizationService.deleteById(getTestMetaOrgUserContext(), getTestOrg()._id).catch((error) => {
         return null;
     });
 }

package/dist/__tests__/models/test-item.model.d.ts

@@ -7,6 +7,6 @@ export interface ITestItem extends IEntity, IAuditable {
 export declare const TestItemSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
     value: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    eventDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>, import("@sinclair/typebox").TUndefined]>>;
+    eventDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>>;
 }>;
 export declare const TestItemSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.js

@@ -17,7 +17,6 @@ export class CreateTestUsersTableMigration {
                     "firstName" VARCHAR(255),
                     "lastName" VARCHAR(255),
                     "displayName" VARCHAR(255),
-                    "roles" TEXT[],
                     "_lastLoggedIn" TIMESTAMP,
                     "_lastPasswordChange" TIMESTAMP,
                     "_created" TIMESTAMP NOT NULL,

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

@@ -6,6 +6,7 @@ import { setupDatabaseForMultitenant } from '../databases/postgres/migrations/se
 import { setupDatabaseForAuth } from '../databases/postgres/migrations/setup-for-auth.migration.js';
 import { runTestMigrations } from './postgres-test-migrations/run-test-migrations.js';
 import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
+import { getTestMetaOrg, setTestMetaOrgId } from './test-objects.js';
 import { getSystemUserContext } from '@loomcore/common/models';
 export class TestPostgresDatabase {
     database = null;
@@ -29,10 +30,13 @@ export class TestPostgresDatabase {
             const testDatabase = new PostgresDatabase(postgresClient);
             this.database = testDatabase;
             this.postgresClient = postgresClient;
-            let success = (await setupDatabaseForMultitenant(postgresClient, 'Test Org', 'test-org')).success;
-            if (!success) {
+            const metaOrg = getTestMetaOrg();
+            const multitenantResult = await setupDatabaseForMultitenant(postgresClient, metaOrg.name, metaOrg.code);
+            let success = multitenantResult.success;
+            if (!success || !multitenantResult.metaOrgId) {
                 throw new Error('Failed to setup for multitenant');
             }
+            setTestMetaOrgId(multitenantResult.metaOrgId);
             await initSystemUserContext(this.database);
             success = (await setupDatabaseForAuth(postgresClient, adminUsername || 'admin', adminPassword || 'password')).success;
             if (!success) {

package/dist/__tests__/test-objects.d.ts

@@ -1,41 +1,9 @@
-import { IOrganization, IUserContext } from "@loomcore/common/models";
-export declare const testMetaOrg: IOrganization;
-export declare function getTestMetaOrgUser(): {
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    displayName?: string;
-    password: string;
-    roles?: string[];
-    _lastLoggedIn?: Date;
-    _lastPasswordChange?: Date;
-    _created: Date;
-    _createdBy: string;
-    _updated: Date;
-    _updatedBy: string;
-    _deleted?: Date;
-    _deletedBy?: string;
-    _id: string;
-    _orgId?: string;
-};
-export declare const testMetaOrgUserContext: IUserContext;
-export declare const testOrg: IOrganization;
-export declare function getTestOrgUser(): {
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    displayName?: string;
-    password: string;
-    roles?: string[];
-    _lastLoggedIn?: Date;
-    _lastPasswordChange?: Date;
-    _created: Date;
-    _createdBy: string;
-    _updated: Date;
-    _updatedBy: string;
-    _deleted?: Date;
-    _deletedBy?: string;
-    _id: string;
-    _orgId?: string;
-};
-export declare const testOrgUserContext: IUserContext;
+import { IOrganization, IUser, IUserContext } from "@loomcore/common/models";
+export declare let TEST_META_ORG_ID: string;
+export declare function setTestMetaOrgId(metaOrgId: string): void;
+export declare function getTestMetaOrg(): IOrganization;
+export declare function getTestMetaOrgUser(): IUser;
+export declare function getTestMetaOrgUserContext(): IUserContext;
+export declare function getTestOrg(): IOrganization;
+export declare function getTestOrgUser(): IUser;
+export declare function getTestOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -1,67 +1,100 @@
-export const testMetaOrg = {
-    _id: '69261691f936c45f85da24d0',
-    name: 'Test Meta Organization',
-    code: 'test-meta-org',
-    status: 1,
-    isMetaOrg: true,
-    _created: new Date(),
-    _createdBy: 'system',
-    _updated: new Date(),
-    _updatedBy: 'system',
-};
-const testMetaOrgUser = {
-    _id: '69261672f48fb7bf76e54dfb',
-    email: 'test@example.com',
-    password: 'testpassword',
-    firstName: 'Test',
-    lastName: 'User',
-    displayName: 'Test User',
-    roles: ['user'],
-    _orgId: testMetaOrg._id,
-    _created: new Date(),
-    _createdBy: 'system',
-    _lastLoggedIn: new Date(),
-    _lastPasswordChange: new Date(),
-    _updated: new Date(),
-    _updatedBy: 'system',
-};
+export let TEST_META_ORG_ID = '69261691f936c45f85da24d0';
+export function setTestMetaOrgId(metaOrgId) {
+    TEST_META_ORG_ID = metaOrgId;
+}
+export function getTestMetaOrg() {
+    return {
+        _id: TEST_META_ORG_ID,
+        name: 'Test Meta Organization',
+        code: 'test-meta-org',
+        status: 1,
+        isMetaOrg: true,
+        _created: new Date(),
+        _createdBy: 'system',
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
+;
 export function getTestMetaOrgUser() {
-    return { ...testMetaOrgUser };
+    return {
+        _id: '69261672f48fb7bf76e54dfb',
+        _orgId: getTestMetaOrg()._id,
+        email: 'test@example.com',
+        password: 'testpassword',
+        firstName: 'Test',
+        lastName: 'User',
+        displayName: 'Test User',
+        authorizations: [{
+                _id: '6939c54e57a1c6576a40c590',
+                _orgId: getTestMetaOrg()._id,
+                feature: 'metaorgUser',
+                config: {},
+                _created: new Date(),
+                _createdBy: 'system',
+                _updated: new Date(),
+                _updatedBy: 'system',
+            }],
+        _created: new Date(),
+        _createdBy: 'system',
+        _lastLoggedIn: new Date(),
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
+;
+export function getTestMetaOrgUserContext() {
+    return {
+        user: getTestMetaOrgUser(),
+        _orgId: getTestMetaOrg()._id,
+    };
 }
-export const testMetaOrgUserContext = {
-    user: getTestMetaOrgUser(),
-    _orgId: testMetaOrg._id,
-};
-export const testOrg = {
-    _id: '6926167d06c0073a778a124f',
-    name: 'Test Organization',
-    code: 'test-org',
-    status: 1,
-    isMetaOrg: false,
-    _created: new Date(),
-    _createdBy: 'system',
-    _updated: new Date(),
-    _updatedBy: 'system',
-};
-const testOrgUser = {
-    _id: '6926167d06c0073a778a1250',
-    email: 'test-org-user@example.com',
-    password: 'testpassword',
-    firstName: 'Test',
-    lastName: 'User',
-    displayName: 'Test User',
-    roles: ['user'],
-    _orgId: testOrg._id,
-    _created: new Date(),
-    _createdBy: 'system',
-    _lastLoggedIn: new Date(),
-    _updated: new Date(),
-    _updatedBy: 'system',
-};
+;
+export function getTestOrg() {
+    return {
+        _id: '6926167d06c0073a778a124f',
+        name: 'Test Organization',
+        code: 'test-org',
+        status: 1,
+        isMetaOrg: false,
+        _created: new Date(),
+        _createdBy: 'system',
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
+;
 export function getTestOrgUser() {
-    return { ...testOrgUser };
+    return {
+        _id: '6926167d06c0073a778a1250',
+        _orgId: getTestOrg()._id,
+        email: 'test-org-user@example.com',
+        password: 'testpassword',
+        firstName: 'Test',
+        lastName: 'User',
+        displayName: 'Test User',
+        authorizations: [{
+                _id: '6939c54e57a1c6576a40c591',
+                _orgId: getTestOrg()._id,
+                feature: 'testOrgUser',
+                config: {},
+                _created: new Date(),
+                _createdBy: 'system',
+                _updated: new Date(),
+                _updatedBy: 'system',
+            }],
+        _created: new Date(),
+        _createdBy: 'system',
+        _lastLoggedIn: new Date(),
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
+;
+export function getTestOrgUserContext() {
+    return {
+        user: getTestOrgUser(),
+        _orgId: getTestOrg()._id,
+    };
 }
-export const testOrgUserContext = {
-    user: getTestOrgUser(),
-    _orgId: testOrg._id,
-};
+;

package/dist/controllers/auth.controller.js

@@ -1,4 +1,4 @@
-import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec, passwordValidator, } from '@loomcore/common/models';
+import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, passwordValidator, PublicUserContextSpec, } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 import { isAuthenticated } from '../middleware/index.js';
@@ -38,13 +38,12 @@ export class AuthController {
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
     }
     async requestTokenUsingRefreshToken(req, res, next) {
-        const userContext = req.userContext;
         const refreshToken = req.query.refreshToken;
-        if (!userContext || !refreshToken || typeof refreshToken !== 'string') {
-            throw new BadRequestError('Missing required fields: userContext and refreshToken are required.');
+        if (!refreshToken || typeof refreshToken !== 'string') {
+            throw new BadRequestError('Missing required fields: refreshToken is required.');
         }
         const deviceId = this.authService.getDeviceIdFromCookie(req);
-        const tokens = await this.authService.requestTokenUsingRefreshToken(userContext, refreshToken, deviceId);
+        const tokens = await this.authService.requestTokenUsingRefreshToken(refreshToken, deviceId);
         if (tokens) {
             apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
         }
@@ -54,7 +53,7 @@ export class AuthController {
     }
     async getUserContext(req, res, next) {
         const userContext = req.userContext;
-        apiUtils.apiResponse(res, 200, { data: userContext }, UserContextSpec);
+        apiUtils.apiResponse(res, 200, { data: userContext }, PublicUserContextSpec);
     }
     afterAuth(req, res, loginResponse) {
         console.log('in afterAuth');

package/dist/databases/postgres/migrations/001-create-migrations-table.migration.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'crypto';
+import { doesTableExist } from "../utils/does-table-exist.util.js";
 export class CreateMigrationTableMigration {
     client;
     constructor(client) {
@@ -8,42 +9,39 @@ export class CreateMigrationTableMigration {
     async execute() {
         const _id = randomUUID().toString();
         try {
-            await this.client.query(`
-                CREATE TABLE "migrations" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "index" INTEGER NOT NULL,
-                    "hasRun" BOOLEAN NOT NULL,
-                    "reverted" BOOLEAN NOT NULL
-                )
-            `);
-        }
-        catch (error) {
-            if (error.code !== '42P07' && !error.data?.error?.includes('already exists')) {
-                return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'migrations');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "migrations" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "index" INTEGER NOT NULL UNIQUE,
+                        "hasRun" BOOLEAN NOT NULL,
+                        "reverted" BOOLEAN NOT NULL
+                    )
+                `);
             }
-        }
-        try {
             const result = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
     async revert() {
         try {
-            const result = await this.client.query(`
+            await this.client.query(`
             DROP TABLE "migrations";
         `);
-            if (result.rowCount === 0) {
-                return { success: false, error: new Error(`Error dropping migrations table: No row returned`) };
-            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error reverting migration ${this.index} from migrations table: ${error.message}`) };

package/dist/databases/postgres/migrations/002-create-organizations-table.migration.d.ts

@@ -2,9 +2,7 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateOrganizationsTableMigration implements IMigration {
     private readonly client;
-    private readonly orgName;
-    private readonly orgCode;
-    constructor(client: Client, orgName: string, orgCode: string);
+    constructor(client: Client);
     index: number;
     execute(): Promise<{
         success: boolean;

package/dist/databases/postgres/migrations/002-create-organizations-table.migration.js

@@ -1,83 +1,76 @@
 import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
 export class CreateOrganizationsTableMigration {
     client;
-    orgName;
-    orgCode;
-    constructor(client, orgName, orgCode) {
+    constructor(client) {
         this.client = client;
-        this.orgName = orgName;
-        this.orgCode = orgCode;
     }
     index = 2;
     async execute() {
         const _id = randomUUID().toString();
         try {
-            await this.client.query(`
-            CREATE TABLE "organizations" (
-                "_id" VARCHAR(255) PRIMARY KEY,
-                "name" VARCHAR(255) NOT NULL,
-                "code" VARCHAR(255) NOT NULL,
-                "description" TEXT,
-                "status" INTEGER NOT NULL,
-                "isMetaOrg" BOOLEAN NOT NULL,
-                "authToken" TEXT,
-                "_created" TIMESTAMP NOT NULL,
-                "_createdBy" VARCHAR(255) NOT NULL,
-                "_updated" TIMESTAMP NOT NULL,
-                "_updatedBy" VARCHAR(255) NOT NULL,
-                "_deleted" TIMESTAMP,
-                "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                console.log(`Organization table already exists`);
-            }
-            else {
-                return { success: false, error: new Error(`Error creating organization table: ${error.message}`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'organizations');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "organizations" (
+                        "_id" VARCHAR(255) 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" TIMESTAMP NOT NULL,
+                        "_createdBy" VARCHAR(255) NOT NULL,
+                        "_updated" TIMESTAMP NOT NULL,
+                        "_updatedBy" VARCHAR(255) NOT NULL,
+                        "_deleted" TIMESTAMP,
+                        "_deletedBy" VARCHAR(255)
+                    )
+                `);
             }
-        }
-        try {
             const result = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
     async revert() {
         try {
-            const result = await this.client.query(`
-                DROP TABLE "organizations";
-            `);
-            if (result.rowCount === 0) {
-                return { success: false, error: new Error(`Error dropping organizations table: No row returned`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'organizations');
+            if (tableExists) {
+                await this.client.query(`
+                    DROP TABLE "organizations";
+                `);
             }
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping organizations table: ${error.message}`) };
-        }
-        try {
-            const result = await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
+            const updateResult = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
-            if (result.rowCount === 0) {
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return {
                     success: false, error: new Error(`Error updating migration record for index ${this.index}: Migration record not found.
                     Migration index: ${this.index}`)
                 };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record for index ${this.index}: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
 }