@loomcore/api 0.1.5 → 0.1.7

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

@@ -6,6 +6,18 @@ export declare class CreateTestEntitiesTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -27,22 +27,31 @@ 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 (this.orgId) {
+            try {
                 await this.client.query(`
                     Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.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);
                 `);
             }
-            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() {
         try {
@@ -51,9 +60,16 @@ export class CreateTestEntitiesTableMigration {
             `);
         }
         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 "_id" = '${this._id}';
+            `);
+        }
+        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

@@ -6,6 +6,18 @@ export declare class CreateCategoriesTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -17,36 +17,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 (this.orgId) {
+            try {
                 await this.client.query(`
                     Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.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);
                 `);
             }
-            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() {
         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}';
             `);
         }
         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

@@ -6,6 +6,18 @@ export declare class CreateProductsTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -26,37 +26,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 (this.orgId) {
+            try {
                 await this.client.query(`
                     Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.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);
                 `);
             }
-            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() {
         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}';
             `);
         }
         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

@@ -6,6 +6,18 @@ export declare class CreateTestUsersTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -30,23 +30,31 @@ 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 (this.orgId) {
+            try {
                 await this.client.query(`
                     Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.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);
                 `);
             }
-            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() {
         try {
@@ -55,12 +63,16 @@ export class CreateTestUsersTableMigration {
             `);
         }
         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}';
             `);
-            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

@@ -6,6 +6,18 @@ export declare class CreateTestItemsTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -27,10 +27,29 @@ 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 (this.orgId) {
+            try {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.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 ('${this._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() {
         try {
@@ -39,12 +58,16 @@ export class CreateTestItemsTableMigration {
             `);
         }
         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}';
             `);
-            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

@@ -11,12 +11,13 @@ export async function runTestMigrations(client, orgId) {
         new CreateTestUsersTableMigration(client, orgId),
         new CreateTestItemsTableMigration(client, orgId),
     ];
-    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/dist/databases/index.d.ts

@@ -1,2 +1,4 @@
 export * from './mongo-db/index.js';
 export * from './postgres/index.js';
+export * from './models/index.js';
+export * from './operations/index.js';

package/dist/databases/index.js

@@ -1,2 +1,4 @@
 export * from './mongo-db/index.js';
 export * from './postgres/index.js';
+export * from './models/index.js';
+export * from './operations/index.js';

package/dist/databases/operations/index.d.ts

@@ -0,0 +1,2 @@
+export * from './operation.js';
+export * from './join.operation.js';

package/dist/databases/operations/index.js

@@ -0,0 +1,2 @@
+export * from './operation.js';
+export * from './join.operation.js';

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

@@ -6,6 +6,18 @@ export declare class CreateMigrationTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -26,27 +26,38 @@ export class CreateMigrationTableMigration {
                 alreadyRun = true;
             }
             else {
-                throw error;
+                return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
             }
         }
         if (!alreadyRun) {
-            if (this.orgId) {
-                await this.client.query(`
-                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+            try {
+                if (this.orgId) {
+                    await this.client.query(`
+                        INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                        VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);`);
+                }
+                else {
+                    await this.client.query(`
+                        INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                        VALUES ('${this._id}', ${this.index}, TRUE, FALSE);
             `);
+                }
             }
-            else {
-                await this.client.query(`
-                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted") VALUES ('${this._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() {
-        await this.client.query(`
+        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

@@ -6,6 +6,18 @@ export declare class CreateOrganizationTableMigration implements IMigration {
     constructor(client: Client, orgId: string);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -27,29 +27,38 @@ export class CreateOrganizationTableMigration {
                 "_deletedBy" VARCHAR(255)
                 )
             `);
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating organization 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 ('${this._id}', '${this.orgId}', ${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() {
         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}';
             `);
         }
         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

@@ -6,6 +6,18 @@ export declare class CreateUsersTableMigration implements IMigration {
     constructor(client: Client, orgId?: string | undefined);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -30,36 +30,51 @@ export class CreateUsersTableMigration {
                     "_deletedBy" VARCHAR(255)
                 )
             `);
-            if (this.orgId) {
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating users table: ${error.message}`) };
+        }
+        if (this.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 ('${this._id}', '${this.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 ('${this._id}', ${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;
-        }
-        return true;
+        return { success: true, error: null };
     }
     async revert() {
         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 "_id" = '${this._id}';
             `);
         }
         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,23 @@
 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);
     index: number;
     _id: string;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
 }

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

@@ -11,47 +11,62 @@ export class CreateRefreshTokenTableMigration {
     async execute() {
         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) {
+                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) {
+            return { success: false, error: new Error(`Error creating refresh token table: ${error.message}`) };
+        }
+        if (this.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 ('${this._id}', '${this.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 ('${this._id}', ${this.index}, TRUE, FALSE);
                 `);
             }
-            return true;
-        }
-        catch (error) {
-            console.error('Error creating refresh token 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() {
         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 "_id" = '${this._id}';
             `);
-            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,12 @@
 import { IEntity } from "@loomcore/common/models";
 export interface IMigration extends IEntity {
     index: number;
-    execute(): Promise<boolean>;
-    revert(): Promise<boolean>;
+    execute(): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
+    revert(): 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

@@ -7,12 +7,13 @@ export async function setupDatabaseForAuth(client, orgId) {
         new CreateUsersTableMigration(client, orgId),
         new CreateRefreshTokenTableMigration(client, orgId),
     ];
-    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/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, orgId: string): Promise<{
+    success: boolean;
+    error: Error | null;
+}>;

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

@@ -5,12 +5,13 @@ export async function setupDatabaseForMultitenant(client, orgId) {
         new CreateMigrationTableMigration(client, orgId),
         new CreateOrganizationTableMigration(client, orgId),
     ];
-    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/dist/utils/express.utils.d.ts

@@ -1,9 +1,10 @@
 import { Application } from 'express';
-import { Db, MongoClient } from "mongodb";
+import { MongoClient } from "mongodb";
 import { Server } from "http";
 import { IBaseApiConfig } from "../models/index.js";
-type RouteSetupFunction = (app: Application, db: Db, config: IBaseApiConfig) => void;
-declare function setupExpressApp(db: Db, config: IBaseApiConfig, setupRoutes: RouteSetupFunction): Application;
+import { IDatabase } from '../databases/models/index.js';
+type RouteSetupFunction = (app: Application, database: IDatabase, config: IBaseApiConfig) => void;
+declare function setupExpressApp(database: IDatabase, config: IBaseApiConfig, setupRoutes: RouteSetupFunction): Application;
 declare function performGracefulShutdown(event: any, mongoClient: MongoClient | null, externalServer: Server | null, internalServer: Server | null): void;
 export declare const expressUtils: {
     setupExpressApp: typeof setupExpressApp;

package/dist/utils/express.utils.js

@@ -6,7 +6,7 @@ import qs from 'qs';
 import { NotFoundError } from "../errors/not-found.error.js";
 import { errorHandler } from "../middleware/error-handler.js";
 import { ensureUserContext } from '../middleware/ensure-user-context.js';
-function setupExpressApp(db, config, setupRoutes) {
+function setupExpressApp(database, config, setupRoutes) {
     const app = express();
     app.set('query parser', (str) => {
         return qs.parse(str, {});
@@ -24,7 +24,7 @@ function setupExpressApp(db, config, setupRoutes) {
         credentials: true
     }));
     app.use(ensureUserContext);
-    setupRoutes(app, db, config);
+    setupRoutes(app, database, config);
     app.use(async (req, res) => {
         throw new NotFoundError(`Requested path, ${req.path}, Not Found`);
     });

package/package.json

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