@loomcore/api 0.1.9 → 0.1.11

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

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

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

@@ -6,10 +6,10 @@ export declare class CreateMigrationTableMigration implements IMigration {
     index: number;
     execute(_orgId?: string): Promise<{
         success: boolean;
-        error: null;
+        error: Error;
     } | {
         success: boolean;
-        error: Error;
+        error: null;
     }>;
     revert(_orgId?: string): Promise<{
         success: boolean;

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

@@ -20,7 +20,7 @@ export class CreateMigrationTableMigration {
         }
         catch (error) {
             if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                return { success: true, error: null };
+                console.log(`Migrations table already exists`);
             }
             else {
                 return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
@@ -28,15 +28,21 @@ export class CreateMigrationTableMigration {
         }
         try {
             if (_orgId) {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
                     VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);`);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
             else {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                     VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
         }
         catch (error) {
@@ -46,9 +52,12 @@ export class CreateMigrationTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
+            const result = 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

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

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "crypto";
-export class CreateOrganizationTableMigration {
+export class CreateOrganizationsTableMigration {
     client;
     orgName;
     orgCode;
@@ -11,7 +11,6 @@ export class CreateOrganizationTableMigration {
     index = 2;
     async execute(_orgId) {
         const _id = randomUUID().toString();
-        const _orgIdToUse = _orgId || randomUUID().toString();
         try {
             await this.client.query(`
             CREATE TABLE "organizations" (
@@ -33,26 +32,20 @@ export class CreateOrganizationTableMigration {
         }
         catch (error) {
             if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                return { success: true, error: null };
+                console.log(`Organization table already exists`);
             }
             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 creating meta organization: ${error.message}`) };
-        }
-        try {
-            await this.client.query(`
+            const result = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
-                VALUES ('${_id}', '${_orgIdToUse}', ${this.index}, TRUE, FALSE);
+                VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
             `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
@@ -61,12 +54,15 @@ export class CreateOrganizationTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
-            DROP TABLE "organizations";
-        `);
+            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`) };
+            }
         }
         catch (error) {
-            return { success: false, error: new Error(`Error dropping organizations table: ${error.message}`) };
+            return { success: false, error: new Error(`Error dropping organizations table for orgId ${_orgId}: ${error.message}`) };
         }
         try {
             const result = await this.client.query(`
@@ -74,13 +70,13 @@ export class CreateOrganizationTableMigration {
             `);
             if (result.rowCount === 0) {
                 return {
-                    success: false, error: new Error(`Error updating migration record: Migration record not found.
+                    success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: Migration record not found.
                     Migration index: ${this.index}, _orgId: ${_orgId}`)
                 };
             }
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
+            return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: ${error.message}`) };
         }
         return { success: true, error: null };
     }

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

@@ -6,10 +6,10 @@ export declare class CreateUsersTableMigration implements IMigration {
     index: number;
     execute(_orgId?: string): Promise<{
         success: boolean;
-        error: null;
+        error: Error;
     } | {
         success: boolean;
-        error: Error;
+        error: null;
     }>;
     revert(_orgId?: string): Promise<{
         success: boolean;

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

@@ -31,7 +31,7 @@ export class CreateUsersTableMigration {
         }
         catch (error) {
             if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                return { success: true, error: null };
+                console.log(`Users table already exists`);
             }
             else {
                 return { success: false, error: new Error(`Error creating users table: ${error.message}`) };
@@ -39,10 +39,13 @@ export class CreateUsersTableMigration {
         }
         if (_orgId) {
             try {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
                     VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
             catch (error) {
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
@@ -50,10 +53,13 @@ export class CreateUsersTableMigration {
         }
         else {
             try {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                     VALUES ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
             catch (error) {
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
@@ -63,20 +69,26 @@ export class CreateUsersTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
+            const result = await this.client.query(`
                 DROP TABLE "users";
             `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error dropping users table: No row returned`) };
+            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error dropping users table: ${error.message}`) };
         }
         try {
-            await this.client.query(`
+            const result = await this.client.query(`
                 UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: No row returned`) };
+            }
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
+            return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: ${error.message}`) };
         }
         return { success: true, error: null };
     }

package/dist/databases/postgres/migrations/{004-create-refresh-token-table.migration.js → 004-create-refresh-tokens-table.migration.js}

@@ -23,7 +23,7 @@ export class CreateRefreshTokenTableMigration {
         }
         catch (error) {
             if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                return { success: true, error: null };
+                console.log(`Refresh token table already exists`);
             }
             else {
                 return { success: false, error: new Error(`Error creating refresh token table: ${error.message}`) };
@@ -31,10 +31,13 @@ export class CreateRefreshTokenTableMigration {
         }
         if (_orgId) {
             try {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
                     VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
             catch (error) {
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
@@ -42,10 +45,13 @@ export class CreateRefreshTokenTableMigration {
         }
         else {
             try {
-                await this.client.query(`
+                const result = await this.client.query(`
                     INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                     VALUES ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
+                if (result.rowCount === 0) {
+                    return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+                }
             }
             catch (error) {
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
@@ -55,17 +61,23 @@ export class CreateRefreshTokenTableMigration {
     }
     async revert(_orgId) {
         try {
-            await this.client.query(`
+            const result = await this.client.query(`
                 DROP TABLE "refreshTokens";
             `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error dropping refresh token table: No row returned`) };
+            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error dropping refresh token table: ${error.message}`) };
         }
         try {
-            await this.client.query(`
+            const result = await this.client.query(`
                 UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
             `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: No row returned`) };
+            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };

package/dist/databases/postgres/migrations/005-create-meta-org.migration.d.ts

@@ -0,0 +1,26 @@
+import { Client } from "pg";
+import { IMigration } from "./migration.interface.js";
+export declare class CreateMetaOrgMigration implements IMigration {
+    private readonly client;
+    private readonly orgName;
+    private readonly orgCode;
+    constructor(client: Client, orgName: string, orgCode: string);
+    index: number;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+        metaOrgId?: undefined;
+    } | {
+        success: boolean;
+        metaOrgId: string;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+}
+export default CreateMetaOrgMigration;

package/dist/databases/postgres/migrations/005-create-meta-org.migration.js

@@ -0,0 +1,63 @@
+import { randomUUID } from "crypto";
+export class CreateMetaOrgMigration {
+    client;
+    orgName;
+    orgCode;
+    constructor(client, orgName, orgCode) {
+        this.client = client;
+        this.orgName = orgName;
+        this.orgCode = orgCode;
+    }
+    index = 5;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            const result = await this.client.query(`
+                INSERT INTO "organizations" ("_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
+                VALUES ('${_id}', '${this.orgName}', '${this.orgCode}', 1, true, NOW(), 'system', NOW(), 'system');`);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error creating meta org: No row returned`) };
+            }
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating meta org: ${error.message}`) };
+        }
+        try {
+            const result = await this.client.query(`
+                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
+            `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+        }
+        return { success: true, metaOrgId: _id, error: null };
+    }
+    async revert(_orgId) {
+        try {
+            const result = await this.client.query(`DELETE FROM "organizations" WHERE "_id" = ${_orgId} AND "isMetaOrg" = TRUE;`);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error reverting meta org: No row returned`) };
+            }
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error reverting meta org: ${error.message}`) };
+        }
+        try {
+            const result = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}' AND "_orgId" = '${_orgId}';
+            `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: No row returned`) };
+            }
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error updating migration record for index ${this.index} and orgId ${_orgId}: ${error.message}`) };
+        }
+        return { success: true, error: null };
+    }
+}
+export default CreateMetaOrgMigration;

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

@@ -1,4 +1,4 @@
-import { CreateRefreshTokenTableMigration } from "./004-create-refresh-token-table.migration.js";
+import { CreateRefreshTokenTableMigration } from "./004-create-refresh-tokens-table.migration.js";
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
 import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";

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

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

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

@@ -1,30 +1,44 @@
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
-import { CreateOrganizationTableMigration } from "./002-create-organizations-table.migration.js";
+import { CreateOrganizationsTableMigration } from "./002-create-organizations-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
+import { CreateMetaOrgMigration } from "./005-create-meta-org.migration.js";
+import { randomUUID } from 'crypto';
 export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
     let runMigrations = [];
+    const metaOrgId = randomUUID().toString();
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
             SELECT "_id", "index"
             FROM migrations
-            WHERE "hasRun" = TRUE AND "reverted" = FALSE AND "_orgId" IS NULL
+            WHERE "hasRun" = TRUE AND "reverted" = FALSE
         `);
         runMigrations = migrations.rows.map((row) => {
             return row.index;
         });
     }
-    let migrationsToRun = [];
-    if (!runMigrations.includes(1))
-        migrationsToRun.push(new CreateMigrationTableMigration(client));
-    if (!runMigrations.includes(2))
-        migrationsToRun.push(new CreateOrganizationTableMigration(client, orgName, orgCode));
-    try {
-        for (const migration of migrationsToRun) {
-            await migration.execute();
+    if (!runMigrations.includes(1)) {
+        const createMigrationTableMigration = new CreateMigrationTableMigration(client);
+        const result = await createMigrationTableMigration.execute(metaOrgId);
+        if (!result.success) {
+            console.log('setupDatabaseForMultitenant: error creating migration table', result.error);
+            return { success: false, metaOrgId: metaOrgId, error: result.error };
         }
     }
-    catch (error) {
-        return { success: false, error: error };
+    if (!runMigrations.includes(2)) {
+        const createOrganizationTableMigration = new CreateOrganizationsTableMigration(client, orgName, orgCode);
+        const result = await createOrganizationTableMigration.execute(metaOrgId);
+        if (!result.success) {
+            console.log('setupDatabaseForMultitenant: error creating organizations table', result.error);
+            return { success: false, metaOrgId: metaOrgId, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(5)) {
+        const createMetaOrgMigration = new CreateMetaOrgMigration(client, orgName, orgCode);
+        const result = await createMetaOrgMigration.execute(metaOrgId);
+        if (!result.success || !result.metaOrgId) {
+            console.log('setupDatabaseForMultitenant: error creating meta org', result.error);
+            return { success: false, metaOrgId: metaOrgId, error: result.error };
+        }
     }
-    return { success: true, error: null };
+    return { success: true, metaOrgId: metaOrgId, error: null };
 }

package/package.json

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

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

@@ -6,10 +6,10 @@ export declare class CreateRefreshTokenTableMigration implements IMigration {
     index: number;
     execute(_orgId?: string): Promise<{
         success: boolean;
-        error: null;
+        error: Error;
     } | {
         success: boolean;
-        error: Error;
+        error: null;
     }>;
     revert(_orgId?: string): Promise<{
         success: boolean;