@loomcore/api 0.1.22 → 0.1.24

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
 export class CreateUsersTableMigration {
     client;
     constructor(client) {
@@ -8,72 +9,66 @@ export class CreateUsersTableMigration {
     async execute(_orgId) {
         const _id = randomUUID().toString();
         try {
-            await this.client.query(`
-                CREATE TABLE "users" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "email" VARCHAR(255) NOT NULL,
-                    "firstName" VARCHAR(255),
-                    "lastName" VARCHAR(255),
-                    "displayName" VARCHAR(255),
-                    "password" VARCHAR(255) NOT NULL,
-                    "roles" TEXT[],
-                    "_lastLoggedIn" TIMESTAMP,
-                    "_lastPasswordChange" TIMESTAMP,
-                    "_created" TIMESTAMP NOT NULL,
-                    "_createdBy" VARCHAR(255) NOT NULL,
-                    "_updated" TIMESTAMP NOT NULL,
-                    "_updatedBy" VARCHAR(255) NOT NULL,
-                    "_deleted" TIMESTAMP,
-                    "_deletedBy" VARCHAR(255)
-                )
-            `);
-        }
-        catch (error) {
-            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                console.log(`Users table already exists`);
-            }
-            else {
-                return { success: false, error: new Error(`Error creating users table: ${error.message}`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'users');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "users" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "_orgId" VARCHAR(255),
+                        "email" VARCHAR(255) NOT NULL,
+                        "firstName" VARCHAR(255),
+                        "lastName" VARCHAR(255),
+                        "displayName" VARCHAR(255),
+                        "password" VARCHAR(255) NOT NULL,
+                        "_lastLoggedIn" TIMESTAMP,
+                        "_lastPasswordChange" TIMESTAMP,
+                        "_created" TIMESTAMP NOT NULL,
+                        "_createdBy" VARCHAR(255) NOT NULL,
+                        "_updated" TIMESTAMP NOT NULL,
+                        "_updatedBy" VARCHAR(255) NOT NULL,
+                        "_deleted" TIMESTAMP,
+                        "_deletedBy" VARCHAR(255),
+                        CONSTRAINT "fk_users_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")
+                    )
+                `);
             }
-        }
-        try {
             const result = await this.client.query(`
-                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
-                VALUES ('${_id}', ${this.index}, TRUE, FALSE);
-            `);
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
             if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
     async revert() {
         try {
-            const result = await this.client.query(`
+            await this.client.query('BEGIN');
+            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 {
-            const result = await this.client.query(`
+            const updateResult = await this.client.query(`
                 UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
-            if (result.rowCount === 0) {
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record for index ${this.index}: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
 }

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
 export class CreateRefreshTokenTableMigration {
     client;
     constructor(client) {
@@ -8,64 +9,60 @@ export class CreateRefreshTokenTableMigration {
     async execute(_orgId) {
         const _id = randomUUID().toString();
         try {
-            await this.client.query(`
-                CREATE TABLE "refreshTokens" (
-                    "_id" VARCHAR(255) PRIMARY KEY,
-                    "_orgId" VARCHAR(255),
-                    "token" VARCHAR(255) NOT NULL,
-                    "deviceId" VARCHAR(255) NOT NULL,
-                    "userId" VARCHAR(255) NOT NULL,
-                    "expiresOn" BIGINT NOT NULL,
-                    "created" TIMESTAMP NOT NULL,
-                    "createdBy" VARCHAR(255) NOT NULL
-                )
-            `);
-        }
-        catch (error) {
-            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                console.log(`Refresh token table already exists`);
-            }
-            else {
-                return { success: false, error: new Error(`Error creating refresh token table: ${error.message}`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'refreshTokens');
+            if (!tableExists) {
+                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
+                    )
+                `);
             }
-        }
-        try {
             const result = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
             if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
     async revert() {
         try {
-            const result = await this.client.query(`
-                DROP TABLE "refreshTokens";
-            `);
-            if (result.rowCount === 0) {
-                return { success: false, error: new Error(`Error dropping refresh token table: No row returned`) };
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'refreshTokens');
+            if (tableExists) {
+                await this.client.query(`
+                    DROP TABLE "refreshTokens";
+                `);
             }
-        }
-        catch (error) {
-            return { success: false, error: new Error(`Error dropping refresh token table: ${error.message}`) };
-        }
-        try {
-            const result = await this.client.query(`
+            const updateResult = await this.client.query(`
                 UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
-            if (result.rowCount === 0) {
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
 }

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

@@ -12,52 +12,53 @@ export class CreateMetaOrgMigration {
     async execute() {
         const _id = randomUUID().toString();
         try {
-            const result = await this.client.query(`
+            await this.client.query('BEGIN');
+            const orgResult = 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) {
+                VALUES ('${_id}', '${this.orgName}', '${this.orgCode}', 1, true, NOW(), 'system', NOW(), 'system');
+            `);
+            if (orgResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 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(`
+            const migrationResult = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);
             `);
-            if (result.rowCount === 0) {
+            if (migrationResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, metaOrgId: _id, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, metaOrgId: _id, error: null };
     }
     async revert() {
         try {
-            const result = await this.client.query(`DELETE FROM "organizations" WHERE "isMetaOrg" = TRUE;`);
-            if (result.rowCount === 0) {
+            await this.client.query('BEGIN');
+            const deleteResult = await this.client.query(`DELETE FROM "organizations" WHERE "isMetaOrg" = TRUE;`);
+            if (deleteResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 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(`
+            const updateResult = await this.client.query(`
                 UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
             `);
-            if (result.rowCount === 0) {
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
             }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
         }
         catch (error) {
-            return { success: false, error: new Error(`Error updating migration record for index ${this.index}: ${error.message}`) };
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
         }
-        return { success: true, error: null };
     }
 }
 export default CreateMetaOrgMigration;

package/dist/databases/postgres/migrations/006-create-admin-user.migration.d.ts

@@ -4,8 +4,7 @@ export declare class CreateAdminUserMigration implements IMigration {
     private readonly client;
     private readonly adminEmail;
     private readonly adminPassword;
-    private readonly _orgId?;
-    constructor(client: Client, adminEmail: string, adminPassword: string, _orgId?: string | undefined);
+    constructor(client: Client, adminEmail: string, adminPassword: string);
     index: number;
     execute(): Promise<{
         success: boolean;

package/dist/databases/postgres/migrations/006-create-admin-user.migration.js

@@ -6,32 +6,41 @@ export class CreateAdminUserMigration {
     client;
     adminEmail;
     adminPassword;
-    _orgId;
-    constructor(client, adminEmail, adminPassword, _orgId) {
+    constructor(client, adminEmail, adminPassword) {
         this.client = client;
         this.adminEmail = adminEmail;
         this.adminPassword = adminPassword;
-        this._orgId = _orgId;
     }
     index = 6;
     async execute() {
         const _id = randomUUID().toString();
+        const systemUserContext = getSystemUserContext();
         try {
             const database = new PostgresDatabase(this.client);
             const authService = new AuthService(database);
-            const adminUser = await authService.createUser(getSystemUserContext(), {
+            const adminUser = await authService.createUser(systemUserContext, {
                 _id: _id,
-                _orgId: this._orgId,
+                _orgId: systemUserContext._orgId,
                 email: this.adminEmail,
                 password: this.adminPassword,
                 firstName: 'Admin',
                 lastName: 'User',
                 displayName: 'Admin User',
-                roles: ['admin'],
+                authorizations: [{
+                        _id: randomUUID().toString(),
+                        feature: 'metaorgAdmin',
+                        config: {},
+                        _created: new Date(),
+                        _createdBy: systemUserContext.user._id,
+                        _updated: new Date(),
+                        _updatedBy: systemUserContext.user._id
+                    }],
             });
         }
         catch (error) {
-            return { success: false, error: new Error(`Error creating admin user: ${error.message}`) };
+            return {
+                success: false, error: new Error(`Error creating admin user: ${error.message}`)
+            };
         }
         try {
             const result = await this.client.query(`

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

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

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

@@ -0,0 +1,62 @@
+import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export class CreateRoleTableMigration {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    index = 7;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'roles');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "roles" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "_orgId" VARCHAR(255),
+                        "name" VARCHAR(255) NOT NULL,
+                        CONSTRAINT "fk_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "uk_roles_name" UNIQUE ("_orgId", "name")
+                    )
+                `);
+            }
+            const result = await this.client.query(`
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query('BEGIN');
+            await this.client.query(`
+                DROP TABLE "roles";
+            `);
+            const updateResult = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
+            `);
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
+        }
+    }
+}

package/dist/databases/postgres/migrations/008-create-user-roles-table.migration.d.ts

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

package/dist/databases/postgres/migrations/008-create-user-roles-table.migration.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export class CreateUserRolesTableMigration {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    index = 8;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'user_roles');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "user_roles" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "_orgId" VARCHAR(255),
+                        "_userId" VARCHAR(255) NOT NULL,
+                        "_roleId" VARCHAR(255) NOT NULL,
+                        CONSTRAINT "fk_user_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE
+                        CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("_userId") REFERENCES "users"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("_roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "_userId", "_roleId")
+                    )
+                `);
+            }
+            const result = await this.client.query(`
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query('BEGIN');
+            await this.client.query(`
+                DROP TABLE "user_roles";
+            `);
+            const updateResult = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
+            `);
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
+        }
+    }
+}

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

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

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

@@ -0,0 +1,62 @@
+import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export class CreateFeaturesTableMigration {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    index = 9;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'features');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "features" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "_orgId" VARCHAR(255),
+                        "name" VARCHAR(255) NOT NULL,
+                        CONSTRAINT "fk_features_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "uk_features" UNIQUE ("_orgId", "name")
+                    )
+                `);
+            }
+            const result = await this.client.query(`
+                    INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                    VALUES ('${_id}', ${this.index}, TRUE, FALSE);
+                `);
+            if (result.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query('BEGIN');
+            await this.client.query(`
+                DROP TABLE "features";
+            `);
+            const updateResult = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = '${this.index}';
+            `);
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
+        }
+    }
+}

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

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