@loomcore/api 0.1.7 → 0.1.9

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {
         success: boolean;
         error: null;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -31,10 +29,10 @@ export class CreateTestEntitiesTableMigration {
         catch (error) {
             return { success: false, error: new Error(`Error creating test entities table: ${error.message}`) };
         }
-        if (this.orgId) {
+        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);
                 `);
             }
             catch (error) {
@@ -44,7 +42,7 @@ export class CreateTestEntitiesTableMigration {
         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);
                 `);
             }
             catch (error) {
@@ -53,7 +51,7 @@ export class CreateTestEntitiesTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE test_entities;
@@ -64,7 +62,7 @@ export class CreateTestEntitiesTableMigration {
         }
         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) {

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {
         success: boolean;
         error: null;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -21,10 +19,10 @@ export class CreateCategoriesTableMigration {
         catch (error) {
             return { success: false, error: new Error(`Error creating categories table: ${error.message}`) };
         }
-        if (this.orgId) {
+        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);
                 `);
             }
             catch (error) {
@@ -34,7 +32,7 @@ export class CreateCategoriesTableMigration {
         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);
                 `);
             }
             catch (error) {
@@ -43,7 +41,7 @@ export class CreateCategoriesTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "categories";
@@ -54,7 +52,7 @@ export class CreateCategoriesTableMigration {
         }
         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) {

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {
         success: boolean;
         error: null;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -30,10 +28,10 @@ export class CreateProductsTableMigration {
         catch (error) {
             return { success: false, error: new Error(`Error creating products table: ${error.message}`) };
         }
-        if (this.orgId) {
+        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);
                 `);
             }
             catch (error) {
@@ -43,7 +41,7 @@ export class CreateProductsTableMigration {
         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);
                 `);
             }
             catch (error) {
@@ -52,7 +50,7 @@ export class CreateProductsTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "products";
@@ -63,7 +61,7 @@ export class CreateProductsTableMigration {
         }
         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) {

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {
         success: boolean;
         error: null;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -34,10 +32,10 @@ export class CreateTestUsersTableMigration {
         catch (error) {
             return { success: false, error: new Error(`Error creating test users table: ${error.message}`) };
         }
-        if (this.orgId) {
+        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);
                 `);
             }
             catch (error) {
@@ -47,7 +45,7 @@ export class CreateTestUsersTableMigration {
         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);
                 `);
             }
             catch (error) {
@@ -56,7 +54,7 @@ export class CreateTestUsersTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "testUsers";
@@ -67,7 +65,7 @@ export class CreateTestUsersTableMigration {
         }
         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) {

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {
         success: boolean;
         error: null;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -29,10 +27,10 @@ export class CreateTestItemsTableMigration {
         catch (error) {
             return { success: false, error: new Error(`Error creating test items table: ${error.message}`) };
         }
-        if (this.orgId) {
+        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);
                 `);
             }
             catch (error) {
@@ -42,7 +40,7 @@ export class CreateTestItemsTableMigration {
         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);
                 `);
             }
             catch (error) {
@@ -51,7 +49,7 @@ export class CreateTestItemsTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "testItems";
@@ -62,7 +60,7 @@ export class CreateTestItemsTableMigration {
         }
         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) {

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

@@ -1,5 +1,5 @@
 import { Client } from "pg";
-export declare function runTestMigrations(client: Client, orgId?: string): Promise<{
+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,17 +3,17 @@ 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),
     ];
     try {
         for (const migration of migrations) {
-            await migration.execute();
+            await migration.execute(_orgId);
         }
     }
     catch (error) {

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,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
-        error: Error;
+        error: null;
     } | {
         success: boolean;
-        error: null;
+        error: Error;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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,34 +19,32 @@ 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 {
                 return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
             }
         }
-        if (!alreadyRun) {
-            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);
-            `);
-                }
+        try {
+            if (_orgId) {
+                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 {
+                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 "migrations";

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

@@ -2,18 +2,18 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
-        error: Error;
+        error: null;
     } | {
         success: boolean;
-        error: null;
+        error: Error;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -29,12 +32,26 @@ export class CreateOrganizationTableMigration {
             `);
         }
         catch (error) {
-            return { success: false, error: new Error(`Error creating organization table: ${error.message}`) };
+            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 creating meta organization: ${error.message}`) };
         }
         try {
             await this.client.query(`
                 INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
-                VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                VALUES ('${_id}', '${_orgIdToUse}', ${this.index}, TRUE, FALSE);
             `);
         }
         catch (error) {
@@ -42,7 +59,7 @@ export class CreateOrganizationTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
             DROP TABLE "organizations";
@@ -52,9 +69,15 @@ export class CreateOrganizationTableMigration {
             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}';
+            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: Migration record not found.
+                    Migration index: ${this.index}, _orgId: ${_orgId}`)
+                };
+            }
         }
         catch (error) {
             return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };

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

