@loomcore/api 0.2.12 → 0.2.13

package/dist/__tests__/common-test.utils.js

@@ -11,8 +11,9 @@ import { PostgresDatabase } from "../databases/postgres/postgres.database.js";
 import { GenericApiService, UserService } from "../services/index.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
 import { OrganizationService } from "../services/organization.service.js";
+import { OrganizationDomainService } from "../services/organization-domain.service.js";
 import * as testObjectsModule from "./test-objects.js";
-const { getTestMetaOrg, getTestMetaOrgRefererUrl, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUser, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, } = testObjectsModule;
+const { getTestMetaOrg, getTestMetaOrgDomain, getTestMetaOrgRefererUrl, getTestOrg, getTestOrgDomain, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUser, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, TEST_META_ORG_DOMAIN, TEST_ORG_DOMAIN, } = testObjectsModule;
 import { entityUtils } from "@loomcore/common/utils";
 import { config, setBaseApiConfig } from "../config/index.js";
 import { attemptLogin } from "../utils/auth/index.js";
@@ -24,6 +25,7 @@ import { TestEmailClient } from "./test-email-client.js";
 let deviceIdCookie;
 let database;
 let organizationService;
+let organizationDomainService;
 let userService;
 const JWT_SECRET = "test-secret";
 const newUser1Email = "one@test.com";
@@ -32,6 +34,7 @@ const constDeviceIdCookie = crypto.randomBytes(16).toString("hex");
 function initialize(db) {
     database = db;
     organizationService = new OrganizationService(db);
+    organizationDomainService = new OrganizationDomainService(db);
     userService = new UserService(db);
     deviceIdCookie = constDeviceIdCookie;
 }
