@loomcore/api 0.0.22 → 0.0.24

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 } from '@loomcore/common/models';
+import { IEntity, IModelSpec, IUserContext } from '@loomcore/common/models';
 import { IGenericApiService } from '../services/index.js';
 export declare abstract class ApiController<T extends IEntity> {
     protected app: Application;
@@ -11,6 +11,12 @@ export declare abstract class ApiController<T extends IEntity> {
     protected publicSchema?: TSchema;
     protected constructor(slug: string, app: Application, service: IGenericApiService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSchema?: TSchema);
     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

@@ -1,3 +1,4 @@
+import { entityUtils } from '@loomcore/common/utils';
 import { isAuthenticated } from '../middleware/index.js';
 import { apiUtils } from '../utils/index.js';
 export class ApiController {
@@ -26,6 +27,17 @@ export class ApiController {
         app.patch(`/api/${this.slug}/:id`, isAuthenticated, this.partialUpdateById.bind(this));
         app.delete(`/api/${this.slug}/:id`, isAuthenticated, this.deleteById.bind(this));
     }
+    validate(entity, isPartial = false) {
+        const validationErrors = this.service.validate(entity, isPartial);
+        entityUtils.handleValidationResult(validationErrors, `ApiController.validate for ${this.slug}`);
+    }
+    validateMany(entities, isPartial = false) {
+        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);
@@ -50,17 +62,23 @@ export class ApiController {
     }
     async create(req, res, next) {
         res.set('Content-Type', 'application/json');
-        const entity = await this.service.create(req.userContext, req.body);
+        this.validate(req.body);
+        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, true);
+        const entity = await this.service.create(req.userContext, preparedEntity);
         apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSchema);
     }
     async fullUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
-        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, req.body);
+        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);
         apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
     }
     async partialUpdateById(req, res, next) {
         res.set('Content-Type', 'application/json');
-        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, req.body);
+        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);
         apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
     }
     async deleteById(req, res, next) {

package/dist/controllers/auth.controller.js

@@ -1,4 +1,5 @@
-import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec } 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';
 import { apiUtils } from '../utils/index.js';