@@ -2,18 +2,16 @@ 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
-        error: Error;
+        error: null;
     } | {
         success: boolean;
-        error: null;
+        error: Error;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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" (
@@ -32,13 +30,18 @@ export class CreateUsersTableMigration {
             `);
         }
         catch (error) {
-            return { success: false, error: new Error(`Error creating users table: ${error.message}`) };
+            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 (this.orgId) {
+        if (_orgId) {
             try {
                 await this.client.query(`
                     INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
-                    VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -49,7 +52,7 @@ export class CreateUsersTableMigration {
             try {
                 await this.client.query(`
                     INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
-                    VALUES ('${this._id}', ${this.index}, TRUE, FALSE);
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -58,7 +61,7 @@ export class CreateUsersTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "users";
@@ -69,7 +72,7 @@ export class CreateUsersTableMigration {
         }
         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) {

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

@@ -2,18 +2,16 @@ import { Client } from "pg";
 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<{
+    execute(_orgId?: string): Promise<{
         success: boolean;
-        error: Error;
+        error: null;
     } | {
         success: boolean;
-        error: null;
+        error: Error;
     }>;
-    revert(): Promise<{
+    revert(_orgId?: string): Promise<{
         success: boolean;
         error: Error;
     } | {

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

@@ -1,14 +1,12 @@
 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" (
@@ -24,13 +22,18 @@ export class CreateRefreshTokenTableMigration {
             `);
         }
         catch (error) {
-            return { success: false, error: new Error(`Error creating refresh token table: ${error.message}`) };
+            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 (this.orgId) {
+        if (_orgId) {
             try {
                 await this.client.query(`
                     INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
-                    VALUES ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                    VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -41,7 +44,7 @@ export class CreateRefreshTokenTableMigration {
             try {
                 await this.client.query(`
                     INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
-                    VALUES ('${this._id}', ${this.index}, TRUE, FALSE);
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
                 `);
             }
             catch (error) {
@@ -50,7 +53,7 @@ export class CreateRefreshTokenTableMigration {
         }
         return { success: true, error: null };
     }
-    async revert() {
+    async revert(_orgId) {
         try {
             await this.client.query(`
                 DROP TABLE "refreshTokens";
@@ -61,7 +64,7 @@ export class CreateRefreshTokenTableMigration {
         }
         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) {

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

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

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

@@ -1,5 +1,5 @@
 import { Client } from "pg";
-export declare function setupDatabaseForAuth(client: Client, orgId?: string): Promise<{
+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,19 +1,28 @@
 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) {
-    const migrations = [
-        new CreateMigrationTableMigration(client, orgId),
-        new CreateUsersTableMigration(client, orgId),
-        new CreateRefreshTokenTableMigration(client, orgId),
-    ];
-    try {
-        for (const migration of migrations) {
-            await migration.execute();
-        }
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export async function setupDatabaseForAuth(client, _orgId) {
+    let runMigrations = [];
+    if (await doesTableExist(client, 'migrations')) {
+        const migrations = await client.query(`
+            SELECT "_id", "index"
+            FROM migrations
+            WHERE "hasRun" = TRUE AND "reverted" = FALSE AND "_orgId" = $1
+        `, [_orgId]);
+        runMigrations = migrations.rows.map((row) => {
+            return row.index;
+        });
     }
-    catch (error) {
-        return { success: false, error: error };
+    let migrationsToRun = [];
+    if (!runMigrations.includes(1))
+        migrationsToRun.push(new CreateMigrationTableMigration(client));
+    if (!runMigrations.includes(3))
+        migrationsToRun.push(new CreateUsersTableMigration(client));
+    if (!runMigrations.includes(4))
+        migrationsToRun.push(new CreateRefreshTokenTableMigration(client));
+    for (const migration of migrationsToRun) {
+        await migration.execute(_orgId);
     }
     return { success: true, error: null };
 }

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

@@ -1,5 +1,5 @@
 import { Client } from "pg";
-export declare function setupDatabaseForMultitenant(client: Client, orgId: string): Promise<{
+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,12 +1,25 @@
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
 import { CreateOrganizationTableMigration } from "./002-create-organizations-table.migration.js";
-export async function setupDatabaseForMultitenant(client, orgId) {
-    const migrations = [
-        new CreateMigrationTableMigration(client, orgId),
-        new CreateOrganizationTableMigration(client, orgId),
-    ];
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
+    let runMigrations = [];
+    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
+        `);
+        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 migrations) {
+        for (const migration of migrationsToRun) {
             await migration.execute();
         }
     }

package/dist/databases/postgres/utils/does-table-exist.util.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "pg";
+export declare function doesTableExist(client: Client, tableName: string): Promise<boolean>;

package/dist/databases/postgres/utils/does-table-exist.util.js

@@ -0,0 +1,8 @@
+export async function doesTableExist(client, tableName) {
+    const result = await client.query(`
+        SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
+        )
+    `, [tableName]);
+    return result.rows[0].exists;
+}

package/package.json

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