@loomcore/api 0.1.6 → 0.1.8

package/dist/__tests__/postgres-test-migrations/001-create-test-entities-table.migration.d.ts

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "../../databases/postgres/migrations/migration.interface.js";
 export declare class CreateTestEntitiesTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

package/dist/__tests__/postgres-test-migrations/001-create-test-entities-table.migration.js

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateTestEntitiesTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 1;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "testEntities" (
@@ -27,33 +25,49 @@ export class CreateTestEntitiesTableMigration {
                     "_deletedBy" VARCHAR(255)
                 )
             `);
-            if (this.orgId) {
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating test entities table: ${error.message}`) };
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            else {
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        else {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
-        }
-        catch (error) {
-            console.error('Error creating test entities table:', error);
-            return false;
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE test_entities;
             `);
         }
         catch (error) {
-            console.error('Error reverting test entities table:', error);
-            return false;
+            return { success: false, error: new Error(`Error dropping test entities table: ${error.message}`) };
+        }
+        try {
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
+            `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
-        return true;
+        return { success: true, error: null };
     }
 }

package/dist/__tests__/postgres-test-migrations/002-create-categories-table.migration.d.ts

@@ -2,10 +2,20 @@ import { IMigration } from "../../databases/postgres/migrations/index.js";
 import { Client } from "pg";
 export declare class CreateCategoriesTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

package/dist/__tests__/postgres-test-migrations/002-create-categories-table.migration.js

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateCategoriesTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 2;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "categories" (
@@ -17,36 +15,49 @@ export class CreateCategoriesTableMigration {
                     "name" VARCHAR(255) NOT NULL
                 )
             `);
-            if (this.orgId) {
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating categories table: ${error.message}`) };
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            else {
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        else {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
-        }
-        catch (error) {
-            console.error('Error creating categories table:', error);
-            return false;
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "categories";
             `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error dropping categories table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {
-            console.error('Error reverting categories table:', error);
-            return false;
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
-        return true;
+        return { success: true, error: null };
     }
 }

package/dist/__tests__/postgres-test-migrations/003-create-products-table.migration.d.ts

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "../../databases/postgres/migrations/index.js";
 export declare class CreateProductsTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

package/dist/__tests__/postgres-test-migrations/003-create-products-table.migration.js

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateProductsTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 3;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "products" (
@@ -26,37 +24,49 @@ export class CreateProductsTableMigration {
                     "_deletedBy" VARCHAR(255)
                 )
             `);
-            if (this.orgId) {
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating products table: ${error.message}`) };
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            else {
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        else {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
-        }
-        catch (error) {
-            console.error('Error creating products table:', error);
-            return false;
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
-        return true;
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "products";
             `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error dropping products table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {
-            console.error('Error reverting products table:', error);
-            return false;
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
-        return true;
+        return { success: true, error: null };
     }
 }

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

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "../../databases/postgres/migrations/index.js";
 export declare class CreateTestUsersTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateTestUsersTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 4;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "testUsers" (
@@ -30,37 +28,49 @@ export class CreateTestUsersTableMigration {
                     "_deletedBy" VARCHAR(255)
                 )
             `);
-            if (this.orgId) {
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating test users table: ${error.message}`) };
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            else {
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        else {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
-        }
-        catch (error) {
-            console.error('Error creating test users table:', error);
-            return false;
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
-        return true;
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "testUsers";
             `);
         }
         catch (error) {
+            return { success: false, error: new Error(`Error dropping test users table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
-            console.error('Error reverting test users table:', error);
-            return false;
         }
-        return true;
+        catch (error) {
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
+        }
+        return { success: true, error: null };
     }
 }

package/dist/__tests__/postgres-test-migrations/005-create-test-items-table.migration.d.ts

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "../../databases/postgres/migrations/index.js";
 export declare class CreateTestItemsTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

