@loomcore/api 0.1.22 → 0.1.24

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

@@ -0,0 +1,74 @@
+import { randomUUID } from "crypto";
+import { doesTableExist } from "../utils/does-table-exist.util.js";
+export class CreateAuthorizationsTableMigration {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    index = 10;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            await this.client.query('BEGIN');
+            const tableExists = await doesTableExist(this.client, 'authorizations');
+            if (!tableExists) {
+                await this.client.query(`
+                    CREATE TABLE "authorizations" (
+                        "_id" VARCHAR(255) PRIMARY KEY,
+                        "_orgId" VARCHAR(255),
+                        "_roleId" VARCHAR(255) NOT NULL,
+                        "_featureId" VARCHAR(255) NOT NULL,
+                        "startDate" TIMESTAMP,
+                        "endDate" TIMESTAMP,
+                        "config" JSONB,
+                        "_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_authorizations_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("_roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("_featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
+                        CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "_roleId", "_featureId")
+                    )
+                `);
+            }
+            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 "authorizations";
+            `);
+            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/setup-for-auth.migration.js

@@ -3,7 +3,10 @@ import { CreateMigrationTableMigration } from "./001-create-migrations-table.mig
 import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
 import { CreateAdminUserMigration } from "./006-create-admin-user.migration.js";
-import { getSystemUserContext } from "@loomcore/common/models";
+import { CreateUserRolesTableMigration } from "./008-create-user-roles-table.migration.js";
+import { CreateRoleTableMigration } from "./007-create-roles-table.migration.js";
+import { CreateAuthorizationsTableMigration } from "./010-create-authorizations-table.migration.js";
+import { CreateFeaturesTableMigration } from "./009-create-features-table.migration.js";
 export async function setupDatabaseForAuth(client, adminUsername, adminPassword) {
     let runMigrations = [];
     if (await doesTableExist(client, 'migrations')) {
@@ -23,10 +26,16 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword)
         migrationsToRun.push(new CreateUsersTableMigration(client));
     if (!runMigrations.includes(4))
         migrationsToRun.push(new CreateRefreshTokenTableMigration(client));
-    if (!runMigrations.includes(6)) {
-        const systemUserContext = getSystemUserContext();
-        migrationsToRun.push(new CreateAdminUserMigration(client, adminUsername, adminPassword, systemUserContext._orgId));
-    }
+    if (!runMigrations.includes(6))
+        migrationsToRun.push(new CreateAdminUserMigration(client, adminUsername, adminPassword));
+    if (!runMigrations.includes(7))
+        migrationsToRun.push(new CreateRoleTableMigration(client));
+    if (!runMigrations.includes(8))
+        migrationsToRun.push(new CreateUserRolesTableMigration(client));
+    if (!runMigrations.includes(9))
+        migrationsToRun.push(new CreateFeaturesTableMigration(client));
+    if (!runMigrations.includes(10))
+        migrationsToRun.push(new CreateAuthorizationsTableMigration(client));
     for (const migration of migrationsToRun) {
         await migration.execute();
     }

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, orgName: string, orgCode: string): Promise<{
+export declare function setupDatabaseForMultitenant(client: Client, metaOrgName: string, metaOrgCode: string): Promise<{
     success: boolean;
     metaOrgId: string | undefined;
     error: Error | null;

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

@@ -2,13 +2,12 @@ import { CreateMigrationTableMigration } from "./001-create-migrations-table.mig
 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';
 import { PostgresDatabase } from "../postgres.database.js";
 import { OrganizationService } from "../../../services/index.js";
 import { EmptyUserContext } from "@loomcore/common/models";
-export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
+export async function setupDatabaseForMultitenant(client, metaOrgName, metaOrgCode) {
     let runMigrations = [];
-    let metaOrgId = randomUUID().toString();
+    let metaOrgId;
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
             SELECT "_id", "index"
@@ -28,7 +27,7 @@ export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
         }
     }
     if (!runMigrations.includes(2)) {
-        const createOrganizationTableMigration = new CreateOrganizationsTableMigration(client, orgName, orgCode);
+        const createOrganizationTableMigration = new CreateOrganizationsTableMigration(client);
         const result = await createOrganizationTableMigration.execute();
         if (!result.success) {
             console.log('setupDatabaseForMultitenant: error creating organizations table', result.error);
@@ -44,11 +43,22 @@ export async function setupDatabaseForMultitenant(client, orgName, orgCode) {
         }
     }
     if (!runMigrations.includes(5)) {
-        const createMetaOrgMigration = new CreateMetaOrgMigration(client, orgName, orgCode);
+        const createMetaOrgMigration = new CreateMetaOrgMigration(client, metaOrgName, metaOrgCode);
         const result = await createMetaOrgMigration.execute();
         if (!result.success || !result.metaOrgId) {
             console.log('setupDatabaseForMultitenant: error creating meta org', result.error);
-            return { success: false, metaOrgId: metaOrgId, error: result.error };
+            return { success: false, metaOrgId: result.metaOrgId, error: result.error };
+        }
+        metaOrgId = result.metaOrgId;
+    }
+    else {
+        if (!metaOrgId) {
+            const database = new PostgresDatabase(client);
+            const organizationService = new OrganizationService(database);
+            const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+            if (metaOrg) {
+                metaOrgId = metaOrg._id;
+            }
         }
     }
     return { success: true, metaOrgId: metaOrgId, error: null };

package/dist/models/refresh-token.model.d.ts

@@ -12,7 +12,7 @@ export declare const refreshTokenSchema: import("@sinclair/typebox").TObject<{
     deviceId: import("@sinclair/typebox").TString;
     userId: import("@sinclair/typebox").TString;
     expiresOn: import("@sinclair/typebox").TNumber;
-    created: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>, import("@sinclair/typebox").TUndefined]>;
+    created: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>;
     createdBy: import("@sinclair/typebox").TString;
 }>;
 export declare const refreshTokenModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/services/auth.service.js

@@ -242,9 +242,6 @@ export class AuthService extends MultiTenantApiService {
             const hash = await passwordUtils.hashPassword(entity.password);
             entity.password = hash;
         }
-        if (isCreate && !entity.roles) {
-            entity.roles = ["user"];
-        }
         const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
         return preparedEntity;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -13,8 +13,8 @@
     "push": "git push",
     "publishMe": "npm publish --access public",
     "pub": "npm-run-all -s add commit patch build push publishMe",
-    "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/models",
-    "install-updated-libs": "npm i @loomcore/models",
+    "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/common",
+    "install-updated-libs": "npm i @loomcore/common",
     "update-libs": "npm-run-all -s update-lib-versions install-updated-libs",
     "typecheck": "tsc",
     "test": "npm-run-all -s test:postgres test:mongodb",
@@ -53,7 +53,7 @@
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.19",
+    "@loomcore/common": "^0.0.27",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
@@ -70,17 +70,17 @@
     "@types/express": "^5.0.1",
     "@types/jsonwebtoken": "^9.0.9",
     "@types/lodash": "^4.17.13",
+    "@types/pg": "^8.15.6",
     "@types/qs": "^6.14.0",
     "@types/supertest": "^6.0.3",
-    "@types/pg": "^8.15.6",
     "@vitest/coverage-v8": "^3.0.9",
     "cross-env": "^7.0.3",
     "mongodb-memory-server": "^9.3.0",
     "npm-run-all": "^4.1.5",
+    "pg-mem": "^3.0.5",
     "rxjs": "^7.8.0",
     "supertest": "^7.1.0",
     "typescript": "^5.8.3",
-    "pg-mem": "^3.0.5",
     "vite": "^6.2.5",
     "vitest": "^3.0.9"
   }