@loomcore/api 0.2.7 → 0.2.9

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

@@ -1,15 +1,16 @@
-import { IQueryOptions, IUser, IUserContext } from "@loomcore/common/models";
-import { Application, NextFunction, Request, Response } from "express";
+import { type IQueryOptions, type IUser, type IUserContext } from "@loomcore/common/models";
+import type { Application, NextFunction, Request, Response } from "express";
 import { ApiController } from "../controllers/api.controller.js";
-import { IDatabase } from "../databases/models/index.js";
-import { Operation } from "../databases/operations/operation.js";
+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";
 import { type IProductWithCategory } from "./models/product-with-category.model.js";
-declare function initialize(database: IDatabase): void;
+declare function initialize(db: IDatabase): void;
 declare function getRandomId(): string;
 declare function isMongoDatabase(database: IDatabase): boolean;
 declare function isPostgresDatabase(database: IDatabase): boolean;
@@ -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,37 +1,38 @@
-import { EmptyUserContext, } from "@loomcore/common/models";
+import crypto from "node:crypto";
+import { EmptyUserContext, getSystemUserContext, } from "@loomcore/common/models";
 import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import crypto from "crypto";
 import jwt from "jsonwebtoken";
 import { ObjectId } from "mongodb";
 import { ApiController } from "../controllers/api.controller.js";
 import { MongoDBDatabase } from "../databases/mongo-db/mongo-db.database.js";
 import { LeftJoin } from "../databases/operations/left-join.operation.js";
 import { PostgresDatabase } from "../databases/postgres/postgres.database.js";
-import { AuthService, GenericApiService } from "../services/index.js";
-import { JwtService } from "../services/jwt.service.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 * 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";
 import { apiUtils } from "../utils/index.js";
 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 authService;
+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(database) {
-    authService = new AuthService(database);
-    organizationService = new OrganizationService(database);
+function initialize(db) {
+    database = db;
+    organizationService = new OrganizationService(db);
+    userService = new UserService(db);
     deviceIdCookie = constDeviceIdCookie;
 }
 function getRandomId() {
@@ -95,7 +96,7 @@ async function setupTestUsers() {
     }
 }
 async function createTestUsers() {
-    if (!authService || !organizationService) {
+    if (!organizationService || !userService) {
         throw new Error("Database not initialized. Call initialize() first.");
     }
     try {
@@ -115,8 +116,8 @@ async function createTestUsers() {
         else {
             setTestOrgId(existingTestOrg._id);
         }
-        const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser());
-        const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
+        const createdTestOrgUser = await userService.create(getTestOrgUserContext(), getTestOrgUser());
+        const createdMetaOrgUser = await userService.create(getTestMetaOrgUserContext(), getTestMetaOrgUser());
         if (!createdTestOrgUser || !createdMetaOrgUser) {
             throw new Error("Failed to create test user");
         }
@@ -130,39 +131,60 @@ async function createTestUsers() {
     }
 }
 async function deleteTestUser() {
-    if (!authService || !organizationService) {
+    if (!organizationService || !userService) {
         return;
     }
-    await authService
-        .deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id)
-        .catch((error) => {
-        return null;
-    });
-    await organizationService
-        .deleteById(getTestMetaOrgUserContext(), getTestOrg()._id)
-        .catch((error) => {
-        return null;
-    });
+    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 = {
         cookies: {},
     };
     if (deviceIdCookie) {
-        req.cookies["deviceId"] = deviceIdCookie;
+        req.cookies.deviceId = deviceIdCookie;
     }
     const res = {
-        cookie: function (name, value) {
+        cookie: (name, value) => {
             if (name === "deviceId") {
                 deviceIdCookie = value;
             }
             return res;
         },
     };
-    if (!authService) {
-        throw new Error("AuthService not initialized. Call initialize() first.");
+    if (!database) {
+        throw new Error("Database not initialized. Call initialize() first.");
     }
-    const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD);
+    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");
     }
@@ -170,11 +192,11 @@ async function simulateloginWithTestUser() {
 }
 function getAuthToken() {
     const userContext = getTestMetaOrgUserContext();
-    const token = JwtService.sign(userContext, JWT_SECRET, { expiresIn: 3600 });
+    const token = jwt.sign(userContext, JWT_SECRET, { expiresIn: 3600 });
     return `Bearer ${token}`;
 }
 function verifyToken(token) {
-    return JwtService.verify(token, JWT_SECRET);
+    return jwt.verify(token, JWT_SECRET);
 }
 export class CategoryService extends GenericApiService {
     constructor(database) {
@@ -329,14 +351,15 @@ 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,
     });
@@ -365,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

@@ -1,15 +1,16 @@
-import type { Application, NextFunction, Request, Response } from "express";
+import type { Application, Request, Response } from "express";
 import type { IDatabase } from "../databases/models/index.js";
-import { AuthService } from "../services/index.js";
+import { OrganizationService, UserService } from "../services/index.js";
 export declare class AuthController {
-    authService: AuthService;
+    database: IDatabase;
+    userService: UserService;
+    organizationService: OrganizationService;
     constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
-    login(req: Request, res: Response, next: NextFunction): Promise<void>;
-    registerUser(req: Request, res: Response): Promise<void>;
-    requestTokenUsingRefreshToken(req: Request, res: Response, next: NextFunction): Promise<void>;
-    getUserContext(req: Request, res: Response, next: NextFunction): Promise<void>;
-    afterAuth(req: Request, res: Response, loginResponse: any): void;
+    login(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;
     changePassword(req: Request, res: Response): Promise<void>;
     forgotPassword(req: Request, res: Response): Promise<void>;
     resetPassword(req: Request, res: Response): Promise<void>;