@@ -51,7 +54,7 @@ async function createMetaOrg() {
     if (!config.app.isMultiTenant) {
         return;
     }
-    if (!organizationService) {
+    if (!organizationService || !organizationDomainService) {
         throw new Error("OrganizationService not initialized. Call initialize() first.");
     }
     try {
@@ -60,10 +63,15 @@ async function createMetaOrg() {
             const metaOrgInsertResult = await organizationService.create(EmptyUserContext, getTestMetaOrg());
             if (metaOrgInsertResult) {
                 setTestMetaOrgId(metaOrgInsertResult._id);
+                await organizationDomainService.create(EmptyUserContext, getTestMetaOrgDomain(metaOrgInsertResult._id));
             }
         }
         else {
             setTestMetaOrgId(existingMetaOrg._id);
+            const existingDomain = await organizationDomainService.findOne(EmptyUserContext, { filters: { domain: { eq: TEST_META_ORG_DOMAIN } } });
+            if (!existingDomain) {
+                await organizationDomainService.create(EmptyUserContext, getTestMetaOrgDomain(existingMetaOrg._id));
+            }
         }
     }
     catch (error) {
@@ -96,7 +104,7 @@ async function setupTestUsers() {
     }
 }
 async function createTestUsers() {
-    if (!organizationService || !userService) {
+    if (!organizationService || !organizationDomainService || !userService) {
         throw new Error("Database not initialized. Call initialize() first.");
     }
     try {
@@ -112,9 +120,14 @@ async function createTestUsers() {
                 throw new Error("Failed to create test organization");
             }
             setTestOrgId(createdTestOrg._id);
+            await organizationDomainService.create(EmptyUserContext, getTestOrgDomain(createdTestOrg._id));
         }
         else {
             setTestOrgId(existingTestOrg._id);
+            const existingDomain = await organizationDomainService.findOne(EmptyUserContext, { filters: { domain: { eq: TEST_ORG_DOMAIN } } });
+            if (!existingDomain) {
+                await organizationDomainService.create(EmptyUserContext, getTestOrgDomain(existingTestOrg._id));
+            }
         }
         const createdTestOrgUser = await userService.create(getTestOrgUserContext(), getTestOrgUser());
         const createdMetaOrgUser = await userService.create(getTestMetaOrgUserContext(), getTestMetaOrgUser());

package/dist/__tests__/test-objects.d.ts

@@ -1,4 +1,4 @@
-import type { IOrganization, IUser, IUserContext } from "@loomcore/common/models";
+import type { IOrganization, IOrganizationDomain, IUser, IUserContext } from "@loomcore/common/models";
 export declare let TEST_META_ORG_ID: string | number;
 export declare let TEST_META_ORG_USER_ID: string | number;
 export declare function setTestMetaOrgId(metaOrgId: string | number): void;
@@ -6,15 +6,17 @@ export declare function setTestMetaOrgUserId(userId: string | number): void;
 export declare const TEST_META_ORG_USER_PASSWORD = "test-meta-org-user-password";
 export declare const TEST_META_ORG_DOMAIN = "test-meta-org.example.com";
 export declare const TEST_ORG_DOMAIN = "test-org.example.com";
-export declare function getRefererUrlForOrg(org: Pick<IOrganization, "domain">): string;
+export declare function getRefererUrlForOrg(domain: string): string;
 export declare function getTestMetaOrgRefererUrl(): string;
 export declare function getTestOrgRefererUrl(): string;
 export declare function getTestMetaOrg(): IOrganization;
+export declare function getTestMetaOrgDomain(organizationId?: string | number): Partial<IOrganizationDomain>;
 export declare function getTestMetaOrgUser(): IUser;
 export declare function getTestMetaOrgUserContext(): IUserContext;
 export declare function setTestOrgId(orgId: string | number): void;
 export declare function setTestOrgUserId(userId: string | number): void;
 export declare function getTestOrg(): IOrganization;
+export declare function getTestOrgDomain(organizationId?: string | number): Partial<IOrganizationDomain>;
 export declare const TEST_ORG_USER_PASSWORD = "test-org-user-password";
 export declare function getTestOrgUser(): IUser;
 export declare function getTestOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -9,30 +9,35 @@ export function setTestMetaOrgUserId(userId) {
 export const TEST_META_ORG_USER_PASSWORD = "test-meta-org-user-password";
 export const TEST_META_ORG_DOMAIN = "test-meta-org.example.com";
 export const TEST_ORG_DOMAIN = "test-org.example.com";
-export function getRefererUrlForOrg(org) {
-    if (!org.domain) {
+export function getRefererUrlForOrg(domain) {
+    if (!domain) {
         throw new Error("Organization domain is required for auth referer URL");
     }
-    return `https://${org.domain}`;
+    return `https://${domain}`;
 }
 export function getTestMetaOrgRefererUrl() {
-    return getRefererUrlForOrg(getTestMetaOrg());
+    return getRefererUrlForOrg(TEST_META_ORG_DOMAIN);
 }
 export function getTestOrgRefererUrl() {
-    return getRefererUrlForOrg(getTestOrg());
+    return getRefererUrlForOrg(TEST_ORG_DOMAIN);
 }
 export function getTestMetaOrg() {
     return {
         _id: TEST_META_ORG_ID,
         name: "Test Meta Organization",
         code: "test-meta-org",
-        domain: TEST_META_ORG_DOMAIN,
         status: 1,
         isMetaOrg: true,
         _created: new Date(),
         _createdBy: "system",
     };
 }
+export function getTestMetaOrgDomain(organizationId = TEST_META_ORG_ID) {
+    return {
+        organizationId,
+        domain: TEST_META_ORG_DOMAIN,
+    };
+}
 export function getTestMetaOrgUser() {
     return {
         _id: TEST_META_ORG_USER_ID,
@@ -73,13 +78,18 @@ export function getTestOrg() {
         _id: TEST_ORG_ID,
         name: "Test Organization",
         code: "test-org",
-        domain: TEST_ORG_DOMAIN,
         status: 1,
         isMetaOrg: false,
         _created: new Date(),
         _createdBy: "system",
     };
 }
+export function getTestOrgDomain(organizationId = TEST_ORG_ID) {
+    return {
+        organizationId,
+        domain: TEST_ORG_DOMAIN,
+    };
+}
 export const TEST_ORG_USER_PASSWORD = "test-org-user-password";
 export function getTestOrgUser() {
     return {

package/dist/controllers/auth.controller.js

@@ -38,9 +38,7 @@ export class AuthController {
             if (!referer) {
                 throw new BadRequestError("Missing required fields: referer is required.");
             }
-            organization = await this.organizationService.findOne(EmptyUserContext, {
-                filters: { domain: { eq: referer.split("/")[2] } },
-            });
+            organization = await this.organizationService.findByDomain(EmptyUserContext, referer.split("/")[2]);
             if (!organization) {
                 throw new BadRequestError("Missing required fields: organization is required.");
             }
@@ -96,9 +94,7 @@ export class AuthController {
         referer = referer.replace(/\/$/, "");
         let organization = null;
         if (config.app.isMultiTenant) {
-            organization = await this.organizationService.findOne(EmptyUserContext, {
-                filters: { domain: { eq: referer.split("/")[2] } },
-            });
+            organization = await this.organizationService.findByDomain(EmptyUserContext, referer.split("/")[2]);
             if (!organization) {
                 throw new BadRequestError("Missing required fields: organization is required.");
             }
@@ -126,9 +122,7 @@ export class AuthController {
             if (!referer) {
                 throw new BadRequestError("Missing required fields: referer is required.");
             }
-            organization = await this.organizationService.findOne(EmptyUserContext, {
-                filters: { domain: { eq: referer.split("/")[2] } },
-            });
+            organization = await this.organizationService.findByDomain(EmptyUserContext, referer.split("/")[2]);
             if (!organization) {
                 throw new BadRequestError("Missing required fields: organization is required.");
             }

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -9,7 +9,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         throw new Error("Multi-tenant configuration is enabled but multi-tenant configuration is not provided");
     }
     const isAuthEnabled = dbConfig.app.isAuthEnabled;
-    if (isMultiTenant)
+    if (isMultiTenant) {
         migrations.push({
             name: "00000000000001_schema-organizations",
             up: async ({ context: db }) => {
@@ -26,6 +26,22 @@ export const getMongoInitialSchema = (dbConfig) => {
                 await db.collection("organizations").drop();
             },
         });
+        migrations.push({
+            name: "00000000000001_schema-organization-domains",
+            up: async ({ context: db }) => {
+                await db.createCollection("organization_domains");
+                await db
+                    .collection("organization_domains")
+                    .createIndex({ domain: 1 }, { unique: true });
+                await db
+                    .collection("organization_domains")
+                    .createIndex({ organizationId: 1 });
+            },
+            down: async ({ context: db }) => {
+                await db.collection("organization_domains").drop();
+            },
+        });
+    }
     if (isAuthEnabled)
         migrations.push({
             name: "00000000000002_schema-users",
@@ -201,9 +217,21 @@ export const getMongoInitialSchema = (dbConfig) => {
                     ...metaOrgDoc,
                     _id: result.insertedId,
                 };
+                const metaOrgDomains = dbConfig.multiTenant.metaOrgDomains ?? [];
+                if (metaOrgDomains.length > 0) {
+                    await db.collection("organization_domains").insertMany(metaOrgDomains.map((domain) => ({
+                        organizationId: metaOrg._id,
+                        domain,
+                        _created: new Date(),
+                        _createdBy: "system",
+                        _updated: new Date(),
+                        _updatedBy: "system",
+                    })));
+                }
                 initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
             },
             down: async ({ context: db }) => {
+                await db.collection("organization_domains").deleteMany({});
                 await db.collection("organizations").deleteMany({ isMetaOrg: true });
             },
         });

package/dist/databases/postgres/migrations/__tests__/test-migration-helper.js

@@ -8,7 +8,7 @@ export async function runInitialSchemaMigrations(pool, config) {
         app: config.app,
         database: config.database,
         adminUser: config.adminUser ?? { email: 'admin@test.com', password: 'admin-password' },
-        multiTenant: config.multiTenant ?? (config.app.isMultiTenant ? { metaOrgName: 'Test Meta Organization', metaOrgCode: 'TEST_META_ORG', metaOrgDomain: TEST_META_ORG_DOMAIN } : { metaOrgName: '', metaOrgCode: '', metaOrgDomain: '' }),
+        multiTenant: config.multiTenant ?? (config.app.isMultiTenant ? { metaOrgName: 'Test Meta Organization', metaOrgCode: 'TEST_META_ORG', metaOrgDomains: [TEST_META_ORG_DOMAIN] } : { metaOrgName: '', metaOrgCode: '', metaOrgDomains: [] }),
         email: config.email,
     };
     const initialSchema = getPostgresInitialSchema(migrationConfig);

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -34,7 +34,6 @@ export const getPostgresInitialSchema = (dbConfig) => {
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
             "name" VARCHAR(255) NOT NULL UNIQUE,
             "code" VARCHAR(255) UNIQUE,
-			"domain" VARCHAR(255) UNIQUE,
             "description" TEXT,
             "status" INTEGER NOT NULL,
             "is_meta_org" BOOLEAN NOT NULL,
@@ -52,6 +51,31 @@ export const getPostgresInitialSchema = (dbConfig) => {
                 await pool.query('DROP TABLE IF EXISTS "organizations"');
             },
         });
+        migrations.push({
+            name: "00000000000002_schema-organization-domains",
+            up: async ({ context: pool }) => {
+                await pool.query(`
+				CREATE TABLE IF NOT EXISTS "organization_domains" (
+					"_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+					"organization_id" INTEGER NOT NULL,
+					"domain" VARCHAR(255) NOT NULL UNIQUE,
+					"_created" TIMESTAMPTZ NOT NULL,
+					"_createdBy" INTEGER NOT NULL,
+					"_updated" TIMESTAMPTZ,
+					"_updatedBy" INTEGER,
+					"_deleted" TIMESTAMPTZ,
+					"_deletedBy" INTEGER,
+					CONSTRAINT "fk_organization_domains_organization"
+					FOREIGN KEY("organization_id") REFERENCES "organizations"("_id") ON DELETE CASCADE
+				)
+				`);
+                await pool.query(`CREATE INDEX IF NOT EXISTS "idx_organization_domains_organization_id" ON "organization_domains"("organization_id")`);
+            },
+            down: async ({ context: pool }) => {
+                await pool.query(`DROP INDEX IF EXISTS "idx_organization_domains_organization_id"`);
+                await pool.query('DROP TABLE IF EXISTS "organization_domains"');
+            },
+        });
     }
     if (isAuthEnabled)
         migrations.push({
@@ -252,18 +276,25 @@ export const getPostgresInitialSchema = (dbConfig) => {
             name: "00000000000010_data-meta-org",
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
-					INSERT INTO "organizations"("name", "code", "domain", "status", "is_meta_org", "_created", "_createdBy")
-					VALUES($1, $2, $3, 1, true, NOW(), 0)
-					RETURNING "_id", "name", "code", "domain", "status", "is_meta_org", "_created", "_createdBy"
+					INSERT INTO "organizations"("name", "code", "status", "is_meta_org", "_created", "_createdBy")
+					VALUES($1, $2, 1, true, NOW(), 0)
+					RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy"
 					`, [
                     dbConfig.multiTenant?.metaOrgName,
                     dbConfig.multiTenant?.metaOrgCode,
-                    dbConfig.multiTenant?.metaOrgDomain,
                 ]);
                 if (result.rowCount === 0) {
                     throw new Error("Failed to create meta organization");
                 }
-                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", result.rows[0]);
+                const metaOrg = result.rows[0];
+                const metaOrgDomains = dbConfig.multiTenant?.metaOrgDomains ?? [];
+                for (const domain of metaOrgDomains) {
+                    await pool.query(`
+						INSERT INTO "organization_domains"("organization_id", "domain", "_created", "_createdBy")
+						VALUES($1, $2, NOW(), 0)
+						`, [metaOrg._id, domain]);
+                }
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
             },
             down: async ({ context: pool }) => {
                 await pool.query(`DELETE FROM "organizations" WHERE "is_meta_org" = TRUE`);

package/dist/models/initial-database-config.interface.d.ts

@@ -12,7 +12,7 @@ export interface IInitialDbMigrationConfig {
     multiTenant: {
         metaOrgName: string;
         metaOrgCode: string;
-        metaOrgDomain: string;
+        metaOrgDomains: string[];
     };
     email?: IEmailConfig;
 }

package/dist/services/index.d.ts

@@ -5,6 +5,7 @@ export * from "./generic-query-service/generic-query.service.js";
 export * from "./generic-query-service/generic-query-service.interface.js";
 export * from "./multi-tenant-api.service.js";
 export * from "./organization.service.js";
+export * from "./organization-domain.service.js";
 export * from "./password-reset-token.service.js";
 export * from "./refresh-token.service.js";
 export * from "./tenant-query-decorator.js";

package/dist/services/index.js

@@ -5,6 +5,7 @@ export * from "./generic-query-service/generic-query.service.js";
 export * from "./generic-query-service/generic-query-service.interface.js";
 export * from "./multi-tenant-api.service.js";
 export * from "./organization.service.js";
+export * from "./organization-domain.service.js";
 export * from "./password-reset-token.service.js";
 export * from "./refresh-token.service.js";
 export * from "./tenant-query-decorator.js";

package/dist/services/organization-domain.service.d.ts

@@ -0,0 +1,6 @@
+import { type IOrganizationDomain } from "@loomcore/common/models";
+import type { IDatabase } from "../databases/models/index.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+export declare class OrganizationDomainService extends GenericApiService<IOrganizationDomain> {
+    constructor(database: IDatabase);
+}

package/dist/services/organization-domain.service.js

@@ -0,0 +1,7 @@
+import { OrganizationDomainSpec, } from "@loomcore/common/models";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+export class OrganizationDomainService extends GenericApiService {
+    constructor(database) {
+        super(database, "organization_domains", "organization_domain", OrganizationDomainSpec);
+    }
+}

package/dist/services/organization.service.d.ts

@@ -3,9 +3,11 @@ import type { AppIdType } from "@loomcore/common/types";
 import type { IDatabase } from "../databases/models/index.js";
 import { GenericApiService } from "./generic-api-service/generic-api.service.js";
 export declare class OrganizationService extends GenericApiService<IOrganization> {
+    private organizationDomainService;
     constructor(database: IDatabase);
     preProcessEntity(userContext: IUserContext, entity: Partial<IOrganization>, isCreate: boolean, allowId?: boolean): Promise<Partial<IOrganization>>;
     getAuthTokenByRepoCode(userContext: IUserContext, orgId: AppIdType): Promise<string | null>;
     validateRepoAuthToken(userContext: IUserContext, orgCode: string, authToken: string): Promise<AppIdType | null>;
     getMetaOrg(userContext: IUserContext): Promise<IOrganization | null>;
+    findByDomain(userContext: IUserContext, domain: string): Promise<IOrganization | null>;
 }

package/dist/services/organization.service.js

@@ -1,9 +1,12 @@
 import { OrganizationSpec, } from "@loomcore/common/models";
 import { BadRequestError } from "../errors/index.js";
 import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+import { OrganizationDomainService } from "./organization-domain.service.js";
 export class OrganizationService extends GenericApiService {
+    organizationDomainService;
     constructor(database) {
         super(database, "organizations", "organization", OrganizationSpec);
+        this.organizationDomainService = new OrganizationDomainService(database);
     }
     async preProcessEntity(userContext, entity, isCreate, allowId = true) {
         if (isCreate) {
@@ -38,4 +41,15 @@ export class OrganizationService extends GenericApiService {
         });
         return org;
     }
+    async findByDomain(userContext, domain) {
+        const organizationDomain = await this.organizationDomainService.findOne(userContext, {
+            filters: { domain: { eq: domain } },
+        });
+        if (!organizationDomain) {
+            return null;
+        }
+        return this.findOne(userContext, {
+            filters: { _id: { eq: organizationDomain.organizationId } },
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -58,7 +58,7 @@
     "qs": "^6.15.2"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.74",
+    "@loomcore/common": "^0.0.77",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",