@loomcore/api 0.2.11 → 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__/postgres-test-migrations/postgres-test-schema.d.ts

@@ -1,3 +1,3 @@
-import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
-import { SyntheticMigration } from '../../databases/postgres/migrations/postgres-initial-schema.js';
+import type { SyntheticMigration } from "../../databases/postgres/migrations/postgres-initial-schema.js";
+import type { IBaseApiConfig } from "../../models/base-api-config.interface.js";
 export declare const getPostgresTestSchema: (config: IBaseApiConfig) => SyntheticMigration[];

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -2,9 +2,9 @@ export const getPostgresTestSchema = (config) => {
     const migrations = [];
     const isMultiTenant = config.app.isMultiTenant === true;
     migrations.push({
-        name: '00000000000100_schema-test-entities',
+        name: "00000000000100_schema-test-entities",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "testEntities" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -25,12 +25,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "testEntities"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000101_schema-categories',
+        name: "00000000000101_schema-categories",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "categories" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -41,12 +41,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "categories"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000102_schema-products',
+        name: "00000000000102_schema-products",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "products" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -67,12 +67,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "products"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000103_schema-test-items',
+        name: "00000000000103_schema-test-items",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "testItems" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -91,12 +91,53 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "testItems"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000105_5_schema-agents',
+        name: "00000000000104_schema-persons",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
+            const personsUniqueConstraints = isMultiTenant
+                ? `CONSTRAINT "uk_persons_org_external_id" UNIQUE ("_orgId", "external_id"),
+            CONSTRAINT "uk_persons_org_ssn" UNIQUE ("_orgId", "ssn")`
+                : `CONSTRAINT "uk_persons_external_id" UNIQUE ("external_id"),
+            CONSTRAINT "uk_persons_ssn" UNIQUE ("ssn")`;
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "persons" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "external_id" VARCHAR(255),
+          "first_name" VARCHAR(255) NOT NULL,
+          "middle_name" VARCHAR(255),
+          "last_name" VARCHAR(255) NOT NULL,
+          "date_of_birth" DATE,
+          "ssn" VARCHAR(255),
+          "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
+          "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
+          "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
+          "extended_types" INTEGER,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ,
+          "_updatedBy" INTEGER,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          ${personsUniqueConstraints}
+        )
+      `);
+            await pool.query(`CREATE INDEX IF NOT EXISTS "idx_persons_external_id" ON "persons" ("external_id")`);
+            await pool.query(`CREATE INDEX IF NOT EXISTS "idx_persons_ssn" ON "persons" ("ssn")`);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query(`DROP INDEX IF EXISTS "idx_persons_external_id"`);
+            await pool.query(`DROP INDEX IF EXISTS "idx_persons_ssn"`);
+            await pool.query('DROP TABLE IF EXISTS "persons"');
+        },
+    });
+    migrations.push({
+        name: "00000000000105_5_schema-agents",
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "agents" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -114,12 +155,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "agents"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000105_6_schema-clients',
+        name: "00000000000105_6_schema-clients",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "clients" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -140,12 +181,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "clients"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000105_7_schema-policies',
+        name: "00000000000105_7_schema-policies",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "policies" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -165,12 +206,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "policies"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000105_8_schema-agents-policies',
+        name: "00000000000105_8_schema-agents-policies",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS agents_policies (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -191,12 +232,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "agents_policies"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000105_9_schema-premiums',
+        name: "00000000000105_9_schema-premiums",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS "premiums" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -216,12 +257,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "premiums"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000106_schema-email-addresses',
+        name: "00000000000106_schema-email-addresses",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS email_addresses (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -243,12 +284,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "email_addresses"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000107_schema-phone-numbers',
+        name: "00000000000107_schema-phone-numbers",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS phone_numbers (
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -268,12 +309,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "phone_numbers"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000108_schema-addresses',
+        name: "00000000000108_schema-addresses",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS addresses (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -297,12 +338,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "addresses"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000109_schema-person-addresses',
+        name: "00000000000109_schema-person-addresses",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS persons_addresses (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -323,12 +364,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "persons_addresses"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000110_schema-person-phone-numbers',
+        name: "00000000000110_schema-person-phone-numbers",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS persons_phone_numbers (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -349,12 +390,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "persons_phone_numbers"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000111_schema-states',
+        name: "00000000000111_schema-states",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS states (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -371,12 +412,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "states"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000112_schema-districts',
+        name: "00000000000112_schema-districts",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS districts (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -395,12 +436,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "districts"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000113_schema-schools',
+        name: "00000000000113_schema-schools",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS schools (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -419,12 +460,12 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "schools"');
-        }
+        },
     });
     migrations.push({
-        name: '00000000000114_schema-person-schools',
+        name: "00000000000114_schema-person-schools",
         up: async ({ context: pool }) => {
-            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : "";
             await pool.query(`
         CREATE TABLE IF NOT EXISTS persons_schools (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -445,7 +486,7 @@ export const getPostgresTestSchema = (config) => {
         },
         down: async ({ context: pool }) => {
             await pool.query('DROP TABLE IF EXISTS "persons_schools"');
-        }
+        },
     });
     return migrations;
 };

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,30 +26,25 @@ export const getMongoInitialSchema = (dbConfig) => {
                 await db.collection("organizations").drop();
             },
         });