package/dist/__tests__/postgres-test-migrations/005-create-test-items-table.migration.js

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateTestItemsTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 5;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "testItems" (
@@ -27,24 +25,47 @@ export class CreateTestItemsTableMigration {
             `);
         }
         catch (error) {
-            console.error('Error creating test items table:', error);
-            return false;
+            return { success: false, error: new Error(`Error creating test items table: ${error.message}`) };
         }
-        return true;
+        if (_orgId) {
+            try {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        else {
+            try {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
+        }
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "testItems";
             `);
         }
         catch (error) {
+            return { success: false, error: new Error(`Error dropping test items table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
-            console.error('Error reverting test items table:', error);
-            return false;
         }
-        return true;
+        catch (error) {
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
+        }
+        return { success: true, error: null };
     }
 }

package/dist/__tests__/postgres-test-migrations/run-test-migrations.d.ts

@@ -1,2 +1,5 @@
 import { Client } from "pg";
-export declare function runTestMigrations(client: Client, orgId?: string): Promise<boolean>;
+export declare function runTestMigrations(client: Client, _orgId?: string): Promise<{
+    success: boolean;
+    error: Error | null;
+}>;

package/dist/__tests__/postgres-test-migrations/run-test-migrations.js

@@ -3,20 +3,21 @@ import { CreateCategoriesTableMigration } from "./002-create-categories-table.mi
 import { CreateProductsTableMigration } from "./003-create-products-table.migration.js";
 import { CreateTestUsersTableMigration } from "./004-create-test-users-table.migration.js";
 import { CreateTestItemsTableMigration } from "./005-create-test-items-table.migration.js";
-export async function runTestMigrations(client, orgId) {
+export async function runTestMigrations(client, _orgId) {
     const migrations = [
-        new CreateTestEntitiesTableMigration(client, orgId),
-        new CreateCategoriesTableMigration(client, orgId),
-        new CreateProductsTableMigration(client, orgId),
-        new CreateTestUsersTableMigration(client, orgId),
-        new CreateTestItemsTableMigration(client, orgId),
+        new CreateTestEntitiesTableMigration(client),
+        new CreateCategoriesTableMigration(client),
+        new CreateProductsTableMigration(client),
+        new CreateTestUsersTableMigration(client),
+        new CreateTestItemsTableMigration(client),
     ];
-    let success = true;
-    for (const migration of migrations) {
-        success = await migration.execute();
-        if (!success) {
-            return false;
+    try {
+        for (const migration of migrations) {
+            await migration.execute(_orgId);
         }
     }
-    return success;
+    catch (error) {
+        return { success: false, error: error };
+    }
+    return { success: true, error: null };
 }

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

@@ -29,7 +29,7 @@ export class TestPostgresDatabase {
             const testDatabase = new PostgresDatabase(postgresClient);
             this.database = testDatabase;
             this.postgresClient = postgresClient;
-            let success = await setupDatabaseForMultitenant(postgresClient, testOrg._id);
+            let success = await setupDatabaseForMultitenant(postgresClient, 'Test Org', 'test-org');
             if (!success) {
                 throw new Error('Failed to setup for multitenant');
             }

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

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateMigrationTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: null;
+    } | {
+        success: boolean;
+        error: Error;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -1,15 +1,12 @@
 import { randomUUID } from 'crypto';
 export class CreateMigrationTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 1;
-    _id = randomUUID().toString();
-    async execute() {
-        let alreadyRun = false;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "migrations" (
@@ -22,31 +19,40 @@ export class CreateMigrationTableMigration {
             `);
         }
         catch (error) {
-            if (error.data.error.includes('already exists')) {
-                alreadyRun = true;
+            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
+                return { success: true, error: null };
             }
             else {
-                throw error;
+                return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
             }
         }
-        if (!alreadyRun) {
-            if (this.orgId) {
+        try {
+            if (_orgId) {
                 await this.client.query(`
-                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
-            `);
+                    INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);`);
             }
             else {
                 await this.client.query(`
-                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted") VALUES ('${this._id}', ${this.index}, TRUE, FALSE);
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             }
         }
-        return true;
+        catch (error) {
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+        }
+        return { success: true, error: null };
     }
-    async revert() {
-        await this.client.query(`
+    async revert(_orgId) {
+        try {
+            await this.client.query(`
             DROP TABLE "migrations";
         `);
-        return true;
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error reverting migration ${this.index} from migrations table: ${error.message}`) };
+        }
+        return { success: true, error: null };
     }
 }

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

