@loomcore/api 0.0.59 → 0.1.0

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

@@ -0,0 +1,81 @@
+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';
+export class TestMongoDb {
+    static mongoServer;
+    static client;
+    static db;
+    static initPromise = null;
+    static async init() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performInit();
+        return this.initPromise;
+    }
+    static getRandomId() {
+        return new ObjectId().toString();
+    }
+    static async _performInit() {
+        if (!this.db) {
+            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.client = await MongoClient.connect(uri);
+            this.db = this.client.db();
+            testUtils.initialize(this.db);
+            await this.createIndexes(this.db);
+            await testUtils.createMetaOrg();
+        }
+        await initSystemUserContext(this.db);
+        return this.db;
+    }
+    static async createIndexes(db) {
+        await db.command({
+            createIndexes: "users", indexes: [{ key: { email: 1 }, name: 'email_index', unique: true, collation: { locale: 'en', strength: 1 } }]
+        });
+    }
+    static getDb() {
+        if (!this.db) {
+            throw new Error('Database not initialized. Call init() first.');
+        }
+        return this.db;
+    }
+    static async clearCollections() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const collections = await this.db.collections();
+        for (const collection of collections) {
+            await collection.deleteMany({});
+        }
+    }
+    static async cleanup() {
+        await testUtils.cleanup();
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const collections = await this.db.collections();
+        for (const collection of collections) {
+            await collection.deleteMany({});
+        }
+        if (this.client) {
+            await this.client.close();
+        }
+        if (this.mongoServer) {
+            await this.mongoServer.stop();
+        }
+        this.initPromise = null;
+        this.db = undefined;
+        this.client = undefined;
+        this.mongoServer = undefined;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { IOrganization, IUser, IUserContext } from "@loomcore/common/models";
+export declare const testUser: IUser;
+export declare function getTestUser(): {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    displayName?: string;
+    password: string;
+    roles?: string[];
+    _lastLoggedIn?: Date;
+    _lastPasswordChange?: Date;
+    _created: Date;
+    _createdBy: string;
+    _updated: Date;
+    _updatedBy: string;
+    _deleted?: Date;
+    _deletedBy?: string;
+    _id: string;
+    _orgId?: string;
+};
+export declare const testUserContext: IUserContext;
+export declare const testMetaOrg: IOrganization;
+export declare const testOrg: IOrganization;

package/dist/__tests__/test-objects.js

@@ -0,0 +1,45 @@
+export const testUser = {
+    _id: '69261672f48fb7bf76e54dfb',
+    email: 'test@example.com',
+    password: 'testpassword',
+    firstName: 'Test',
+    lastName: 'User',
+    displayName: 'Test User',
+    roles: ['user'],
+    _orgId: '6926167d06c0073a778a124f',
+    _created: new Date(),
+    _createdBy: 'system',
+    _lastLoggedIn: new Date(),
+    _lastPasswordChange: new Date(),
+    _updated: new Date(),
+    _updatedBy: 'system',
+};
+export function getTestUser() {
+    return { ...testUser };
+}
+export const testUserContext = {
+    user: getTestUser(),
+    _orgId: '6926167d06c0073a778a124f'
+};
+export const testMetaOrg = {
+    _id: '69261691f936c45f85da24d0',
+    name: 'Test Meta Organization',
+    code: 'test-meta-org',
+    status: 1,
+    isMetaOrg: true,
+    _created: new Date(),
+    _createdBy: 'system',
+    _updated: new Date(),
+    _updatedBy: 'system',
+};
+export const testOrg = {
+    _id: '6926167d06c0073a778a124f',
+    name: 'Test Organization',
+    code: 'test-org',
+    status: 1,
+    isMetaOrg: false,
+    _created: new Date(),
+    _createdBy: 'system',
+    _updated: new Date(),
+    _updatedBy: 'system',
+};

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

@@ -0,0 +1,3 @@
+import { IUser, IUserContext } from "@loomcore/common/models";
+export declare const testUser: IUser;
+export declare const testUserContext: IUserContext;

package/dist/__tests__/test-user.js

@@ -0,0 +1,16 @@
+export const testUser = {
+    _id: '67f33ed5b75090e0dda18a3c',
+    email: 'test@example.com',
+    password: 'testpassword',
+    _orgId: '67e8e19b149f740323af93d7',
+    _created: new Date(),
+    _createdBy: 'system',
+    _updated: new Date(),
+    _updatedBy: 'system',
+    _deleted: undefined,
+    _deletedBy: undefined
+};
+export const testUserContext = {
+    user: testUser,
+    _orgId: '67e8e19b149f740323af93d7'
+};

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

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

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

@@ -18,7 +18,7 @@ export function setBaseApiConfig(apiConfig) {
         console.warn('BaseApiConfig data has already been set. Ignoring subsequent calls to setBaseApiConfig.');
     }
 }
