@loomcore/api 0.0.58 → 0.1.0

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

@@ -1,70 +1,41 @@
-import { ObjectId } from 'mongodb';
 import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
+import { getSystemUserContext } from '@loomcore/common/models';
 import { Type } from '@sinclair/typebox';
-import { TypeboxObjectId } from '@loomcore/common/validation';
 import { JwtService } from '../services/jwt.service.js';
-import { passwordUtils } from '../utils/password.utils.js';
-import { AuthService } from '../services/auth.service.js';
-import { GenericApiService } from '../services/generic-api.service.js';
 import { ApiController } from '../controllers/api.controller.js';
-import { entityUtils } from '@loomcore/common/utils';
 import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
-let db;
-let collections = {};
+import { Join } from '../databases/operations/join.operation.js';
+import { OrganizationService } from '../services/organization.service.js';
+import { IdNotFoundError } from '../errors/index.js';
+import { AuthService, GenericApiService } from '../services/index.js';
+import { ObjectId } from 'mongodb';
+import { testMetaOrg, testOrg, getTestUser, testUserContext } from './test-objects.js';
+import { CategorySpec } from './models/category.model.js';
+import { ProductSpec } from './models/product.model.js';
 let deviceIdCookie;
 let authService;
-let testUser;
+let organizationService;
 const JWT_SECRET = 'test-secret';
 const newUser1Email = 'one@test.com';
 const newUser1Password = 'testone';
-const testUserId = '67f33ed5b75090e0dda18a3c';
-const testOrgId = '67e8e19b149f740323af93d7';
-const testOrgName = 'Test Organization';
-const testUserEmail = 'test@example.com';
-const testUserEmailCaseInsensitive = 'tesT@example.com';
-const testUserPassword = 'testPassword';
 const constDeviceIdCookie = crypto.randomBytes(16).toString('hex');
-const testUserContext = {
-    user: {
-        _id: testUserId,
-        email: testUserEmail,
-        _created: new Date(),
-        _createdBy: 'system',
-        _updated: new Date(),
-        _updatedBy: 'system'
-    },
-    _orgId: testOrgId
-};
 function initialize(database) {
-    db = database;
-    collections = {
-        users: db.collection('users'),
-        organizations: db.collection('organizations'),
-    };
-    authService = new AuthService(db);
+    authService = new AuthService(database);
+    organizationService = new OrganizationService(database);
+    deviceIdCookie = constDeviceIdCookie;
 }