@@ -28,7 +29,10 @@ export class AuthController {
     async registerUser(req, res) {
         const userContext = req.userContext;
         const body = req.body;
-        const user = await this.authService.createUser(userContext, 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);
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
     }
     async requestTokenUsingRefreshToken(req, res, next) {
@@ -42,8 +46,7 @@ export class AuthController {
     }
     async getUserContext(req, res, next) {
         const userContext = req.userContext;
-        const clientUserContext = { user: userContext.user };
-        apiUtils.apiResponse(res, 200, { data: clientUserContext }, UserContextSpec);
+        apiUtils.apiResponse(res, 200, { data: userContext }, UserContextSpec);
     }
     afterAuth(req, res, loginResponse) {
         console.log('in afterAuth');
@@ -51,6 +54,8 @@ export class AuthController {
     async changePassword(req, res) {
         const userContext = req.userContext;
         const body = req.body;
+        const validationErrors = entityUtils.validate(passwordValidator, { password: body.password });
+        entityUtils.handleValidationResult(validationErrors, 'AuthController.changePassword');
         const updateResult = await this.authService.changeLoggedInUsersPassword(userContext, body);
         apiUtils.apiResponse(res, 200, { data: updateResult });
     }

package/dist/services/auth.service.js

@@ -1,7 +1,7 @@
 import { ObjectId } from 'mongodb';
 import moment from 'moment';
 import crypto from 'crypto';
-import { EmptyUserContext, passwordValidator, UserSpec, getSystemUserContext } from '@loomcore/common/models';
+import { EmptyUserContext, UserSpec, getSystemUserContext } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, ServerError } from '../errors/index.js';
 import { JwtService, EmailService } from './index.js';
@@ -88,8 +88,6 @@ export class AuthService extends GenericApiService {
         return tokens;
     }
     async changeLoggedInUsersPassword(userContext, body) {
-        const validationResult = entityUtils.validate(passwordValidator, { password: body.password });
-        entityUtils.handleValidationResult(validationResult, 'AuthService.changePassword');
         const queryObject = { _id: new ObjectId(userContext.user._id) };
         const result = await this.changePassword(userContext, queryObject, body.password);
         return result;
@@ -266,7 +264,7 @@ export class AuthService extends GenericApiService {
             if (!entityUtils.isValidObjectId(userId)) {
                 throw new BadRequestError('userId is not a valid ObjectId');
             }
-            const updates = { _lastLoggedIn: moment().utc().toISOString() };
+            const updates = { _lastLoggedIn: moment().utc().toDate() };
             const systemUserContext = getSystemUserContext();
             await this.partialUpdateById(systemUserContext, userId, updates);
         }

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

@@ -4,6 +4,10 @@ import { IUserContext, IEntity, IPagedResult, QueryOptions } from '@loomcore/com
 export interface IGenericApiService<T extends IEntity> {
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
+    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
+    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>[]>;
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions: QueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;

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

@@ -30,7 +30,7 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     auditForCreate(userContext: IUserContext, doc: any): void;
     auditForUpdate(userContext: IUserContext, doc: any): void;
     onBeforeCreate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
-    onAfterCreate<E extends T | T[]>(userContext: IUserContext | undefined, entities: E): Promise<E | E[]>;
+    onAfterCreate<E extends T | T[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
     onBeforeUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
     onAfterUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext | undefined, entities: E): Promise<E>;
     onBeforeDelete(userContext: IUserContext, queryObject: any): Promise<any>;
@@ -38,7 +38,10 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     transformList(list: any[]): T[];
     transformSingle(single: any): T;
     private stripSenderProvidedSystemProperties;
-    protected preparePayload<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entity: E, isCreate?: boolean): Promise<E | E[]>;
+    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
+    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>>;
     protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
     protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: QueryOptions): QueryOptions;

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

@@ -135,8 +135,6 @@ export class GenericApiService {
         return count;
     }
     async create(userContext, entity) {
-        const validationErrors = this.validate(entity);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.create');
         let createdEntity = null;
         try {
             const preparedEntity = await this.onBeforeCreate(userContext, entity);
@@ -160,8 +158,6 @@ export class GenericApiService {
         let createdEntities = [];
         if (entities.length) {
             try {
-                const validationErrors = this.validateMany(entities);
-                entityUtils.handleValidationResult(validationErrors, 'GenericApiService.createMany');
                 const preparedEntities = await this.onBeforeCreate(userContext, entities);
                 const insertResult = await this.collection.insertMany(preparedEntities);
                 if (insertResult.insertedIds) {
@@ -182,8 +178,6 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.fullUpdateById');
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
         const existingEntity = await this.collection.findOne(query);
@@ -194,13 +188,13 @@ export class GenericApiService {
             _created: existingEntity._created,
             _createdBy: existingEntity._createdBy,
         };
-        const clone = await this.onBeforeUpdate(userContext, entity);
-        Object.assign(clone, auditProperties);
-        const mongoUpdateResult = await this.collection.replaceOne(query, clone);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
+        Object.assign(preparedEntity, auditProperties);
+        const mongoUpdateResult = await this.collection.replaceOne(query, preparedEntity);
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new IdNotFoundError();
         }
-        await this.onAfterUpdate(userContext, clone);
+        await this.onAfterUpdate(userContext, preparedEntity);
         const updatedEntity = await this.collection.findOne(query);
         return this.transformSingle(updatedEntity);
     }
@@ -208,12 +202,10 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity, true);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateById');
-        const clone = await this.onBeforeUpdate(userContext, entity);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: clone }, { returnDocument: 'after' });
+        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
         if (!updatedEntity) {
             throw new IdNotFoundError();
         }
@@ -227,12 +219,9 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity, true);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateByIdWithoutBeforeAndAfter');
-        const preparedEntity = this.preparePayload(userContext, entity, false);
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
+        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: entity }, { returnDocument: 'after' });
         let updatedEntity = null;
         if (modifyResult?.ok === 1) {
             updatedEntity = modifyResult.value;
@@ -248,13 +237,13 @@ export class GenericApiService {
         return this.transformSingle(updatedEntity);
     }
     async update(userContext, queryObject, entity) {
-        const clone = await this.onBeforeUpdate(userContext, entity);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
         const query = this.prepareQuery(userContext, queryObject);
-        const mongoUpdateResult = await this.collection.updateMany(query, { $set: clone });
+        const mongoUpdateResult = await this.collection.updateMany(query, { $set: preparedEntity });
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new NotFoundError('No records found matching update query');
         }
-        await this.onAfterUpdate(userContext, clone);
+        await this.onAfterUpdate(userContext, preparedEntity);
         const updatedEntities = await this.collection.find(query).toArray();
         return this.transformList(updatedEntities);
     }
@@ -304,15 +293,13 @@ export class GenericApiService {
         doc._updatedBy = userId;
     }
     async onBeforeCreate(userContext, entities) {
-        const preparedEntities = await this.preparePayload(userContext, entities, true);
-        return Promise.resolve(preparedEntities);
+        return Promise.resolve(entities);
     }
     async onAfterCreate(userContext, entities) {
         return Promise.resolve(entities);
     }
     async onBeforeUpdate(userContext, entities) {
-        const preparedEntities = await this.preparePayload(userContext, entities, false);
-        return Promise.resolve(preparedEntities);
+        return Promise.resolve(entities);
     }
     onAfterUpdate(userContext, entities) {
         return Promise.resolve(entities);
@@ -348,15 +335,13 @@ export class GenericApiService {
             }
         }
     }
-    async preparePayload(userContext, entity, isCreate = false) {
-        let result;
+    async prepareDataForDb(userContext, entity, isCreate = false) {
         if (Array.isArray(entity)) {
-            result = await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
+            return await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
         }
         else {
-            result = await this.prepareEntity(userContext, entity, isCreate);
+            return await this.prepareEntity(userContext, entity, isCreate);
         }
-        return result;
     }
     async prepareEntity(userContext, entity, isCreate) {
         const preparedEntity = _.clone(entity);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -51,7 +51,8 @@
     "express": "^5.1.0",
     "lodash": "^4.17.21",
     "moment": "^2.30.1",
-    "mongodb": "^6.16.0"
+    "mongodb": "^6.16.0",
+    "rxjs": "^7.8.0"
   },
   "devDependencies": {
     "@types/cookie-parser": "^1.4.7",
@@ -64,6 +65,7 @@
     "cross-env": "^7.0.3",
     "mongodb-memory-server": "^9.3.0",
     "npm-run-all": "^4.1.5",
+    "rxjs": "^7.8.0",
     "supertest": "^7.1.0",
     "typescript": "^5.8.3",
     "vite": "^6.2.5",