@loomcore/api 0.2.8 → 0.2.9

package/dist/__tests__/common-test.utils.d.ts

@@ -5,6 +5,7 @@ import type { IDatabase } from "../databases/models/index.js";
 import type { Operation } from "../databases/operations/operation.js";
 import { GenericApiService } from "../services/index.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import * as testObjectsModule from "./test-objects.js";
 import type { DbType } from "../databases/db-type.type.js";
 import { type ICategory } from "./models/category.model.js";
 import { type IProduct } from "./models/product.model.js";
@@ -64,8 +65,9 @@ declare const testUtils: {
     deleteMetaOrg: typeof deleteMetaOrg;
     deleteTestUser: typeof deleteTestUser;
     getAuthToken: typeof getAuthToken;
+    getTestMetaOrgRefererUrl: typeof testObjectsModule.getTestMetaOrgRefererUrl;
     initialize: typeof initialize;
-    SetupTestConfig: typeof setupTestConfig;
+    setupTestConfig: typeof setupTestConfig;
     loginWithTestUser: typeof loginWithTestUser;
     newUser1Email: string;
     newUser1Password: string;

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

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { EmptyUserContext, } from "@loomcore/common/models";
+import { EmptyUserContext, getSystemUserContext, } from "@loomcore/common/models";
 import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import jwt from "jsonwebtoken";
@@ -12,7 +12,7 @@ import { GenericApiService, UserService } from "../services/index.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
 import { OrganizationService } from "../services/organization.service.js";
 import * as testObjectsModule from "./test-objects.js";
-const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, } = testObjectsModule;
+const { getTestMetaOrg, getTestMetaOrgRefererUrl, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUser, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, } = testObjectsModule;
 import { entityUtils } from "@loomcore/common/utils";
 import { config, setBaseApiConfig } from "../config/index.js";
 import { attemptLogin } from "../utils/auth/index.js";
@@ -21,14 +21,13 @@ import { CategorySpec } from "./models/category.model.js";
 import { ProductSpec } from "./models/product.model.js";
 import { ProductWithCategoryPublicSpec, ProductWithCategorySpec, } from "./models/product-with-category.model.js";
 import { TestEmailClient } from "./test-email-client.js";
-import { getTestOrgUser } from "./test-objects.js";
 let deviceIdCookie;
 let database;
 let organizationService;
 let userService;
 const JWT_SECRET = "test-secret";
 const newUser1Email = "one@test.com";