-export async function initSystemUserContext(db) {
+export async function initSystemUserContext(database) {
     if (!isConfigSet) {
         throw new Error('BaseApiConfig has not been set. Call setBaseApiConfig first.');
     }
@@ -27,7 +27,7 @@ export async function initSystemUserContext(db) {
         let metaOrgId = undefined;
         if (config.app.isMultiTenant) {
             const { OrganizationService } = await import('../services/organization.service.js');
-            const organizationService = new OrganizationService(db);
+            const organizationService = new OrganizationService(database);
             const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
             if (!metaOrg) {
                 throw new Error('Meta organization not found. Please create an organization with isMetaOrg=true before starting the API.');

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

@@ -1,6 +1,6 @@
 import { Application, NextFunction, Request, Response } from 'express';
 import { TSchema } from '@sinclair/typebox';
-import { IEntity, IModelSpec, IUserContext } from '@loomcore/common/models';
+import { IEntity, IModelSpec } from '@loomcore/common/models';
 import { IGenericApiService } from '../services/index.js';
 export declare abstract class ApiController<T extends IEntity> {
     protected app: Application;
@@ -13,10 +13,6 @@ export declare abstract class ApiController<T extends IEntity> {
     mapRoutes(app: Application): void;
     protected validate(entity: any, isPartial?: boolean): void;
     protected validateMany(entities: any[], isPartial?: boolean): void;
-    protected prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
-    protected prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
-    protected prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
-    protected prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
     get(req: Request, res: Response, next: NextFunction): Promise<void>;
     getById(req: Request, res: Response, next: NextFunction): Promise<void>;

package/dist/controllers/api.controller.js

@@ -37,9 +37,6 @@ export class ApiController {
         const validationErrors = this.service.validateMany(entities, isPartial);
         entityUtils.handleValidationResult(validationErrors, `ApiController.validateMany for ${this.slug}`);
     }
-    async prepareDataForDb(userContext, entity, isCreate = false) {
-        return await this.service.prepareDataForDb(userContext, entity, isCreate);
-    }
     async getAll(req, res, next) {
         res.set('Content-Type', 'application/json');
         const entities = await this.service.getAll(req.userContext);
@@ -65,8 +62,7 @@ export class ApiController {
     async create(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body);
-        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, true);
-        const entity = await this.service.create(req.userContext, preparedEntity);
+        const entity = await this.service.create(req.userContext, req.body);
         apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSchema);
     }
     async batchUpdate(req, res, next) {
@@ -76,22 +72,19 @@ export class ApiController {
             throw new BadRequestError('Request body must be an array of entities.');
         }
         this.validateMany(entities, true);
-        const preparedEntities = await this.service.prepareDataForBatchUpdate(req.userContext, entities);
-        const updatedEntities = await this.service.batchUpdate(req.userContext, preparedEntities);
+        const updatedEntities = await this.service.batchUpdate(req.userContext, entities);
         apiUtils.apiResponse(res, 200, { data: updatedEntities }, this.modelSpec, this.publicSchema);
     }
     async fullUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body);
-        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, false);
-        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, preparedEntity);
+        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, req.body);
         apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
     }
     async partialUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
         this.validate(req.body, true);
-        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, false);
-        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, preparedEntity);
+        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, req.body);
         apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
     }
     async deleteById(req, res, next) {

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

@@ -1,9 +1,9 @@
 import { Application, Request, Response, NextFunction } from 'express';
-import { Db } from 'mongodb';
 import { AuthService } from '../services/index.js';
+import { IDatabase } from '../databases/models/index.js';
 export declare class AuthController {
     authService: AuthService;
-    constructor(app: Application, db: Db);
+    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>;

package/dist/controllers/auth.controller.js

@@ -1,4 +1,4 @@
-import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec, passwordValidator } from '@loomcore/common/models';
+import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec, passwordValidator, } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 import { isAuthenticated } from '../middleware/index.js';
@@ -6,8 +6,8 @@ import { apiUtils } from '../utils/index.js';
 import { AuthService } from '../services/index.js';
 export class AuthController {
     authService;
-    constructor(app, db) {
-        const authService = new AuthService(db);
+    constructor(app, database) {
+        const authService = new AuthService(database);
         this.authService = authService;
         this.mapRoutes(app);
     }
@@ -31,8 +31,7 @@ export class AuthController {
         const body = req.body;
         const validationErrors = this.authService.validate(body);
         entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
-        const preparedUser = await this.authService.prepareDataForDb(userContext, body, true);
-        const user = await this.authService.createUser(userContext, preparedUser);
+        const user = await this.authService.createUser(userContext, body);
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
     }
     async requestTokenUsingRefreshToken(req, res, next) {

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

@@ -1,11 +1,11 @@
 import { Application, NextFunction, Request, Response } from 'express';
-import { Db } from 'mongodb';
 import { IOrganization } from '@loomcore/common/models';
 import { ApiController } from './api.controller.js';
 import { OrganizationService } from '../services/index.js';
+import { IDatabase } from '../databases/models/index.js';
 export declare class OrganizationsController extends ApiController<IOrganization> {
     orgService: OrganizationService;
-    constructor(app: Application, db: Db);
+    constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
     getByName(req: Request, res: Response, next: NextFunction): Promise<void>;
     getByCode(req: Request, res: Response, next: NextFunction): Promise<void>;

package/dist/controllers/organizations.controller.js

@@ -5,8 +5,8 @@ import { BadRequestError } from '../errors/index.js';
 import { OrganizationService } from '../services/index.js';
 export class OrganizationsController extends ApiController {
     orgService;
-    constructor(app, db) {
-        const orgService = new OrganizationService(db);
+    constructor(app, database) {
+        const orgService = new OrganizationService(database);
         super('organizations', app, orgService);
         this.orgService = orgService;
     }
@@ -20,7 +20,7 @@ export class OrganizationsController extends ApiController {
         let name = req.params?.name;
         try {
             res.set('Content-Type', 'application/json');
-            const entity = await this.orgService.findOne(req.userContext, { name: { $regex: new RegExp(`^${name}$`, 'i') } });
+            const entity = await this.orgService.findOne(req.userContext, { filters: { name: { contains: name } } });
             if (!entity)
                 throw new BadRequestError('Name not found');
             apiUtils.apiResponse(res, 200, { data: entity });
@@ -34,7 +34,7 @@ export class OrganizationsController extends ApiController {
         let code = req.params?.code;
         try {
             res.set('Content-Type', 'application/json');
-            const entity = await this.orgService.findOne(req.userContext, { code: code });
+            const entity = await this.orgService.findOne(req.userContext, { filters: { code: { eq: code } } });
             if (!entity)
                 throw new BadRequestError('Code not found');
             apiUtils.apiResponse(res, 200, { data: entity });

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

@@ -1,9 +1,9 @@
-import { Db } from 'mongodb';
 import { Application } from 'express';
 import { IUser } from '@loomcore/common/models';
 import { ApiController } from './api.controller.js';
+import { IDatabase } from '../databases/models/index.js';
 export declare class UsersController extends ApiController<IUser> {
     private userService;
-    constructor(app: Application, db: Db);
+    constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
 }

package/dist/controllers/users.controller.js

@@ -4,8 +4,8 @@ import { isAuthenticated } from '../middleware/index.js';
 import { UserService } from '../services/index.js';
 export class UsersController extends ApiController {
     userService;
-    constructor(app, db) {
-        const userService = new UserService(db);
+    constructor(app, database) {
+        const userService = new UserService(database);
         super('users', app, userService, 'user', UserSpec, PublicUserSchema);
         this.userService = userService;
     }

package/dist/databases/index.d.ts

@@ -0,0 +1 @@
+export * from './mongo-db/index.js';

package/dist/databases/index.js

@@ -0,0 +1 @@
+export * from './mongo-db/index.js';

package/dist/databases/models/constants.d.ts

@@ -0,0 +1 @@
+export declare const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS: string[];

package/dist/databases/models/constants.js

@@ -0,0 +1 @@
+export const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS = ['_orgId'];

package/dist/databases/models/database.d.ts

@@ -0,0 +1,3 @@
+import { Db } from 'mongodb';
+import { Client } from 'pg';
+export type Database = Db | Client;

package/dist/databases/models/database.interface.d.ts

@@ -0,0 +1,28 @@
+import { IModelSpec, IQueryOptions, IPagedResult, IEntity } from "@loomcore/common/models";
+import { DeleteResult } from "./delete-result.js";
+import { TSchema } from "@sinclair/typebox";
+import { Operation } from "../operations/operation.js";
+export interface IDatabase {
+    preprocessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
+    postprocessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
+    getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    get<T extends IEntity>(operations: Operation[], queryOptions: IQueryOptions, modelSpec: IModelSpec, pluralResourceName: string): Promise<IPagedResult<T>>;
+    getById<T extends IEntity>(operations: Operation[], queryObject: IQueryOptions, id: string, pluralResourceName: string): Promise<T | null>;
+    getCount(pluralResourceName: string): Promise<number>;
+    create<T extends IEntity>(entity: Partial<T>, pluralResourceName: string): Promise<{
+        insertedId: string;
+        entity: T;
+    }>;
+    createMany<T extends IEntity>(entities: Partial<T>[], pluralResourceName: string): Promise<{
+        insertedIds: string[];
+        entities: T[];
+    }>;
+    batchUpdate<T extends IEntity>(entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    fullUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    partialUpdateById<T extends IEntity>(operations: Operation[], id: string, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+    update<T extends IEntity>(queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+    deleteById(id: string, pluralResourceName: string): Promise<DeleteResult>;
+    deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
+    find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+    findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
+}

package/dist/databases/models/delete-result.d.ts

@@ -0,0 +1,5 @@
+export declare class DeleteResult {
+    success: boolean;
+    count: number;
+    constructor(success: boolean, count: number);
+}

package/dist/databases/models/delete-result.js

@@ -0,0 +1,8 @@
+export class DeleteResult {
+    success;
+    count;
+    constructor(success, count) {
+        this.success = success;
+        this.count = count;
+    }
+}

package/dist/databases/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants.js';
+export * from './database.interface.js';
+export * from './database.js';
+export * from './delete-result.js';
+export * from './update-result.js';

package/dist/databases/models/index.js

@@ -0,0 +1,5 @@
+export * from './constants.js';
+export * from './database.interface.js';
+export * from './database.js';
+export * from './delete-result.js';
+export * from './update-result.js';

package/dist/databases/models/update-result.d.ts

@@ -0,0 +1,5 @@
+export declare class UpdateResult {
+    success: boolean;
+    count: number;
+    constructor(success: boolean, count: number);
+}

package/dist/databases/models/update-result.js

@@ -0,0 +1,8 @@
+export class UpdateResult {
+    success;
+    count;
+    constructor(success, count) {
+        this.success = success;
+        this.count = count;
+    }
+}

package/dist/databases/mongo-db/commands/batch-update.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function batchUpdate<T>(db: Db, entities: Partial<T>[], operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/mongo-db/commands/batch-update.command.js

@@ -0,0 +1,41 @@
+import { ObjectId } from "mongodb";
+import { BadRequestError } from "../../../errors/index.js";
+import { convertOperationsToPipeline } from "../utils/index.js";
+export async function batchUpdate(db, entities, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    if (!entities || entities.length === 0) {
+        return [];
+    }
+    const bulkOperations = [];
+    const entityIds = [];
+    for (const entity of entities) {
+        const { _id, ...updateData } = entity;
+        if (!_id || !(_id instanceof ObjectId)) {
+            throw new BadRequestError('Each entity in a batch update must have a valid _id that has been converted to an ObjectId.');
+        }
+        entityIds.push(_id);
+        bulkOperations.push({
+            updateOne: {
+                filter: { _id },
+                update: { $set: updateData },
+            },
+        });
+    }
+    if (bulkOperations.length > 0) {
+        await collection.bulkWrite(bulkOperations);
+    }
+    const baseQuery = { _id: { $in: entityIds } };
+    const operationsDocuments = convertOperationsToPipeline(operations);
+    let updatedEntities;
+    if (operationsDocuments.length > 0) {
+        const pipeline = [
+            { $match: baseQuery },
+            ...operationsDocuments
+        ];
+        updatedEntities = await collection.aggregate(pipeline).toArray();
+    }
+    else {
+        updatedEntities = await collection.find(baseQuery).toArray();
+    }
+    return updatedEntities;
+}

package/dist/databases/mongo-db/commands/create-many.command.d.ts

@@ -0,0 +1,5 @@
+import { Db } from "mongodb";
+export declare function createMany<T>(db: Db, pluralResourceName: string, entities: Partial<T>[]): Promise<{
+    insertedIds: any;
+    entities: any[];
+}>;

package/dist/databases/mongo-db/commands/create-many.command.js

@@ -0,0 +1,17 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+export async function createMany(db, pluralResourceName, entities) {
+    try {
+        const collection = db.collection(pluralResourceName);
+        const insertResult = await collection.insertMany(entities);
+        return {
+            insertedIds: insertResult.insertedIds,
+            entities: entities
+        };
+    }
+    catch (err) {
+        if (err.code === 11000) {
+            throw new DuplicateKeyError(`One or more ${pluralResourceName} already exist`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}`);
+    }
+}

package/dist/databases/mongo-db/commands/create.command.d.ts

@@ -0,0 +1,5 @@
+import { Db } from "mongodb";
+export declare function create<T>(db: Db, pluralResourceName: string, entity: any): Promise<{
+    insertedId: any;
+    entity: any;
+}>;

package/dist/databases/mongo-db/commands/create.command.js

@@ -0,0 +1,17 @@
+import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
+export async function create(db, pluralResourceName, entity) {
+    try {
+        const collection = db.collection(pluralResourceName);
+        const insertResult = await collection.insertOne(entity);
+        return {
+            insertedId: insertResult.insertedId,
+            entity: entity
+        };
+    }
+    catch (err) {
+        if (err.code === 11000) {
+            throw new DuplicateKeyError(`${pluralResourceName} already exists`);
+        }
+        throw new BadRequestError(`Error creating ${pluralResourceName}`);
+    }
+}

package/dist/databases/mongo-db/commands/delete-by-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+export declare function deleteById(db: Db, id: string, pluralResourceName: string): Promise<GenericDeleteResult>;

package/dist/databases/mongo-db/commands/delete-by-id.command.js

@@ -0,0 +1,9 @@
+import { ObjectId } from "mongodb";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+export async function deleteById(db, id, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const objectId = new ObjectId(id);
+    const baseQuery = { _id: objectId };
+    const deleteResult = await collection.deleteOne(baseQuery);
+    return new GenericDeleteResult(deleteResult.acknowledged, deleteResult.deletedCount);
+}

package/dist/databases/mongo-db/commands/delete-many.command.d.ts

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+export declare function deleteMany(db: Db, queryObject: IQueryOptions, pluralResourceName: string): Promise<GenericDeleteResult>;

package/dist/databases/mongo-db/commands/delete-many.command.js

@@ -0,0 +1,9 @@
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function deleteMany(db, queryObject, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const deleteResult = await collection.deleteMany(filter);
+    return new GenericDeleteResult(deleteResult.acknowledged, deleteResult.deletedCount);
+}

package/dist/databases/mongo-db/commands/full-updateby-id.command.d.ts

@@ -0,0 +1,3 @@
+import { Db } from "mongodb";
+import { Operation } from "../../operations/operation.js";
+export declare function fullUpdateById<T>(db: Db, operations: Operation[], id: string, entity: any, pluralResourceName: string): Promise<T>;

package/dist/databases/mongo-db/commands/full-updateby-id.command.js

@@ -0,0 +1,21 @@
+import { IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+export async function fullUpdateById(db, operations, id, entity, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch({ filters: { _id: { eq: id } } });
+    const filter = matchDocument.$match;
+    const replaceResult = await collection.replaceOne(filter, entity);
+    if (replaceResult.matchedCount <= 0) {
+        throw new IdNotFoundError();
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch({ filters: { _id: { eq: id } } })
+        .addOperations(operations)
+        .build();
+    const updatedEntity = await collection.aggregate(pipeline).next();
+    if (!updatedEntity) {
+        throw new IdNotFoundError();
+    }
+    return updatedEntity;
+}

package/dist/databases/mongo-db/commands/index.d.ts

@@ -0,0 +1,8 @@
+export * from './mongo-create.command.js';
+export * from './mongo-create-many.command.js';
+export * from './mongo-batch-update.command.js';
+export * from './mongo-full-updateby-id.command.js';
+export * from './mongo-partial-update-by-id.command.js';
+export * from './mongo-update.command.js';
+export * from './mongo-delete-by-id.command.js';
+export * from './mongo-delete-many.command.js';