-async function createIndexes(db) {
-    await db.command({
-        createIndexes: "users", indexes: [{ key: { email: 1 }, name: 'email_index', unique: true, collation: { locale: 'en', strength: 1 } }]
-    });
+function getRandomId() {
+    return new ObjectId().toString();
 }
 async function createMetaOrg() {
-    if (!db || !collections.organizations) {
-        throw new Error('Database not initialized. Call initialize() first.');
+    if (!organizationService) {
+        throw new Error('OrganizationService not initialized. Call initialize() first.');
     }
     try {
-        const existingMetaOrg = await collections.organizations.findOne({ isMetaOrg: true });
+        const existingMetaOrg = await organizationService.findOne(testUserContext, { filters: { isMetaOrg: { eq: true } } });
         if (!existingMetaOrg) {
-            const metaOrgInsertResult = await collections.organizations.insertOne({
-                _id: new ObjectId(),
-                name: 'Meta Organization',
-                isMetaOrg: true,
-                _created: new Date(),
-                _createdBy: 'system',
-                _updated: new Date(),
-                _updatedBy: 'system'
-            });
+            const metaOrgInsertResult = await organizationService.create(testUserContext, testMetaOrg);
         }
     }
     catch (error) {
@@ -73,11 +44,11 @@ async function createMetaOrg() {
     }
 }
 async function deleteMetaOrg() {
-    if (!collections.organizations) {
+    if (!organizationService) {
         return Promise.resolve();
     }
     try {
-        await collections.organizations.deleteOne({ isMetaOrg: true });
+        await organizationService.deleteMany(testUserContext, { filters: { isMetaOrg: { eq: true } } });
     }
     catch (error) {
         console.log('Error deleting meta org:', error);
@@ -94,51 +65,44 @@ async function setupTestUser() {
     }
 }
 async function createTestUser() {
-    if (!db || !collections.users) {
+    if (!authService || !organizationService) {
         throw new Error('Database not initialized. Call initialize() first.');
     }
     try {
-        const hashedAndSaltedTestUserPassword = await passwordUtils.hashPassword(testUserPassword);
-        const existingOrg = await collections.organizations.findOne({ _id: testOrgId });
+        let existingOrg;
+        try {
+            existingOrg = await organizationService.getById(testUserContext, testOrg._id);
+        }
+        catch (error) {
+            if (error instanceof IdNotFoundError) {
+                existingOrg = null;
+            }
+            else {
+                throw error;
+            }
+        }
         if (!existingOrg) {
-            const orgInsertResult = await collections.organizations.insertOne({
-                _id: new ObjectId(testOrgId),
-                name: testOrgName,
-                _created: new Date(),
-                _createdBy: 'system',
-                _updated: new Date(),
-                _updatedBy: 'system'
-            });
+            await organizationService.create(testUserContext, testOrg);
+        }
+        const systemUserContext = getSystemUserContext();
+        const createdUser = await authService.createUser(systemUserContext, getTestUser());
+        if (!createdUser) {
+            throw new Error('Failed to create test user');
         }
-        const localTestUser = {
-            _id: new ObjectId(testUserId),
-            email: testUserEmail,
-            password: hashedAndSaltedTestUserPassword,
-            _orgId: testOrgId,
-            _created: new Date(),
-            _createdBy: 'system',
-            _updated: new Date(),
-            _updatedBy: 'system'
-        };
-        const insertResult = await collections.users.insertOne(localTestUser);
-        delete localTestUser['password'];
-        testUser = { ...localTestUser, _id: localTestUser._id.toString() };
-        return localTestUser;
+        return createdUser;
     }
     catch (error) {
         console.log('Error in createTestUser:', error);
         throw error;
     }
 }
-function deleteTestUser() {
-    let promises = [];
-    if (testUser) {
-        promises.push(collections.users.deleteOne({ _id: testUser._id }));
-    }
-    if (collections.organizations) {
-        promises.push(collections.organizations.deleteOne({ _id: new ObjectId(testOrgId) }));
-    }
-    return Promise.all(promises);
+async function deleteTestUser() {
+    await authService.deleteById(testUserContext, getTestUser()._id).catch((error) => {
+        return null;
+    });
+    await organizationService.deleteById(testUserContext, testOrg._id).catch((error) => {
+        return null;
+    });
 }
 async function simulateloginWithTestUser() {
     const req = {
@@ -155,7 +119,7 @@ async function simulateloginWithTestUser() {
             return res;
         }
     };
-    const loginResponse = await authService.attemptLogin(req, res, testUserEmail, testUserPassword);
+    const loginResponse = await authService.attemptLogin(req, res, getTestUser().email, getTestUser().password);
     if (!loginResponse?.tokens?.accessToken) {
         throw new Error('Failed to login with test user');
     }
@@ -164,10 +128,10 @@ async function simulateloginWithTestUser() {
 function getAuthToken() {
     const payload = {
         user: {
-            _id: new ObjectId(testUserId),
-            email: testUserEmail
+            _id: getTestUser()._id,
+            email: getTestUser().email
         },
-        _orgId: testOrgId
+        _orgId: testOrg._id
     };
     const token = JwtService.sign(payload, JWT_SECRET, { expiresIn: 3600 });
     return `Bearer ${token}`;
@@ -175,64 +139,41 @@ function getAuthToken() {
 function verifyToken(token) {
     return JwtService.verify(token, JWT_SECRET);
 }
-export const CategorySchema = Type.Object({
-    _id: Type.Optional(TypeboxObjectId()),
-    name: Type.String(),
-});
-export const CategorySpec = entityUtils.getModelSpec(CategorySchema);
-export const ProductSchema = Type.Object({
-    _id: Type.Optional(TypeboxObjectId()),
-    name: Type.String(),
-    description: Type.Optional(Type.String()),
-    internalNumber: Type.Optional(Type.String()),
-    categoryId: TypeboxObjectId({ title: 'Category ID' }),
-});
-export const ProductSpec = entityUtils.getModelSpec(ProductSchema, { isAuditable: true });
-export const PublicProductSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);
 export class CategoryService extends GenericApiService {
-    constructor(db) {
-        super(db, 'categories', 'category', CategorySpec);
+    constructor(database) {
+        super(database, 'categories', 'category', CategorySpec);
     }
 }
 export class CategoryController extends ApiController {
-    constructor(app, db) {
-        const categoryService = new CategoryService(db);
+    constructor(app, database) {
+        const categoryService = new CategoryService(database);
         super('categories', app, categoryService, 'category', CategorySpec);
     }
 }
 export class ProductService extends GenericApiService {
-    constructor(db) {
-        super(db, 'products', 'product', ProductSpec);
+    db;
+    constructor(database) {
+        super(database, 'products', 'product', ProductSpec);
+        this.db = database;
     }
-    getAdditionalPipelineStages() {
-        return [
-            {
-                $lookup: {
-                    from: 'categories',
-                    localField: 'categoryId',
-                    foreignField: '_id',
-                    as: 'category'
-                }
-            },
-            {
-                $unwind: {
-                    path: '$category',
-                    preserveNullAndEmptyArrays: true
-                }
-            }
+    prepareQuery(userContext, queryObject, operations) {
+        const newOperations = [
+            ...operations,
+            new Join('categories', 'categoryId', '_id', 'category')
         ];
+        return super.prepareQuery(userContext, queryObject, newOperations);
     }
-    transformSingle(single) {
+    postprocessEntity(userContext, single) {
         if (single && single.category) {
             const categoryService = new CategoryService(this.db);
-            single.category = categoryService.transformSingle(single.category);
+            single.category = categoryService.postprocessEntity(userContext, single.category);
         }
-        return super.transformSingle(single);
+        return super.postprocessEntity(userContext, single);
     }
 }
 export class ProductsController extends ApiController {
-    constructor(app, db) {
-        const productService = new ProductService(db);
+    constructor(app, database) {
+        const productService = new ProductService(database);
         const AggregatedProductSchema = Type.Intersect([
             ProductSpec.fullSchema,
             Type.Partial(Type.Object({
@@ -244,38 +185,29 @@ export class ProductsController extends ApiController {
     }
 }
 export class MultiTenantProductService extends MultiTenantApiService {
-    constructor(db) {
-        super(db, 'products', 'product', ProductSpec);
+    db;
+    constructor(database) {
+        super(database, 'products', 'product', ProductSpec);
+        this.db = database;
     }
-    getAdditionalPipelineStages() {
-        return [
-            {
-                $lookup: {
-                    from: 'categories',
-                    localField: 'categoryId',
-                    foreignField: '_id',
-                    as: 'category'
-                }
-            },
-            {
-                $unwind: {
-                    path: '$category',
-                    preserveNullAndEmptyArrays: true
-                }
-            }
+    prepareQuery(userContext, queryObject, operations) {
+        const newOperations = [
+            ...operations,
+            new Join('categories', 'categoryId', '_id', 'category')
         ];
+        return super.prepareQuery(userContext, queryObject, newOperations);
     }
-    transformSingle(single) {
+    postprocessEntity(userContext, single) {
         if (single && single.category) {
             const categoryService = new CategoryService(this.db);
-            single.category = categoryService.transformSingle(single.category);
+            single.category = categoryService.postprocessEntity(userContext, single.category);
         }
-        return super.transformSingle(single);
+        return super.postprocessEntity(userContext, single);
     }
 }
 export class MultiTenantProductsController extends ApiController {
-    constructor(app, db) {
-        const productService = new MultiTenantProductService(db);
+    constructor(app, database) {
+        const productService = new MultiTenantProductService(database);
         const AggregatedProductSchema = Type.Intersect([
             ProductSpec.fullSchema,
             Type.Partial(Type.Object({
@@ -286,9 +218,6 @@ export class MultiTenantProductsController extends ApiController {
         super('multi-tenant-products', app, productService, 'product', ProductSpec, PublicAggregatedProductSchema);
     }
 }
-function getTestUser() {
-    return testUser;
-}
 function configureJwtSecret() {
     const originalJwtVerify = jwt.verify;
     jwt.verify = function (token, secret, options) {
@@ -297,11 +226,12 @@ function configureJwtSecret() {
 }
 async function loginWithTestUser(agent) {
     agent.set('Cookie', [`deviceId=${deviceIdCookie}`]);
+    const testUser = getTestUser();
     const response = await agent
         .post('/api/auth/login')
         .send({
-        email: testUserEmail,
-        password: testUserPassword,
+        email: testUser.email,
+        password: testUser.password,
     });
     if (!response.body?.data?.tokens?.accessToken) {
         console.error('Login failed:', response.body);
@@ -320,28 +250,20 @@ async function cleanup() {
     }
 }
 const testUtils = {
+    getRandomId,
     cleanup,
     configureJwtSecret,
     constDeviceIdCookie,
-    createIndexes,
     createMetaOrg,
     deleteMetaOrg,
     deleteTestUser,
     getAuthToken,
-    getTestUser,
     initialize,
     loginWithTestUser,
     newUser1Email,
     newUser1Password,
     setupTestUser,
     simulateloginWithTestUser,
-    testUserContext,
-    testUserId,
-    testUserEmail,
-    testUserEmailCaseInsensitive,
-    testUserPassword,
-    testOrgId,
-    testOrgName,
     verifyToken
 };
 export default testUtils;

package/dist/__tests__/index.d.ts

@@ -0,0 +1,6 @@
+export * from './postgres-test-migrations/001-create-test-entities-table.migration.js';
+export * from './models/test-entity.model.js';
+export * from './postgres.test-database.js';
+export * from './mongo-db.test-database.js';
+export * from './test-express-app.js';
+export * from './test-database.interface.js';

package/dist/__tests__/index.js

@@ -0,0 +1,6 @@
+export * from './postgres-test-migrations/001-create-test-entities-table.migration.js';
+export * from './models/test-entity.model.js';
+export * from './postgres.test-database.js';
+export * from './mongo-db.test-database.js';
+export * from './test-express-app.js';
+export * from './test-database.interface.js';

package/dist/__tests__/models/category.model.d.ts

@@ -0,0 +1,8 @@
+import { IEntity } from "@loomcore/common/models";
+export interface ICategory extends IEntity {
+    name: string;
+}
+export declare const CategorySchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>;
+export declare const CategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/__tests__/models/category.model.js

@@ -0,0 +1,6 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const CategorySchema = Type.Object({
+    name: Type.String(),
+});
+export const CategorySpec = entityUtils.getModelSpec(CategorySchema);

package/dist/__tests__/models/mongo-test-entity.model.d.ts

@@ -0,0 +1,11 @@
+import { IAuditable, IEntity, IModelSpec } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+export declare const MongoTestEntitySchema: TSchema;
+export interface MongoTestEntity extends IEntity, IAuditable {
+    name: string;
+    description?: string;
+    isActive?: boolean;
+    tags?: string[];
+    count?: number;
+}
+export declare const mongoTestEntityModelSpec: IModelSpec;

package/dist/__tests__/models/mongo-test-entity.model.js

@@ -0,0 +1,13 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { TypeboxObjectId } from "@loomcore/common/validation";
+import { Type } from "@sinclair/typebox";
+export const MongoTestEntitySchema = Type.Object({
+    _id: TypeboxObjectId(),
+    _orgId: Type.Optional(TypeboxObjectId()),
+    name: Type.String({ minLength: 1 }),
+    description: Type.Optional(Type.String()),
+    isActive: Type.Optional(Type.Boolean()),
+    tags: Type.Optional(Type.Array(Type.String())),
+    count: Type.Optional(Type.Number())
+});
+export const mongoTestEntityModelSpec = entityUtils.getModelSpec(MongoTestEntitySchema, { isAuditable: true });

package/dist/__tests__/models/product.model.d.ts

@@ -0,0 +1,17 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+import { ICategory } from "./category.model.js";
+export interface IProduct extends IEntity, IAuditable {
+    name: string;
+    description?: string;
+    internalNumber?: string;
+    categoryId: string;
+    category?: ICategory;
+}
+export declare const ProductSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    internalNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    categoryId: import("@sinclair/typebox").TString;
+}>;
+export declare const ProductSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const PublicProductSchema: import("@sinclair/typebox").TObject<{}>;

package/dist/__tests__/models/product.model.js

@@ -0,0 +1,10 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const ProductSchema = Type.Object({
+    name: Type.String(),
+    description: Type.Optional(Type.String()),
+    internalNumber: Type.Optional(Type.String()),
+    categoryId: Type.String({ title: 'Category ID' }),
+});
+export const ProductSpec = entityUtils.getModelSpec(ProductSchema, { isAuditable: true });
+export const PublicProductSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);

package/dist/__tests__/models/test-entity.model.d.ts

@@ -0,0 +1,11 @@
+import { IAuditable, IEntity, IModelSpec } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+export declare const TestEntitySchema: TSchema;
+export interface TestEntity extends IEntity, IAuditable {
+    name: string;
+    description?: string;
+    isActive?: boolean;
+    tags?: string[];
+    count?: number;
+}
+export declare const testModelSpec: IModelSpec;

package/dist/__tests__/models/test-entity.model.js

@@ -0,0 +1,10 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const TestEntitySchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    description: Type.Optional(Type.String()),
+    isActive: Type.Optional(Type.Boolean()),
+    tags: Type.Optional(Type.Array(Type.String())),
+    count: Type.Optional(Type.Number())
+});
+export const testModelSpec = entityUtils.getModelSpec(TestEntitySchema, { isAuditable: true });

package/dist/__tests__/models/test-item.model.d.ts

@@ -0,0 +1,12 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+export interface ITestItem extends IEntity, IAuditable {
+    name: string;
+    value?: number;
+    eventDate?: Date;
+}
+export declare const TestItemSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    eventDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>, import("@sinclair/typebox").TUndefined]>>;
+}>;
+export declare const TestItemSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/__tests__/models/test-item.model.js

@@ -0,0 +1,9 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { TypeboxIsoDate } from "@loomcore/common/validation";
+import { Type } from "@sinclair/typebox";
+export const TestItemSchema = Type.Object({
+    name: Type.String(),
+    value: Type.Optional(Type.Number()),
+    eventDate: Type.Optional(TypeboxIsoDate())
+});
+export const TestItemSpec = entityUtils.getModelSpec(TestItemSchema, { isAuditable: true });

package/dist/__tests__/mongo-db.test-database.d.ts

@@ -0,0 +1,15 @@
+import { ITestDatabase } from './test-database.interface.js';
+import { IDatabase } from '../databases/models/index.js';
+export declare class TestMongoDatabase implements ITestDatabase {
+    private mongoServer;
+    private mongoClient;
+    private mongoDb;
+    private database;
+    private initPromise;
+    init(databaseName: string): Promise<IDatabase>;
+    getRandomId(): string;
+    private _performInit;
+    private createIndexes;
+    clearCollections(): Promise<void>;
+    cleanup(): Promise<void>;
+}

package/dist/__tests__/mongo-db.test-database.js

@@ -0,0 +1,74 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient, ObjectId } from 'mongodb';
+import testUtils from './common-test.utils.js';
+import { initSystemUserContext } from '../config/base-api-config.js';
+import { MongoDBDatabase } from '../databases/index.js';
+export class TestMongoDatabase {
+    mongoServer = null;
+    mongoClient = null;
+    mongoDb = null;
+    database = null;
+    initPromise = null;
+    async init(databaseName) {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performInit(databaseName);
+        return this.initPromise;
+    }
+    getRandomId() {
+        return new ObjectId().toString();
+    }
+    async _performInit(databaseName) {
+        if (!this.database) {
+            this.mongoServer = await MongoMemoryServer.create({
+                instance: {
+                    ip: '127.0.0.1',
+                    port: 0,
+                },
+                binary: {
+                    downloadDir: process.env.HOME ? `${process.env.HOME}/.cache/mongodb-binaries` : undefined,
+                }
+            });
+            const uri = this.mongoServer.getUri();
+            this.mongoClient = await MongoClient.connect(uri);
+            this.mongoDb = this.mongoClient.db();
+            const testDatabase = new MongoDBDatabase(this.mongoDb);
+            this.database = testDatabase;
+            testUtils.initialize(testDatabase);
+            await this.createIndexes(this.mongoDb);
+            await testUtils.createMetaOrg();
+        }
+        await initSystemUserContext(this.database);
+        return this.database;
+    }
+    async createIndexes(db) {
+        await db.command({
+            createIndexes: "users", indexes: [{ key: { email: 1 }, name: 'email_index', unique: true, collation: { locale: 'en', strength: 1 } }]
+        });
+    }
+    async clearCollections() {
+        if (!this.mongoDb) {
+            throw new Error('Database not initialized');
+        }
+        const collections = await this.mongoDb.collections();
+        for (const collection of collections) {
+            await collection.deleteMany({});
+        }
+    }
+    async cleanup() {
+        await testUtils.cleanup();
+        await this.clearCollections();
+        if (this.mongoClient) {
+            await this.mongoClient.close();
+        }
+        if (this.mongoServer) {
+            await this.mongoServer.stop();
+        }
+        this.initPromise = null;
+        this.mongoDb = null;
+        this.database = null;
+        this.mongoClient = null;
+        this.mongoServer = null;
+    }
+}

package/dist/__tests__/postgres-test-migrations/001-create-test-entities-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "../../databases/postgres/migrations/migration.interface.js";
+export declare class CreateTestEntitiesTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}