-const newUser1Password = "testone";
+const newUser1Password = "testone1";
 const constDeviceIdCookie = crypto.randomBytes(16).toString("hex");
 function initialize(db) {
     database = db;
@@ -135,16 +134,37 @@ async function deleteTestUser() {
     if (!organizationService || !userService) {
         return;
     }
-    await userService
-        .deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id)
-        .catch((error) => {
-        console.log("Error deleting test user:", error);
-    });
-    await organizationService
-        .deleteById(getTestMetaOrgUserContext(), getTestOrg()._id)
-        .catch((error) => {
-        console.log("Error deleting test organization:", error);
-    });
+    const systemUserContext = getSystemUserContext();
+    const metaOrgUser = await userService
+        .findOne(systemUserContext, {
+        filters: { email: { eq: getTestMetaOrgUser().email.toLowerCase() } },
+    })
+        .catch(() => null);
+    if (metaOrgUser) {
+        await userService
+            .deleteById(systemUserContext, metaOrgUser._id)
+            .catch(() => { });
+    }
+    const testOrgUser = await userService
+        .findOne(systemUserContext, {
+        filters: { email: { eq: getTestOrgUser().email.toLowerCase() } },
+    })
+        .catch(() => null);
+    if (testOrgUser) {
+        await userService
+            .deleteById(systemUserContext, testOrgUser._id)
+            .catch(() => { });
+    }
+    const testOrg = await organizationService
+        .findOne(EmptyUserContext, {
+        filters: { code: { eq: getTestOrg().code } },
+    })
+        .catch(() => null);
+    if (testOrg) {
+        await organizationService
+            .deleteById(getTestMetaOrgUserContext(), testOrg._id)
+            .catch(() => { });
+    }
 }
 async function simulateloginWithTestUser() {
     const req = {
@@ -164,7 +184,7 @@ async function simulateloginWithTestUser() {
     if (!database) {
         throw new Error("Database not initialized. Call initialize() first.");
     }
-    const loginResponse = await attemptLogin(database, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD, deviceIdCookie, getTestMetaOrg()._id);
+    const loginResponse = await attemptLogin(database, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD, deviceIdCookie, getTestMetaOrg());
     if (!loginResponse?.tokens?.accessToken) {
         throw new Error("Failed to login with test user");
     }
@@ -331,17 +351,17 @@ export class MultiTenantProductsController extends ApiController {
 }
 function configureJwtSecret() {
     const originalJwtVerify = jwt.verify;
-    jwt.verify = function (token, secret, options) {
-        return originalJwtVerify(token, JWT_SECRET, options);
-    };
+    jwt.verify = (token, _secret, options) => originalJwtVerify(token, JWT_SECRET, options);
 }
 async function loginWithTestUser(agent) {
     agent.set("Cookie", [`deviceId=${deviceIdCookie}`]);
     const testUser = getTestMetaOrgUser();
-    const response = await agent.post("/api/auth/login").send({
+    const response = await agent
+        .post("/api/auth/login")
+        .set("Referer", getTestMetaOrgRefererUrl())
+        .send({
         email: testUser.email,
         password: testUser.password,
-        organizationId: testUser._orgId,
     });
     if (!response.body?.data?.tokens?.accessToken) {
         console.error("Login failed:", response.body);
@@ -368,8 +388,9 @@ const testUtils = {
     deleteMetaOrg,
     deleteTestUser,
     getAuthToken,
+    getTestMetaOrgRefererUrl,
     initialize,
-    SetupTestConfig: setupTestConfig,
+    setupTestConfig,
     loginWithTestUser,
     newUser1Email,
     newUser1Password,

package/dist/__tests__/test-express-app.d.ts

@@ -1,19 +1,20 @@
-import { Application } from 'express';
-import { ITestDatabase } from './test-database.interface.js';
-import { IDatabase } from '../databases/models/database.interface.js';
-export declare class TestExpressApp {
-    private static app;
-    private static database;
-    private static testDatabase;
-    private static initPromise;
-    static init(useMongoDb?: boolean): Promise<{
-        app: Application;
-        database: IDatabase;
-        testDatabase: ITestDatabase;
-        agent: any;
-    }>;
-    private static _performInit;
-    static setupErrorHandling(): Promise<void>;
-    static clearCollections(): Promise<void>;
-    static cleanup(): Promise<void>;
-}
+import { type Application } from "express";
+import type { IDatabase } from "../databases/models/database.interface.js";
+import type { ITestDatabase } from "./test-database.interface.js";
+type TestExpressAppInitResult = {
+    app: Application;
+    database: IDatabase;
+    testDatabase: ITestDatabase;
+    agent: any;
+};
+declare function init(useMongoDb?: boolean): Promise<TestExpressAppInitResult>;
+declare function setupErrorHandling(): Promise<void>;
+declare function clearCollections(): Promise<void>;
+declare function cleanup(): Promise<void>;
+export declare const TestExpressApp: {
+    init: typeof init;
+    setupErrorHandling: typeof setupErrorHandling;
+    clearCollections: typeof clearCollections;
+    cleanup: typeof cleanup;
+};
+export {};

package/dist/__tests__/test-express-app.js

@@ -1,76 +1,80 @@
-import express from 'express';
-import bodyParser from 'body-parser';
-import cookieParser from 'cookie-parser';
-import supertest from 'supertest';
-import { initializeTypeBox } from '@loomcore/common/validation';
-import { errorHandler } from '../middleware/error-handler.js';
-import { ensureUserContext } from '../middleware/ensure-user-context.js';
-import { TestMongoDatabase } from './mongo-db.test-database.js';
-import { TestPostgresDatabase } from './postgres.test-database.js';
-import { setupTestConfig } from './common-test.utils.js';
-export class TestExpressApp {
-    static app;
-    static database;
-    static testDatabase;
-    static initPromise = null;
-    static async init(useMongoDb) {
-        if (useMongoDb === undefined) {
-            const testDb = process.env.TEST_DATABASE;
-            useMongoDb = testDb === 'mongodb';
-        }
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = this._performInit(useMongoDb);
-        return this.initPromise;
+import { initializeTypeBox } from "@loomcore/common/validation";
+import bodyParser from "body-parser";
+import cookieParser from "cookie-parser";
+import express from "express";
+import supertest from "supertest";
+import { ensureUserContext } from "../middleware/ensure-user-context.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { setupTestConfig } from "./common-test.utils.js";
+import { TestMongoDatabase } from "./mongo-db.test-database.js";
+import { TestPostgresDatabase } from "./postgres.test-database.js";
+let app;
+let database;
+let testDatabase;
+let initPromise = null;
+async function init(useMongoDb) {
+    if (useMongoDb === undefined) {
+        const testDb = process.env.TEST_DATABASE;
+        useMongoDb = testDb === "mongodb";
+    }
+    if (initPromise) {
+        return initPromise;
     }
-    static async _performInit(useMongoDb) {
-        setupTestConfig(true, useMongoDb ? 'mongodb' : 'postgres');
-        initializeTypeBox();
-        if (!this.database) {
-            if (useMongoDb) {
-                const testMongoDb = new TestMongoDatabase();
-                this.testDatabase = testMongoDb;
-                this.database = await testMongoDb.init();
-            }
-            else {
-                const testPostgresDb = new TestPostgresDatabase();
-                this.testDatabase = testPostgresDb;
-                this.database = await testPostgresDb.init();
-            }
+    initPromise = performInit(useMongoDb);
+    return initPromise;
+}
+async function performInit(useMongoDb) {
+    setupTestConfig(true, useMongoDb ? "mongodb" : "postgres");
+    initializeTypeBox();
+    if (!database) {
+        if (useMongoDb) {
+            const testMongoDb = new TestMongoDatabase();
+            testDatabase = testMongoDb;
+            database = await testMongoDb.init();
         }
-        if (!this.app) {
-            this.app = express();
-            this.app.use(bodyParser.json());
-            this.app.use(cookieParser());
-            this.app.use(ensureUserContext);
-            this.app.use((req, res, next) => {
-                next();
-            });
+        else {
+            const testPostgresDb = new TestPostgresDatabase();
+            testDatabase = testPostgresDb;
+            database = await testPostgresDb.init();
         }
-        const agent = supertest.agent(this.app);
-        return {
-            app: this.app,
-            database: this.database,
-            testDatabase: this.testDatabase,
-            agent
-        };
     }
-    static async setupErrorHandling() {
-        this.app.use(errorHandler);
+    if (!app) {
+        app = express();
+        app.use(bodyParser.json());
+        app.use(cookieParser());
+        app.use(ensureUserContext);
+        app.use((req, res, next) => {
+            next();
+        });
     }
-    static async clearCollections() {
-        if (this.testDatabase) {
-            await this.testDatabase.clearCollections();
-        }
+    const agent = supertest.agent(app);
+    return {
+        app,
+        database,
+        testDatabase,
+        agent,
+    };
+}
+async function setupErrorHandling() {
+    app.use(errorHandler);
+}
+async function clearCollections() {
+    if (testDatabase) {
+        await testDatabase.clearCollections();
     }
-    static async cleanup() {
-        if (this.testDatabase) {
-            await this.testDatabase.cleanup();
-        }
-        this.initPromise = null;
-        this.app = undefined;
-        this.database = undefined;
-        this.testDatabase = undefined;
+}
+async function cleanup() {
+    if (testDatabase) {
+        await testDatabase.cleanup();
     }
+    initPromise = null;
+    app = undefined;
+    database = undefined;
+    testDatabase = undefined;
 }
+export const TestExpressApp = {
+    init,
+    setupErrorHandling,
+    clearCollections,
+    cleanup,
+};

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

@@ -4,6 +4,11 @@ export declare let TEST_META_ORG_USER_ID: string | number;
 export declare function setTestMetaOrgId(metaOrgId: string | number): void;
 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 getTestMetaOrgRefererUrl(): string;
+export declare function getTestOrgRefererUrl(): string;
 export declare function getTestMetaOrg(): IOrganization;
 export declare function getTestMetaOrgUser(): IUser;
 export declare function getTestMetaOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -7,11 +7,26 @@ export function setTestMetaOrgUserId(userId) {
     TEST_META_ORG_USER_ID = 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) {
+        throw new Error("Organization domain is required for auth referer URL");
+    }
+    return `https://${org.domain}`;
+}
+export function getTestMetaOrgRefererUrl() {
+    return getRefererUrlForOrg(getTestMetaOrg());
+}
+export function getTestOrgRefererUrl() {
+    return getRefererUrlForOrg(getTestOrg());
+}
 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(),
@@ -58,6 +73,7 @@ export function getTestOrg() {
         _id: TEST_ORG_ID,
         name: "Test Organization",
         code: "test-org",
+        domain: TEST_ORG_DOMAIN,
         status: 1,
         isMetaOrg: false,
         _created: new Date(),

package/dist/config/base-api-config.d.ts

@@ -1,5 +1,5 @@
-import { IDatabase } from "../databases/models/index.js";
-import { IBaseApiConfig } from "../models/index.js";
+import type { IDatabase } from "../databases/models/index.js";
+import type { IBaseApiConfig } from "../models/index.js";
 export declare let config: IBaseApiConfig;
 export declare function setBaseApiConfig(theConfig: IBaseApiConfig): void;
 export declare function initSystemUserContext(database: IDatabase): Promise<void>;

package/dist/config/base-api-config.js

@@ -36,7 +36,7 @@ export async function initSystemUserContext(database) {
     }
     if (!isSystemUserContextSet) {
         const systemEmail = config.email?.systemEmailAddress || "system@example.com";
-        let metaOrg = undefined;
+        let metaOrg = null;
         if (config.app.isMultiTenant) {
             const { OrganizationService } = await import("../services/organization.service.js");
             const organizationService = new OrganizationService(database);
@@ -45,7 +45,7 @@ export async function initSystemUserContext(database) {
                 throw new Error("Meta organization not found. Please create an organization with isMetaOrg=true before starting the API.");
             }
         }
-        initializeSystemUserContext(systemEmail, metaOrg);
+        initializeSystemUserContext(systemEmail, metaOrg ?? undefined);
         isSystemUserContextSet = true;
     }
     else if (config.env !== "test") {

package/dist/controllers/auth.controller.d.ts

@@ -8,7 +8,6 @@ export declare class AuthController {
     constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
     login(req: Request, res: Response): Promise<void>;
-    registerUser(req: Request, res: Response): Promise<void>;
     requestTokenUsingRefreshToken(req: Request, res: Response): Promise<void>;
     getUserContext(req: Request, res: Response): Promise<void>;
     afterAuth(_req: Request, _res: Response, _loginResponse: any): void;

package/dist/controllers/auth.controller.js

@@ -1,7 +1,7 @@
-import { EmptyUserContext, LoginResponseSpec, PublicUserContextSpec, PublicUserSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
+import { EmptyUserContext, LoginResponseSpec, PublicUserContextSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
 import { entityUtils } from "@loomcore/common/utils";
 import { config } from "../config/base-api-config.js";
-import { BadRequestError, ServerError, UnauthenticatedError, } from "../errors/index.js";
+import { BadRequestError, UnauthenticatedError } from "../errors/index.js";
 import { isAuthorized } from "../middleware/index.js";
 import { OrganizationService, UserService } from "../services/index.js";
 import { attemptLogin, changePassword, getAndSetDeviceIdCookie, getDeviceIdFromCookie, requestTokenUsingRefreshToken, resetPassword, sendResetPasswordEmail, } from "../utils/auth/index.js";
@@ -18,7 +18,6 @@ export class AuthController {
     }
     mapRoutes(app) {
         app.post(`/api/auth/login`, this.login.bind(this), this.afterAuth.bind(this));
-        app.post(`/api/auth/register`, isAuthorized(), this.registerUser.bind(this));
         app.get(`/api/auth/refresh`, this.requestTokenUsingRefreshToken.bind(this));
         app.get(`/api/auth/get-user-context`, isAuthorized(), this.getUserContext.bind(this));
         app.patch(`/api/auth/change-password`, isAuthorized(), this.changePassword.bind(this));
@@ -26,35 +25,31 @@ export class AuthController {
         app.post(`/api/auth/reset-password`, this.resetPassword.bind(this));
     }
     async login(req, res) {
-        const { email, password, organizationId } = req.body;
+        const { email, password } = req.body;
         if (!email || typeof email !== "string") {
             throw new BadRequestError("Missing required fields: email is required.");
         }
         if (!password || typeof password !== "string") {
             throw new BadRequestError("Missing required fields: password is required.");
         }
-        if (config.app.isMultiTenant && !organizationId) {
-            throw new BadRequestError("Missing required fields: organizationId is required.");
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            const referer = req.get("referer") || req.headers.referer;
+            if (!referer) {
+                throw new BadRequestError("Missing required fields: referer is required.");
+            }
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
         }
         res.set("Content-Type", "application/json");
         const deviceId = getAndSetDeviceIdCookie(req, res);
-        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organizationId);
+        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organization);
         apiUtils.apiResponse(res, 200, { data: loginResponse }, LoginResponseSpec);
     }
-    async registerUser(req, res) {
-        const userContext = req.userContext;
-        if (!userContext) {
-            throw new BadRequestError("Missing required fields: userContext is required.");
-        }
-        const body = req.body;
-        const validationErrors = this.userService.validate(body.user);
-        entityUtils.handleValidationResult(validationErrors, "AuthController.registerUser");
-        const user = await this.userService.create(userContext, body.user);
-        if (!user) {
-            throw new ServerError("Failed to create user");
-        }
-        apiUtils.apiResponse(res, 201, { data: user }, UserSpec, PublicUserSpec);
-    }
     async requestTokenUsingRefreshToken(req, res) {
         const userContext = req.userContext;
         if (!userContext) {
@@ -91,23 +86,23 @@ export class AuthController {
     }
     async forgotPassword(req, res) {
         const email = req.body?.email;
-        const organizationId = req.body?.organizationId;
         if (!email || typeof email !== "string") {
             throw new BadRequestError("Missing required fields: email is required.");
         }
-        if (config.app.isMultiTenant && !organizationId) {
-            throw new BadRequestError("Missing required fields: organizationId is required.");
-        }
         let referer = req.get("referer") || req.headers.referer;
         if (!referer) {
             throw new BadRequestError("Missing required fields: referer is required.");
         }
         referer = referer.replace(/\/$/, "");
-        const organization = organizationId
-            ? await this.organizationService.findOne(EmptyUserContext, {
-                filters: { _id: { eq: organizationId } },
-            })
-            : null;
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
+        }
         const userContext = {
             ...EmptyUserContext,
             organization: organization || undefined,
@@ -121,14 +116,24 @@ export class AuthController {
         apiUtils.apiResponse(res, 200);
     }
     async resetPassword(req, res) {
-        const { email, token, password, organizationId, } = req.body;
+        const { email, token, password } = req.body;
         if (!email || !token || !password) {
             throw new BadRequestError("Missing required fields: email, token, and password are required.");
         }
-        if (config.app.isMultiTenant && !organizationId) {
-            throw new BadRequestError("Missing required fields: organizationId is required.");
+        let organization = null;
+        if (config.app.isMultiTenant) {
+            const referer = req.get("referer") || req.headers.referer;
+            if (!referer) {
+                throw new BadRequestError("Missing required fields: referer is required.");
+            }
+            organization = await this.organizationService.findOne(EmptyUserContext, {
+                filters: { domain: { eq: referer.split("/")[2] } },
+            });
+            if (!organization) {
+                throw new BadRequestError("Missing required fields: organization is required.");
+            }
         }
-        const response = await resetPassword(this.database, email, token, password, organizationId);
+        const response = await resetPassword(this.database, email, token, password, organization);
         apiUtils.apiResponse(res, 200, { data: response });
     }
 }

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

@@ -1,4 +1,5 @@
 import { Umzug } from 'umzug';
+import { TEST_META_ORG_DOMAIN } from '../../../../__tests__/test-objects.js';
 import { getPostgresInitialSchema } from '../postgres-initial-schema.js';
 import { getPostgresTestSchema } from '../../../../__tests__/postgres-test-migrations/postgres-test-schema.js';
 export async function runInitialSchemaMigrations(pool, config) {
@@ -7,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' } : { metaOrgName: '', metaOrgCode: '' }),
+        multiTenant: config.multiTenant ?? (config.app.isMultiTenant ? { metaOrgName: 'Test Meta Organization', metaOrgCode: 'TEST_META_ORG', metaOrgDomain: TEST_META_ORG_DOMAIN } : { metaOrgName: '', metaOrgCode: '', metaOrgDomain: '' }),
         email: config.email,
     };
     const initialSchema = getPostgresInitialSchema(migrationConfig);

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

@@ -33,7 +33,8 @@ export const getPostgresInitialSchema = (dbConfig) => {
           CREATE TABLE IF NOT EXISTS "organizations" (
             "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
             "name" VARCHAR(255) NOT NULL UNIQUE,
-            "code" 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,
@@ -297,12 +298,13 @@ export const getPostgresInitialSchema = (dbConfig) => {
             name: "00000000000011_data-meta-org",
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
-          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"
-          `, [
+					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"
+					`, [
                     dbConfig.multiTenant?.metaOrgName,
                     dbConfig.multiTenant?.metaOrgCode,
+                    dbConfig.multiTenant?.metaOrgDomain,
                 ]);
                 if (result.rowCount === 0) {
                     throw new Error("Failed to create meta organization");

package/dist/middleware/index.d.ts

@@ -1,4 +1,4 @@
-export * from './error-handler.js';
-export * from './is-authorized.js';
-export * from './ensure-user-context.js';
-export * from './request-lifecycle.js';
+export * from "./ensure-user-context.js";
+export * from "./error-handler.js";
+export * from "./is-authorized.js";
+export * from "./request-lifecycle.js";

package/dist/middleware/index.js

@@ -1,4 +1,4 @@
-export * from './error-handler.js';
-export * from './is-authorized.js';
-export * from './ensure-user-context.js';
-export * from './request-lifecycle.js';
+export * from "./ensure-user-context.js";
+export * from "./error-handler.js";
+export * from "./is-authorized.js";
+export * from "./request-lifecycle.js";

package/dist/models/app-config.interface.d.ts

@@ -1,4 +1,4 @@
-import { DbType } from "../databases/db-type.type.js";
+import type { DbType } from "../databases/db-type.type.js";
 export interface IAppConfig {
     dbType: DbType;
     isMultiTenant: boolean;

package/dist/models/base-api-config.interface.d.ts

@@ -1,8 +1,8 @@
-import { IAppConfig } from "./app-config.interface.js";
-import { IAuthConfig } from "./auth-config.interface.js";
-import { IDatabaseConfig } from "./database-config.interface.js";
-import { IEmailConfig } from "./email-config.interface.js";
-import { IEmailClient } from "./email-client.interface.js";
+import type { IAppConfig } from "./app-config.interface.js";
+import type { IAuthConfig } from "./auth-config.interface.js";
+import type { IDatabaseConfig } from "./database-config.interface.js";
+import type { IEmailClient } from "./email-client.interface.js";
+import type { IEmailConfig } from "./email-config.interface.js";
 export interface IBaseApiConfig {
     app: IAppConfig;
     auth?: IAuthConfig;

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

@@ -1,6 +1,6 @@
-import { IAppConfig } from "./app-config.interface.js";
-import { IDatabaseConfig } from "./database-config.interface.js";
-import { IEmailConfig } from "./email-config.interface.js";
+import type { IAppConfig } from "./app-config.interface.js";
+import type { IDatabaseConfig } from "./database-config.interface.js";
+import type { IEmailConfig } from "./email-config.interface.js";
 export interface IInitialDbMigrationConfig {
     env: string;
     app: IAppConfig;
@@ -12,6 +12,7 @@ export interface IInitialDbMigrationConfig {
     multiTenant: {
         metaOrgName: string;
         metaOrgCode: string;
+        metaOrgDomain: string;
     };
     email?: IEmailConfig;
 }

package/dist/utils/auth/attempt-login.util.d.ts

@@ -1,4 +1,3 @@
-import { type ILoginResponse } from "@loomcore/common/models";
-import type { AppIdType } from "@loomcore/common/types";
+import { type ILoginResponse, type IOrganization } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
-export declare function attemptLogin(database: IDatabase, email: string, password: string, deviceId: string, organizationId?: AppIdType): Promise<ILoginResponse | null>;
+export declare function attemptLogin(database: IDatabase, email: string, password: string, deviceId: string, organization: IOrganization | null): Promise<ILoginResponse | null>;

package/dist/utils/auth/attempt-login.util.js

@@ -1,20 +1,10 @@
 import { EmptyUserContext, } from "@loomcore/common/models";
 import { BadRequestError } from "../../errors/index.js";
-import { OrganizationService } from "../../services/organization.service.js";
 import { UserService } from "../../services/user.service.js";
 import { getUserContextAuthorizations } from "../../services/utils/getUserContextAuthorizations.util.js";
 import { passwordUtils } from "../password.utils.js";
 import { logUserIn } from "./log-user-in.util.js";
-export async function attemptLogin(database, email, password, deviceId, organizationId) {
-    const organizationService = new OrganizationService(database);
-    const organization = organizationId
-        ? await organizationService.findOne(EmptyUserContext, {
-            filters: { _id: { eq: organizationId } },
-        })
-        : null;
-    if (organizationId && !organization) {
-        throw new BadRequestError("Invalid Credentials");
-    }
+export async function attemptLogin(database, email, password, deviceId, organization) {
     const lowerCaseEmail = email.toLowerCase();
     const userContext = {
         ...EmptyUserContext,

package/dist/utils/auth/reset-password.util.d.ts

@@ -1,4 +1,4 @@
-import type { AppIdType } from "@loomcore/common/types";
+import { type IOrganization } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
 import type { UpdateResult } from "../../databases/models/update-result.js";
-export declare function resetPassword(database: IDatabase, email: string, passwordResetToken: string, password: string, organizationId?: AppIdType): Promise<UpdateResult>;
+export declare function resetPassword(database: IDatabase, email: string, passwordResetToken: string, password: string, organization: IOrganization | null): Promise<UpdateResult>;

package/dist/utils/auth/reset-password.util.js

@@ -1,26 +1,15 @@
 import { EmptyUserContext, passwordValidator, UserSpec, } from "@loomcore/common/models";
 import { entityUtils } from "@loomcore/common/utils";
-import { config } from "../../config/base-api-config.js";
 import { BadRequestError, ServerError } from "../../errors/index.js";
-import { OrganizationService } from "../../services/organization.service.js";
 import { PasswordResetTokenService } from "../../services/password-reset-token.service.js";
 import { UserService } from "../../services/user.service.js";
 import { changePassword } from "./change-password.util.js";
-export async function resetPassword(database, email, passwordResetToken, password, organizationId) {
+export async function resetPassword(database, email, passwordResetToken, password, organization) {
     const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
     entityUtils.handleValidationResult(validationErrors, "AuthService.resetPassword");
-    if (config.app.isMultiTenant && !organizationId) {
-        throw new BadRequestError("Missing required fields: organizationId is required.");
-    }
     const lowerCaseEmail = email.toLowerCase();
-    const organizationService = new OrganizationService(database);
     const passwordResetTokenService = new PasswordResetTokenService(database);
     const userService = new UserService(database);
-    const organization = organizationId
-        ? await organizationService.findOne(EmptyUserContext, {
-            filters: { _id: { eq: organizationId } },
-        })
-        : null;
     const userContext = {
         ...EmptyUserContext,
         organization: organization ?? undefined,

package/dist/utils/auth/send-reset-password-email.util.d.ts

@@ -1,3 +1,3 @@
-import type { AppIdType } from "@loomcore/common/types";
+import { type IOrganization } from "@loomcore/common/models";
 import type { IDatabase } from "../../databases/models/index.js";
-export declare function sendResetPasswordEmail(database: IDatabase, emailAddress: string, clientBaseUrl: string, organizationId?: AppIdType): Promise<void>;
+export declare function sendResetPasswordEmail(database: IDatabase, emailAddress: string, clientBaseUrl: string, organization?: IOrganization): Promise<void>;

package/dist/utils/auth/send-reset-password-email.util.js

@@ -1,20 +1,13 @@
 import { EmptyUserContext, } from "@loomcore/common/models";
 import { ServerError } from "../../errors/index.js";
 import { EmailService } from "../../services/email.service.js";
-import { OrganizationService } from "../../services/organization.service.js";
 import { PasswordResetTokenService } from "../../services/password-reset-token.service.js";
 import { getAuthConfig } from "./get-auth-config.util.js";
 import { getExpiresOnFromMinutes } from "./get-expires-on-from-minutes.util.js";
-export async function sendResetPasswordEmail(database, emailAddress, clientBaseUrl, organizationId) {
+export async function sendResetPasswordEmail(database, emailAddress, clientBaseUrl, organization) {
     const authConfig = getAuthConfig();
-    const organizationService = new OrganizationService(database);
     const passwordResetTokenService = new PasswordResetTokenService(database);
     const emailService = new EmailService();
-    const organization = organizationId
-        ? await organizationService.findOne(EmptyUserContext, {
-            filters: { _id: { eq: organizationId } },
-        })
-        : null;
     const userContext = {
         ...EmptyUserContext,
         organization: organization ?? undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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.72",
+    "@loomcore/common": "^0.0.74",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",