@loomcore/api 0.0.34 → 0.0.36

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

@@ -26,6 +26,7 @@ export interface ICategory extends IEntity {
 }
 export interface IProduct extends IEntity, IAuditable {
     name: string;
+    description?: string;
     internalNumber?: string;
     categoryId: string;
     category?: ICategory;
@@ -36,6 +37,7 @@ export declare const CategorySchema: import("@sinclair/typebox").TObject<{
 export declare const CategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
 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;
 }>;

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

@@ -179,6 +179,7 @@ export const CategorySchema = Type.Object({
 export const CategorySpec = entityUtils.getModelSpec(CategorySchema);
 export const ProductSchema = Type.Object({
     name: Type.String(),
+    description: Type.Optional(Type.String()),
     internalNumber: Type.Optional(Type.String()),
     categoryId: Type.String({ format: 'objectid' }),
 });

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

@@ -22,6 +22,7 @@ export declare abstract class ApiController<T extends IEntity> {
     getById(req: Request, res: Response, next: NextFunction): Promise<void>;
     getCount(req: Request, res: Response, next: NextFunction): Promise<void>;
     create(req: Request, res: Response, next: NextFunction): Promise<void>;
+    batchUpdate(req: Request, res: Response, next: NextFunction): Promise<void>;
     fullUpdateById(req: Request, res: Response, next: NextFunction): Promise<void>;
     partialUpdateById(req: Request, res: Response, next: NextFunction): Promise<void>;
     deleteById(req: Request, res: Response, next: NextFunction): Promise<void>;

package/dist/controllers/api.controller.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from '../errors/index.js';
 import { entityUtils } from '@loomcore/common/utils';
 import { isAuthenticated } from '../middleware/index.js';
 import { apiUtils } from '../utils/index.js';
@@ -23,6 +24,7 @@ export class ApiController {
         app.get(`/api/${this.slug}/count`, isAuthenticated, this.getCount.bind(this));
         app.get(`/api/${this.slug}/:id`, isAuthenticated, this.getById.bind(this));
         app.post(`/api/${this.slug}`, isAuthenticated, this.create.bind(this));
+        app.patch(`/api/${this.slug}/batch`, isAuthenticated, this.batchUpdate.bind(this));
         app.put(`/api/${this.slug}/:id`, isAuthenticated, this.fullUpdateById.bind(this));
         app.patch(`/api/${this.slug}/:id`, isAuthenticated, this.partialUpdateById.bind(this));
         app.delete(`/api/${this.slug}/:id`, isAuthenticated, this.deleteById.bind(this));
@@ -67,6 +69,17 @@ export class ApiController {
         const entity = await this.service.create(req.userContext, preparedEntity);
         apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSchema);
     }
+    async batchUpdate(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const entities = req.body;
+        if (!Array.isArray(entities)) {
+            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);
+        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);

package/dist/services/generic-api-service.interface.d.ts

@@ -8,12 +8,14 @@ export interface IGenericApiService<T extends IEntity> {
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
     prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
+    prepareDataForBatchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<Partial<T>[]>;
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: T | Partial<T>): Promise<T | null>;
     createMany(userContext: IUserContext, entities: T[]): Promise<T[]>;
+    batchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;
     fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
     partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
     partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, entity: T): Promise<T>;

package/dist/services/generic-api.service.d.ts

@@ -17,12 +17,13 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;
     getCount(userContext: IUserContext): Promise<number>;
-    create(userContext: IUserContext, entity: T | Partial<T>): Promise<T | null>;
-    createMany(userContext: IUserContext, entities: T[]): Promise<T[]>;
-    fullUpdateById(userContext: IUserContext, id: string, entity: T): Promise<T>;
-    partialUpdateById(userContext: IUserContext, id: string, entity: Partial<T>): Promise<T>;
-    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, entity: T): Promise<T>;
-    update(userContext: IUserContext, queryObject: any, entity: Partial<T>): Promise<T[]>;
+    create(userContext: IUserContext, preparedEntity: T | Partial<T>): Promise<T | null>;
+    createMany(userContext: IUserContext, preparedEntities: T[]): Promise<T[]>;
+    batchUpdate(userContext: IUserContext, preparedEntities: Partial<T>[]): Promise<T[]>;
+    fullUpdateById(userContext: IUserContext, id: string, preparedEntity: T): Promise<T>;
+    partialUpdateById(userContext: IUserContext, id: string, preparedEntity: Partial<T>): Promise<T>;
+    partialUpdateByIdWithoutBeforeAndAfter(userContext: IUserContext, id: string, preparedEntity: T): Promise<T>;
+    update(userContext: IUserContext, queryObject: any, preparedEntity: Partial<T>): Promise<T[]>;
     deleteById(userContext: IUserContext, id: string): Promise<DeleteResult>;
     deleteMany(userContext: IUserContext, queryObject: any): Promise<DeleteResult>;
     find(userContext: IUserContext, mongoQueryObject: any, options?: FindOptions<Document> | undefined): Promise<T[]>;
@@ -42,7 +43,8 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
     prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
     prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
-    protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean): Promise<T | Partial<T>>;
+    prepareDataForBatchUpdate(userContext: IUserContext, entities: Partial<T>[]): Promise<Partial<T>[]>;
+    protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean, allowId?: boolean): Promise<T | Partial<T>>;
     protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
     protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
 }