@@ -2,10 +2,22 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateOrganizationTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId;
-    constructor(client: Client, orgId: string);
+    private readonly orgName;
+    private readonly orgCode;
+    constructor(client: Client, orgName: string, orgCode: string);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: null;
+    } | {
+        success: boolean;
+        error: Error;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -1,14 +1,17 @@
 import { randomUUID } from "crypto";
 export class CreateOrganizationTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    orgName;
+    orgCode;
+    constructor(client, orgName, orgCode) {
         this.client = client;
-        this.orgId = orgId;
+        this.orgName = orgName;
+        this.orgCode = orgCode;
     }
     index = 2;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        const _orgIdToUse = _orgId || randomUUID().toString();
         try {
             await this.client.query(`
             CREATE TABLE "organizations" (
@@ -27,29 +30,52 @@ export class CreateOrganizationTableMigration {
                 "_deletedBy" VARCHAR(255)
                 )
             `);
+        }
+        catch (error) {
+            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
+                return { success: true, error: null };
+            }
+            else {
+                return { success: false, error: new Error(`Error creating organization table: ${error.message}`) };
+            }
+        }
+        try {
+            await this.client.query(`
+                INSERT INTO "organizations" ("_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
+                VALUES ('${_orgIdToUse}', '${this.orgName}', '${this.orgCode}', 1, true, NOW(), 'system', NOW(), 'system');
+            `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                VALUES ('${_id}', '${_orgIdToUse}', ${this.index}, TRUE, FALSE);
             `);
-            return true;
         }
         catch (error) {
-            console.error('Error creating organization table:', error);
-            return false;
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
         }
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
             DROP TABLE "organizations";
         `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error dropping organizations table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                Update "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {
-            console.error('Error reverting organization table:', error);
-            return false;
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
-        return true;
+        return { success: true, error: null };
     }
 }

package/dist/databases/postgres/migrations/003-create-users-table.migration.d.ts

@@ -2,10 +2,20 @@ import { Client } from "pg";
 import { IMigration } from "./migration.interface.js";
 export declare class CreateUsersTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: null;