-    if (isAuthEnabled)
         migrations.push({
-            name: "00000000000002_schema-persons",
+            name: "00000000000001_schema-organization-domains",
             up: async ({ context: db }) => {
-                await db.createCollection("persons");
-                if (isMultiTenant) {
-                    await db.collection("persons").createIndex({ _orgId: 1 });
-                    await db
-                        .collection("persons")
-                        .createIndex({ _orgId: 1, externalId: 1 }, { unique: true, sparse: true });
-                }
-                else {
-                    await db
-                        .collection("persons")
-                        .createIndex({ externalId: 1 }, { unique: true, sparse: true });
-                }
+                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("persons").drop();
+                await db.collection("organization_domains").drop();
             },
         });
+    }
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000003_schema-users",
+            name: "00000000000002_schema-users",
             up: async ({ context: db }) => {
                 await db.createCollection("users");
                 if (dbConfig.app.isMultiTenant) {
@@ -70,7 +65,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000004_schema-refresh-tokens",
+            name: "00000000000003_schema-refresh-tokens",
             up: async ({ context: db }) => {
                 await db.createCollection("refresh_tokens");
                 await db
@@ -88,7 +83,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000005_schema-password-reset-tokens",
+            name: "00000000000004_schema-password-reset-tokens",
             up: async ({ context: db }) => {
                 await db.createCollection("password_reset_tokens");
                 if (isMultiTenant) {
@@ -111,7 +106,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000006_schema-roles",
+            name: "00000000000005_schema-roles",
             up: async ({ context: db }) => {
                 await db.createCollection("roles");
                 if (isMultiTenant) {
@@ -132,7 +127,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000007_schema-user-roles",
+            name: "00000000000006_schema-user-roles",
             up: async ({ context: db }) => {
                 await db.createCollection("user_roles");
                 if (isMultiTenant) {
@@ -155,7 +150,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000008_schema-features",
+            name: "00000000000007_schema-features",
             up: async ({ context: db }) => {
                 await db.createCollection("features");
                 if (isMultiTenant) {
@@ -176,7 +171,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000009_schema-authorizations",
+            name: "00000000000008_schema-authorizations",
             up: async ({ context: db }) => {
                 await db.createCollection("authorizations");
                 if (isMultiTenant) {
@@ -199,7 +194,7 @@ export const getMongoInitialSchema = (dbConfig) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000010_data-meta-org",
+            name: "00000000000009_data-meta-org",
             up: async ({ context: db }) => {
                 const metaOrgDoc = {
                     name: dbConfig.multiTenant.metaOrgName,
@@ -222,20 +217,32 @@ 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 });
             },
         });
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000011_data-admin-user",
+            name: "00000000000010_data-admin-user",
             up: async ({ context: db }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. " +
+                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000009_data-meta-org) should have run before this migration. " +
                             "Please ensure metaOrgName and metaOrgCode are provided in your dbConfig."
                         : "BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.";
                     console.error("❌ Migration Error:", errorMessage);
@@ -247,26 +254,12 @@ export const getMongoInitialSchema = (dbConfig) => {
                     : {};
                 const hashedPassword = await passwordUtils.hashPassword(dbConfig.adminUser.password);
                 const email = dbConfig.adminUser.email.toLowerCase();
-                const personResult = await db.collection("persons").insertOne({
-                    ...orgDoc,
-                    externalId: "admin-user-person-external-id",
-                    firstName: "Admin",
-                    lastName: "User",
-                    isAgent: false,
-                    isClient: false,
-                    isEmployee: false,
-                    _created: new Date(),
-                    _createdBy: "system",
-                    _updated: new Date(),
-                    _updatedBy: "system",
-                });
                 await db.collection("users").insertOne({
                     ...orgDoc,
                     externalId: "admin-user-external-id",
                     email,
                     password: hashedPassword,
                     displayName: "Admin User",
-                    personId: personResult.insertedId,
                     _created: new Date(),
                     _createdBy: "system",
                     _updated: new Date(),
@@ -284,7 +277,7 @@ export const getMongoInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000012_data-admin-authorizations",
+            name: "00000000000011_data-admin-authorizations",
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);

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,67 +51,48 @@ export const getPostgresInitialSchema = (dbConfig) => {
                 await pool.query('DROP TABLE IF EXISTS "organizations"');
             },
         });
-    }
-    if (isAuthEnabled)
         migrations.push({
-            name: "00000000000003_schema-persons",
+            name: "00000000000002_schema-organization-domains",
             up: async ({ context: pool }) => {
-                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
-                const personsUniqueConstraints = isMultiTenant
-                    ? `CONSTRAINT "uk_persons_org_external_id" UNIQUE ("_orgId", "external_id"),
-            CONSTRAINT "uk_persons_org_ssn" UNIQUE ("_orgId", "ssn")`
-                    : `CONSTRAINT "uk_persons_external_id" UNIQUE ("external_id"),
-            CONSTRAINT "uk_persons_ssn" UNIQUE ("ssn")`;
                 await pool.query(`
-          CREATE TABLE IF NOT EXISTS "persons" (
-            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-            ${orgColumnDef}
-            "external_id" VARCHAR(255),
-            "first_name" VARCHAR(255) NOT NULL,
-            "middle_name" VARCHAR(255),
-            "last_name" VARCHAR(255) NOT NULL,
-            "date_of_birth" DATE,
-            "ssn" VARCHAR(255),
-            "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
-            "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
-            "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
-            "extended_types" INTEGER,
-            "_created" TIMESTAMPTZ NOT NULL,
-            "_createdBy" INTEGER NOT NULL,
-            "_updated" TIMESTAMPTZ,
-            "_updatedBy" INTEGER,
-            "_deleted" TIMESTAMPTZ,
-            "_deletedBy" INTEGER,
-            ${personsUniqueConstraints}
-          )`);
-                await pool.query(`CREATE INDEX IF NOT EXISTS "idx_persons_external_id" ON "persons" ("external_id")`);
-                await pool.query(`CREATE INDEX IF NOT EXISTS "idx_persons_ssn" ON "persons" ("ssn")`);
+				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_persons_external_id"`);
-                await pool.query(`DROP INDEX IF EXISTS "idx_persons_ssn"`);
-                await pool.query(`DROP TABLE IF EXISTS "persons"`);
+                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({
-            name: "00000000000004_schema-users",
+            name: "00000000000003_schema-users",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
-                let uniqueConstraint = isMultiTenant
+                const uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
-                uniqueConstraint += `,
-          CONSTRAINT "fk_users_person_id" FOREIGN KEY("person_id") REFERENCES "persons"("_id") ON DELETE CASCADE`;
                 await pool.query(`
         CREATE TABLE IF NOT EXISTS "users"(
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
             ${orgColumnDef}
-          "external_id" VARCHAR(255) UNIQUE,
+          	"external_id" VARCHAR(255) UNIQUE,
             "email" VARCHAR(255) NOT NULL,
             "display_name" VARCHAR(255),
             "password" VARCHAR(255) NOT NULL,
-            "person_id" INTEGER UNIQUE,
             "_lastLoggedIn" TIMESTAMPTZ,
             "_lastPasswordChange" TIMESTAMPTZ,
             "_created" TIMESTAMPTZ NOT NULL,
@@ -125,18 +105,16 @@ export const getPostgresInitialSchema = (dbConfig) => {
           )`);
                 await pool.query(`CREATE INDEX IF NOT EXISTS "idx_users_external_id" ON "users"("external_id")`);
                 await pool.query(`CREATE INDEX IF NOT EXISTS "idx_users_email" ON "users"("email")`);
-                await pool.query(`CREATE INDEX IF NOT EXISTS "idx_users_person_id" ON "users"("person_id")`);
             },
             down: async ({ context: pool }) => {
                 await pool.query(`DROP INDEX IF EXISTS "idx_users_external_id"`);
                 await pool.query(`DROP INDEX IF EXISTS "idx_users_email"`);
-                await pool.query(`DROP INDEX IF EXISTS "idx_users_person_id"`);
                 await pool.query(`DROP TABLE IF EXISTS "users"`);
             },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000005_schema-refresh-tokens",
+            name: "00000000000004_schema-refresh-tokens",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 await pool.query(`
@@ -159,7 +137,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000006_schema-password-reset-tokens",
+            name: "00000000000005_schema-password-reset-tokens",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 const uniqueConstraint = isMultiTenant
@@ -188,7 +166,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000007_schema-roles",
+            name: "00000000000006_schema-roles",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 const uniqueConstraint = isMultiTenant
@@ -210,7 +188,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000008_schema-user-roles",
+            name: "00000000000007_schema-user-roles",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 const uniqueConstraint = isMultiTenant
@@ -240,7 +218,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000009_schema-features",
+            name: "00000000000008_schema-features",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 const uniqueConstraint = isMultiTenant
@@ -262,7 +240,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: "00000000000010_schema-authorizations",
+            name: "00000000000009_schema-authorizations",
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER NOT NULL,' : "";
                 const uniqueConstraint = isMultiTenant
@@ -295,21 +273,28 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: "00000000000011_data-meta-org",
+            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`);
@@ -318,11 +303,11 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000012_data-admin-user",
+            name: "00000000000011_data-admin-user",
             up: async ({ context: pool }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000011_data-meta-org) should have run before this migration. " +
+                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. " +
                             "Please ensure metaOrgName and metaOrgCode are provided in your dbConfig."
                         : "BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.";
                     console.error("❌ Migration Error:", errorMessage);
@@ -336,21 +321,13 @@ export const getPostgresInitialSchema = (dbConfig) => {
                 const email = dbConfig.adminUser.email.toLowerCase();
                 const client = await pool.connect();
                 try {
-                    const personResult = isMultiTenant && orgId
-                        ? await client.query(`INSERT INTO "persons"("_orgId", "first_name", "last_name", "is_agent", "is_client", "is_employee", "_created", "_createdBy")
-        VALUES($1, 'Admin', 'User', false, false, false, NOW(), 0)
-                 RETURNING "_id"`, [orgId])
-                        : await client.query(`INSERT INTO "persons"("first_name", "last_name", "is_agent", "is_client", "is_employee", "_created", "_createdBy")
-        VALUES('Admin', 'User', false, false, false, NOW(), 0)
-                 RETURNING "_id"`);
-                    const personId = personResult.rows[0]._id;
-                    if (isMultiTenant && orgId) {
-                        await client.query(`INSERT INTO "users"("_orgId", "email", "display_name", "password", "person_id", "_created", "_createdBy")
-        VALUES($1, $2, 'Admin User', $3, $4, NOW(), 0)`, [orgId, email, hashedPassword, personId]);
+                    if (isMultiTenant) {
+                        await client.query(`INSERT INTO "users"("_orgId", "email", "display_name", "password", "_created", "_createdBy")
+        				VALUES($1, $2, 'Admin User', $3, NOW(), 0)`, [orgId, email, hashedPassword]);
                     }
                     else {
-                        await client.query(`INSERT INTO "users"("email", "display_name", "password", "person_id", "_created", "_createdBy")
-        VALUES($1, 'Admin User', $2, $3, NOW(), 0)`, [email, hashedPassword, personId]);
+                        await client.query(`INSERT INTO "users"("email", "display_name", "password", "_created", "_createdBy")
+        				VALUES($1, 'Admin User', $2, NOW(), 0)`, [email, hashedPassword]);
                     }
                 }
                 finally {
@@ -368,7 +345,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: "00000000000013_data-admin-authorizations",
+            name: "00000000000012_data-admin-authorizations",
             up: async ({ context: pool }) => {
                 const client = await pool.connect();
                 try {

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.11",
+  "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",