package/dist/services/generic-api.service.js

@@ -148,13 +148,13 @@ export class GenericApiService {
         const count = await this.collection.countDocuments(query);
         return count;
     }
-    async create(userContext, entity) {
+    async create(userContext, preparedEntity) {
         let createdEntity = null;
         try {
-            const preparedEntity = await this.onBeforeCreate(userContext, entity);
-            const insertResult = await this.collection.insertOne(preparedEntity);
+            const entity = await this.onBeforeCreate(userContext, preparedEntity);
+            const insertResult = await this.collection.insertOne(entity);
             if (insertResult.insertedId) {
-                createdEntity = this.transformSingle(preparedEntity);
+                createdEntity = this.transformSingle(entity);
             }
             if (createdEntity) {
                 await this.onAfterCreate(userContext, createdEntity);
@@ -168,14 +168,14 @@ export class GenericApiService {
         }
         return createdEntity;
     }
-    async createMany(userContext, entities) {
+    async createMany(userContext, preparedEntities) {
         let createdEntities = [];
-        if (entities.length) {
+        if (preparedEntities.length) {
             try {
-                const preparedEntities = await this.onBeforeCreate(userContext, entities);
-                const insertResult = await this.collection.insertMany(preparedEntities);
+                const entities = await this.onBeforeCreate(userContext, preparedEntities);
+                const insertResult = await this.collection.insertMany(entities);
                 if (insertResult.insertedIds) {
-                    createdEntities = this.transformList(preparedEntities);
+                    createdEntities = this.transformList(entities);
                 }
                 await this.onAfterCreate(userContext, createdEntities);
             }
@@ -188,7 +188,38 @@ export class GenericApiService {
         }
         return createdEntities;
     }
-    async fullUpdateById(userContext, id, entity) {
+    async batchUpdate(userContext, preparedEntities) {
+        if (!preparedEntities || preparedEntities.length === 0) {
+            return [];
+        }
+        const entities = await this.onBeforeUpdate(userContext, preparedEntities);
+        const operations = [];
+        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);
+            operations.push({
+                updateOne: {
+                    filter: { _id },
+                    update: { $set: updateData },
+                },
+            });
+        }
+        if (operations.length > 0) {
+            await this.collection.bulkWrite(operations);
+        }
+        const query = this.prepareQuery(userContext, { _id: { $in: entityIds } });
+        const rawUpdatedEntities = await this.collection.find(query).toArray();
+        const updatedEntities = this.transformList(rawUpdatedEntities);
+        if (updatedEntities.length > 0) {
+            await this.onAfterUpdate(userContext, updatedEntities);
+        }
+        return updatedEntities;
+    }
+    async fullUpdateById(userContext, id, preparedEntity) {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
@@ -202,24 +233,24 @@ export class GenericApiService {
             _created: existingEntity._created,
             _createdBy: existingEntity._createdBy,
         };
-        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
-        Object.assign(preparedEntity, auditProperties);
-        const mongoUpdateResult = await this.collection.replaceOne(query, preparedEntity);
+        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
+        Object.assign(entity, auditProperties);
+        const mongoUpdateResult = await this.collection.replaceOne(query, entity);
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new IdNotFoundError();
         }
-        await this.onAfterUpdate(userContext, preparedEntity);
+        await this.onAfterUpdate(userContext, entity);
         const updatedEntity = await this.collection.findOne(query);
         return this.transformSingle(updatedEntity);
     }
-    async partialUpdateById(userContext, id, entity) {
+    async partialUpdateById(userContext, id, preparedEntity) {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
+        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
+        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: entity }, { returnDocument: 'after' });
         if (!updatedEntity) {
             throw new IdNotFoundError();
         }
@@ -229,13 +260,13 @@ export class GenericApiService {
         }
         return this.transformSingle(updatedEntity);
     }
-    async partialUpdateByIdWithoutBeforeAndAfter(userContext, id, entity) {
+    async partialUpdateByIdWithoutBeforeAndAfter(userContext, id, preparedEntity) {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: entity }, { returnDocument: 'after' });
+        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
         let updatedEntity = null;
         if (modifyResult?.ok === 1) {
             updatedEntity = modifyResult.value;
@@ -250,14 +281,14 @@ export class GenericApiService {
         }
         return this.transformSingle(updatedEntity);
     }
-    async update(userContext, queryObject, entity) {
-        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
+    async update(userContext, queryObject, preparedEntity) {
+        const entity = await this.onBeforeUpdate(userContext, preparedEntity);
         const query = this.prepareQuery(userContext, queryObject);
-        const mongoUpdateResult = await this.collection.updateMany(query, { $set: preparedEntity });
+        const mongoUpdateResult = await this.collection.updateMany(query, { $set: entity });
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new NotFoundError('No records found matching update query');
         }
-        await this.onAfterUpdate(userContext, preparedEntity);
+        await this.onAfterUpdate(userContext, entity);
         const updatedEntities = await this.collection.find(query).toArray();
         return this.transformList(updatedEntities);
     }
@@ -338,13 +369,16 @@ export class GenericApiService {
         const transformedEntity = dbUtils.convertObjectIdsToStrings(single, this.modelSpec.fullSchema);
         return transformedEntity;
     }
-    stripSenderProvidedSystemProperties(userContext, doc) {
+    stripSenderProvidedSystemProperties(userContext, doc, allowId = false) {
         const isSystemUser = userContext.user?._id === 'system';
         if (isSystemUser) {
             return;
         }
         for (const key in doc) {
             if (Object.prototype.hasOwnProperty.call(doc, key) && key.startsWith('_') && key !== '_orgId') {
+                if (allowId && key === '_id') {
+                    continue;
+                }
                 delete doc[key];
             }
         }
@@ -357,9 +391,12 @@ export class GenericApiService {
             return await this.prepareEntity(userContext, entity, isCreate);
         }
     }
-    async prepareEntity(userContext, entity, isCreate) {
+    async prepareDataForBatchUpdate(userContext, entities) {
+        return Promise.all(entities.map(item => this.prepareEntity(userContext, item, false, true)));
+    }
+    async prepareEntity(userContext, entity, isCreate, allowId = false) {
         const preparedEntity = _.clone(entity);
-        this.stripSenderProvidedSystemProperties(userContext, preparedEntity);
+        this.stripSenderProvidedSystemProperties(userContext, preparedEntity, allowId);
         if (this.modelSpec?.isAuditable) {
             if (isCreate) {
                 this.auditForCreate(userContext, preparedEntity);

package/dist/utils/db.utils.js

@@ -67,6 +67,9 @@ function convertStringsToObjectIds(entity, schema) {
     if (!entity)
         return entity;
     const clone = _.cloneDeep(entity);
+    if (clone._id && typeof clone._id === 'string' && entityUtils.isValidObjectId(clone._id)) {
+        clone._id = new ObjectId(clone._id);
+    }
     const processEntity = (obj, subSchema, path = []) => {
         if (!obj || typeof obj !== 'object')
             return obj;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {