@loomcore/api 0.0.59 → 0.1.2

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/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';

package/dist/databases/mongo-db/commands/index.js

@@ -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';

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

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

package/dist/databases/mongo-db/commands/mongo-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, queryObject, 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/mongo-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/mongo-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/mongo-create.command.d.ts

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

package/dist/databases/mongo-db/commands/mongo-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/mongo-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/mongo-delete-by-id.command.js

@@ -0,0 +1,14 @@
+import { ObjectId } from "mongodb";
+import { DeleteResult as GenericDeleteResult } from "../../models/delete-result.js";
+import { BadRequestError } from "../../../errors/index.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function deleteById(db, id, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    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/mongo-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/mongo-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/mongo-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/mongo-full-updateby-id.command.js

@@ -0,0 +1,25 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function fullUpdateById(db, operations, id, entity, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    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/mongo-partial-update-by-id.command.d.ts

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

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

@@ -0,0 +1,25 @@
+import { BadRequestError, IdNotFoundError } from "../../../errors/index.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+import { entityUtils } from "@loomcore/common/utils";
+export async function partialUpdateById(db, operations, id, entity, pluralResourceName) {
+    if (!entityUtils.isValidObjectId(id)) {
+        throw new BadRequestError('id is not a valid ObjectId');
+    }
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch({ filters: { _id: { eq: id } } });
+    const filter = matchDocument.$match;
+    const updatedEntity = await collection.findOneAndUpdate(filter, { $set: entity }, { returnDocument: 'after' });
+    if (!updatedEntity) {
+        throw new IdNotFoundError();
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch({ filters: { _id: { eq: id } } })
+        .addOperations(operations)
+        .build();
+    const updatedEntityWithOperations = await collection.aggregate(pipeline).next();
+    if (!updatedEntityWithOperations) {
+        throw new IdNotFoundError();
+    }
+    return updatedEntityWithOperations;
+}

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

@@ -0,0 +1,4 @@
+import { Db } from "mongodb";
+import { IQueryOptions } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export declare function update<T>(db: Db, queryObject: IQueryOptions, entity: Partial<any>, operations: Operation[], pluralResourceName: string): Promise<T[]>;

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

@@ -0,0 +1,19 @@
+import { NotFoundError } 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 update(db, queryObject, entity, operations, pluralResourceName) {
+    const collection = db.collection(pluralResourceName);
+    const matchDocument = buildNoSqlMatch(queryObject);
+    const filter = matchDocument.$match;
+    const updateResult = await collection.updateMany(filter, { $set: entity });
+    if (updateResult.matchedCount <= 0) {
+        throw new NotFoundError('No records found matching update query');
+    }
+    const pipeline = new NoSqlPipeline()
+        .addMatch(queryObject)
+        .addOperations(operations)
+        .addQueryOptions(queryObject, false)
+        .build();
+    const updatedEntities = await collection.aggregate(pipeline).toArray();
+    return updatedEntities;
+}

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

@@ -0,0 +1,4 @@
+export * from './utils/index.js';
+export * from './mongo-db.database.js';
+export * from './queries/index.js';
+export * from './commands/index.js';

package/dist/databases/mongo-db/index.js

@@ -0,0 +1,4 @@
+export * from './utils/index.js';
+export * from './mongo-db.database.js';
+export * from './queries/index.js';
+export * from './commands/index.js';

package/dist/databases/mongo-db/models/no-sql-pipeline.d.ts

@@ -0,0 +1,15 @@
+import { Document } from "mongodb";
+import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+import { INoSqlPipeline } from "./no-sql-pipeline.interface.js";
+declare class NoSqlPipeline implements INoSqlPipeline {
+    private pipeline;
+    constructor(pipeline?: Document[] | null);
+    addStage(stage: Document): NoSqlPipeline;
+    addStages(stages: Document[]): NoSqlPipeline;
+    addMatch(queryOptions: IQueryOptions, modelSpec?: IModelSpec): NoSqlPipeline;
+    addOperations(operations: Operation[]): NoSqlPipeline;
+    addQueryOptions(queryOptions: IQueryOptions, pagination: boolean): NoSqlPipeline;
+    build(): Document[];
+}
+export default NoSqlPipeline;

package/dist/databases/mongo-db/models/no-sql-pipeline.interface.d.ts

@@ -0,0 +1,11 @@
+import { Document } from "mongodb";
+import { IQueryOptions, IModelSpec } from "@loomcore/common/models";
+import { Operation } from "../../operations/operation.js";
+export interface INoSqlPipeline {
+    addStage(stage: Document): INoSqlPipeline;
+    addStages(stages: Document[]): INoSqlPipeline;
+    addMatch(queryOptions: IQueryOptions, modelSpec?: IModelSpec): INoSqlPipeline;
+    addOperations(operations: Operation[]): INoSqlPipeline;
+    addQueryOptions(queryOptions: IQueryOptions, pagination: boolean): INoSqlPipeline;
+    build(): Document[];
+}

package/dist/databases/mongo-db/models/no-sql-pipeline.js

@@ -0,0 +1,43 @@
+import { buildNoSqlMatch, convertOperationsToPipeline, convertQueryOptionsToPipeline } from "../utils/index.js";
+class NoSqlPipeline {
+    pipeline;
+    constructor(pipeline = null) {
+        if (pipeline) {
+            this.pipeline = [...pipeline];
+        }
+        else {
+            this.pipeline = [];
+        }
+    }
+    addStage(stage) {
+        this.pipeline.push(stage);
+        return this;
+    }
+    addStages(stages) {
+        this.pipeline = this.pipeline.concat(stages);
+        return this;
+    }
+    addMatch(queryOptions, modelSpec) {
+        const matchDocument = buildNoSqlMatch(queryOptions, modelSpec);
+        if (matchDocument) {
+            this.pipeline.push(matchDocument);
+        }
+        return this;
+    }
+    addOperations(operations) {
+        const operationsDocuments = convertOperationsToPipeline(operations);
+        if (operationsDocuments.length > 0) {
+            this.pipeline = this.pipeline.concat(operationsDocuments);
+        }
+        return this;
+    }
+    addQueryOptions(queryOptions, pagination) {
+        const queryOptionsDocuments = convertQueryOptionsToPipeline(queryOptions, pagination);
+        this.pipeline = this.pipeline.concat(queryOptionsDocuments);
+        return this;
+    }
+    build() {
+        return this.pipeline;
+    }
+}
+export default NoSqlPipeline;