+    } | {
+        success: boolean;
+        error: Error;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -1,14 +1,12 @@
 import { randomUUID } from "crypto";
 export class CreateUsersTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 3;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
                 CREATE TABLE "users" (
@@ -30,36 +28,56 @@ export class CreateUsersTableMigration {
                     "_deletedBy" VARCHAR(255)
                 )
             `);
-            if (this.orgId) {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
-                `);
+        }
+        catch (error) {
+            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
+                return { success: true, error: null };
             }
             else {
+                return { success: false, error: new Error(`Error creating users table: ${error.message}`) };
+            }
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
-        catch (error) {
-            console.error('Error creating users table:', error);
-            return false;
+        else {
+            try {
+                await this.client.query(`
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
-        return true;
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "users";
             `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error dropping users table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
         }
         catch (error) {
-            console.error('Error reverting users table:', error);
-            return false;
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
-        return true;
+        return { success: true, error: null };
     }
 }

package/dist/databases/postgres/migrations/004-create-refresh-token-table.migration.d.ts

@@ -1,11 +1,21 @@
 import { Client } from "pg";
-import { IMigration } from "./index.js";
+import { IMigration } from "./migration.interface.js";
 export declare class CreateRefreshTokenTableMigration implements IMigration {
     private readonly client;
-    private readonly orgId?;
-    constructor(client: Client, orgId?: string | undefined);
+    constructor(client: Client);
     index: number;
-    _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: null;
+    } | {
+        success: boolean;
+        error: Error;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

package/dist/databases/postgres/migrations/004-create-refresh-token-table.migration.js

@@ -1,57 +1,75 @@
 import { randomUUID } from "crypto";
 export class CreateRefreshTokenTableMigration {
     client;
-    orgId;
-    constructor(client, orgId) {
+    constructor(client) {
         this.client = client;
-        this.orgId = orgId;
     }
     index = 4;
-    _id = randomUUID().toString();
-    async execute() {
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
         try {
             await this.client.query(`
-            CREATE TABLE "refreshTokens" (
-                "_id" VARCHAR(255) PRIMARY KEY,
-                "_orgId" VARCHAR(255),
-                "token" VARCHAR(255) NOT NULL,
-                "deviceId" VARCHAR(255) NOT NULL,
-                "userId" VARCHAR(255) NOT NULL,
-                "expiresOn" BIGINT NOT NULL,
-                "created" TIMESTAMP NOT NULL,
-                "createdBy" VARCHAR(255) NOT NULL
-            )
-        `);
-            if (this.orgId) {
-                await this.client.query(`
-                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
-                `);
+                CREATE TABLE "refreshTokens" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "token" VARCHAR(255) NOT NULL,
+                    "deviceId" VARCHAR(255) NOT NULL,
+                    "userId" VARCHAR(255) NOT NULL,
+                    "expiresOn" BIGINT NOT NULL,
+                    "created" TIMESTAMP NOT NULL,
+                    "createdBy" VARCHAR(255) NOT NULL
+                )
+            `);
+        }
+        catch (error) {
+            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
+                return { success: true, error: null };
             }
             else {
+                return { success: false, error: new Error(`Error creating refresh token table: ${error.message}`) };
+            }
+        }
+        if (_orgId) {
+            try {
                 await this.client.query(`
-                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                    INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
-        catch (error) {
-            console.error('Error creating refresh token table:', error);
-            return false;
+        else {
+            try {
+                await this.client.query(`
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            catch (error) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            }
         }
+        return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
-                DROP TABLE "refresh_tokens";
+                DROP TABLE "refreshTokens";
             `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error dropping refresh token table: ${error.message}`) };
+        }
+        try {
             await this.client.query(`
-                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
-            return true;
         }
         catch (error) {
-            console.error('Error reverting refresh token table:', error);
-            return false;
+            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
         }
+        return { success: true, error: null };
     }
 }

package/dist/databases/postgres/migrations/migration.interface.d.ts

@@ -1,6 +1,11 @@
-import { IEntity } from "@loomcore/common/models";
-export interface IMigration extends IEntity {
+export interface IMigration {
     index: number;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
 }

package/dist/databases/postgres/migrations/setup-for-auth.migration.d.ts

@@ -1,2 +1,5 @@
 import { Client } from "pg";
-export declare function setupDatabaseForAuth(client: Client, orgId?: string): Promise<boolean>;
+export declare function setupDatabaseForAuth(client: Client, _orgId?: string): Promise<{
+    success: boolean;
+    error: Error | null;
+}>;

package/dist/databases/postgres/migrations/setup-for-auth.migration.js

@@ -1,18 +1,19 @@
 import { CreateRefreshTokenTableMigration } from "./004-create-refresh-token-table.migration.js";
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
 import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
-export async function setupDatabaseForAuth(client, orgId) {
+export async function setupDatabaseForAuth(client, _orgId) {
     const migrations = [
-        new CreateMigrationTableMigration(client, orgId),
-        new CreateUsersTableMigration(client, orgId),
-        new CreateRefreshTokenTableMigration(client, orgId),
+        new CreateMigrationTableMigration(client),
+        new CreateUsersTableMigration(client),
+        new CreateRefreshTokenTableMigration(client),
     ];
-    let success = true;
-    for (const migration of migrations) {
-        success = await migration.execute();
-        if (!success) {
-            return false;
+    try {
+        for (const migration of migrations) {
+            await migration.execute(_orgId);
         }
     }
-    return success;
+    catch (error) {
+        return { success: false, error: error };
+    }
+    return { success: true, error: null };
 }

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.d.ts

@@ -1,2 +1,5 @@
 import { Client } from "pg";
-export declare function setupDatabaseForMultitenant(client: Client, orgId: string): Promise<boolean>;
+export declare function setupDatabaseForMultitenant(client: Client, orgName: string, orgCode: string): Promise<{
+    success: boolean;
+    error: Error | null;
+}>;

package/dist/databases/postgres/migrations/setup-for-multitenant.migration.js

@@ -1,16 +1,17 @@
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
 import { CreateOrganizationTableMigration } from "./002-create-organizations-table.migration.js";
-export async function setupDatabaseForMultitenant(client, orgId) {
+export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
     const migrations = [
-        new CreateMigrationTableMigration(client, orgId),
-        new CreateOrganizationTableMigration(client, orgId),
+        new CreateMigrationTableMigration(client),
+        new CreateOrganizationTableMigration(client, orgName, orgCode),
     ];
-    let success = true;
-    for (const migration of migrations) {
-        success = await migration.execute();
-        if (!success) {
-            return false;
+    try {
+        for (const migration of migrations) {
+            await migration.execute();
         }
     }
-    return success;
+    catch (error) {
+        return { success: false, error: error };
+    }
+    return { success: true, error: null };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {