@clairejs/server 3.16.5 → 3.16.6

package/README.md

@@ -1,6 +1,6 @@
 ## Change Log
 
-#### 3.16.5:
+#### 3.16.6:
 
 -   do not throw when fail to clean up in ModelRepository
 -   fix file controllers

package/dist/http/repository/DtoRepository.d.ts

@@ -31,29 +31,32 @@ export declare const MultipleMap: <R extends Identifiable, K extends AbstractMod
 export declare class DtoRepository<T extends Identifiable> extends AbstractRepository<T> implements ICrudRepository<T> {
     protected readonly model: Constructor<T>;
     protected readonly dissolver: DtoDissolver<T, any>;
-    protected readonly logger: AbstractLogger;
-    constructor(model: Constructor<T>, dissolver: DtoDissolver<T, any>, logger: AbstractLogger);
+    constructor(model: Constructor<T>, dissolver: DtoDissolver<T, any>);
     private getMapValue;
-    createMany({ principal, body, tx, }: {
+    createMany({ principal, body, tx, logger, }: {
         principal?: IPrincipal | undefined;
         body: CreateManyRequestBody<T>;
         tx: ITransaction & IQueryProvider;
+        logger?: AbstractLogger;
     }): Promise<CreateManyResponseBody<T>>;
-    updateMany({ principal, queries, ops, body, tx, }: {
+    updateMany({ principal, queries, ops, body, tx, logger, }: {
         principal?: IPrincipal | undefined;
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         body: UpdateManyBody<T>;
         tx: ITransaction & IQueryProvider;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
-    getMany({ queries, ops, queryProvider, }: {
+    getMany({ queries, ops, queryProvider, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
         queryProvider: IQueryProvider;
+        logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
-    deleteMany({ queries, ops, tx, }: {
+    deleteMany({ queries, ops, tx, logger, }: {
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
 }

package/dist/http/repository/DtoRepository.js

@@ -26,12 +26,10 @@ export const MultipleMap = (modelClass, forwardOps, forwardMapping, rootMapping,
 export class DtoRepository extends AbstractRepository {
     model;
     dissolver;
-    logger;
-    constructor(model, dissolver, logger) {
+    constructor(model, dissolver) {
         super(model);
         this.model = model;
         this.dissolver = dissolver;
-        this.logger = logger;
     }
     async getMapValue(root, currentInstancesResolver, mappers, preOperator, postOperator) {
         for (const mapper of mappers) {
@@ -53,28 +51,34 @@ export class DtoRepository extends AbstractRepository {
             deepMerge(root, partial);
         }
     }
-    async createMany({ principal, body, tx, }) {
+    async createMany({ principal, body, tx, logger, }) {
         const result = [];
         await this.beforeCreating(principal, body.records);
         for (const record of body.records) {
             await this.getMapValue(record, async (mapper) => {
-                const repo = new ModelRepository(mapper.modelClass, this.logger);
+                const repo = new ModelRepository(mapper.modelClass);
                 const currentInstances = await repo.getMany({
                     ops: mapper.forwardOps(),
                     queryProvider: tx,
+                    logger,
                 });
                 return currentInstances.records;
             }, this.dissolver(record), async (mapper, ks, currentInstances) => {
                 if (!ks) {
                     return [];
                 }
-                const repo = new ModelRepository(mapper.modelClass, this.logger);
+                const repo = new ModelRepository(mapper.modelClass);
                 const ops = mapper.forwardOps();
                 if (mapper.multiple) {
                     //-- if ks contain an array of instances, we need to remove old instances and create new ones
-                    await repo.deleteMany({ ops, tx });
+                    await repo.deleteMany({ ops, tx, logger });
                     //-- try creating new
-                    const createManyResult = await repo.createMany({ principal, body: { records: ks }, tx });
+                    const createManyResult = await repo.createMany({
+                        principal,
+                        body: { records: ks },
+                        tx,
+                        logger,
+                    });
                     return createManyResult.records;
                 }
                 else {
@@ -89,11 +93,12 @@ export class DtoRepository extends AbstractRepository {
                             principal,
                             body: { records: ks },
                             tx,
+                            logger,
                         });
                         return instances.records;
                     }
                     else if (currentInstances.length === 1) {
-                        const result = await repo.updateMany({ principal, ops, body: { update: k }, tx });
+                        const result = await repo.updateMany({ principal, ops, body: { update: k }, tx, logger });
                         return [{ ...currentInstances[0], ...k, ...result.modified[0] }];
                     }
                     else {
@@ -105,7 +110,7 @@ export class DtoRepository extends AbstractRepository {
         }
         return { records: result };
     }
-    async updateMany({ principal, queries, ops, body, tx, }) {
+    async updateMany({ principal, queries, ops, body, tx, logger, }) {
         //-- check queries for id field
         if (!queries?.fields?.id || queries.fields.id.length !== 1) {
             throw Errors.VALIDATION_ERROR("Missing required id field in query");
@@ -113,23 +118,24 @@ export class DtoRepository extends AbstractRepository {
         const result = { ...body.update, id: queries.fields.id[0] };
         await this.beforeCreating(principal, [result]);
         await this.getMapValue(result, async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass, this.logger);
+            const repo = new ModelRepository(mapper.modelClass);
             const currentInstances = await repo.getMany({
                 ops: mapper.forwardOps(ops),
                 queryProvider: tx,
+                logger,
             });
             return currentInstances.records;
         }, this.dissolver(result), async (mapper, ks, currentInstances) => {
             if (!ks) {
                 return [];
             }
-            const repo = new ModelRepository(mapper.modelClass, this.logger);
+            const repo = new ModelRepository(mapper.modelClass);
             const opsx = mapper.forwardOps(ops);
             if (mapper.multiple) {
                 //-- if ks contain an array of instances, we need to remove old instances and create new ones
-                await repo.deleteMany({ ops: opsx, tx });
+                await repo.deleteMany({ ops: opsx, tx, logger });
                 //-- try creating new
-                const createManyResult = await repo.createMany({ principal, body: { records: ks }, tx });
+                const createManyResult = await repo.createMany({ principal, body: { records: ks }, tx, logger });
                 return createManyResult.records;
             }
             else {
@@ -144,13 +150,13 @@ export class DtoRepository extends AbstractRepository {
                 }
                 if (currentInstances.length > 1) {
                     //-- remove all instances
-                    await repo.deleteMany({ ops: opsx, tx });
+                    await repo.deleteMany({ ops: opsx, tx, logger });
                     //-- try creating new
-                    await repo.createMany({ principal, body: { records: [k] }, tx });
+                    await repo.createMany({ principal, body: { records: [k] }, tx, logger });
                 }
                 else {
                     //-- update current instance
-                    await repo.updateMany({ principal, ops: opsx, body: { update: k }, tx });
+                    await repo.updateMany({ principal, ops: opsx, body: { update: k }, tx, logger });
                 }
                 return currentInstances.map((re) => ({ ...re, ...k }));
             }
@@ -165,18 +171,19 @@ export class DtoRepository extends AbstractRepository {
         }
         return { modified: result.id ? this.project([result], projection) : [] };
     }
-    async getMany({ queries, ops, queryProvider, }) {
+    async getMany({ queries, ops, queryProvider, logger, }) {
         //-- check queries for id field
         if (!queries?.fields?.id || queries.fields.id.length !== 1) {
             throw Errors.VALIDATION_ERROR("Missing required id field in query");
         }
         const result = { id: queries.fields.id[0] };
         await this.getMapValue(result, async () => [], this.dissolver(result), async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass, this.logger);
+            const repo = new ModelRepository(mapper.modelClass);
             //-- forward get
             const instances = await repo.getMany({
                 ops: mapper.forwardOps(ops),
                 queryProvider,
+                logger,
             });
             return instances.records;
         });
@@ -184,20 +191,21 @@ export class DtoRepository extends AbstractRepository {
             ? { records: this.project([result], queries.projection), total: 1 }
             : { records: [], total: 0 };
     }
-    async deleteMany({ queries, ops, tx, }) {
+    async deleteMany({ queries, ops, tx, logger, }) {
         //-- check queries for id field
         if (!queries?.fields?.id || queries.fields.id.length !== 1) {
             throw Errors.VALIDATION_ERROR("Missing required id field in query");
         }
         const result = { id: queries.fields.id[0] };
         await this.getMapValue(result, async () => [], this.dissolver(result), undefined, async (mapper) => {
-            const repo = new ModelRepository(mapper.modelClass, this.logger);
+            const repo = new ModelRepository(mapper.modelClass);
             //const nestedQueries = mapper.forwardQuery();
             const nestedOps = mapper.forwardOps(ops);
             const result = await repo.deleteMany({
                 queries: { returning: queries?.returning },
                 ops: nestedOps,
                 tx,
+                logger,
             });
             return result.modified;
         });

package/dist/http/repository/ICrudRepository.d.ts

@@ -1,27 +1,31 @@
-import { CreateManyRequestBody, CreateManyResponseBody, GetManyQueries, GetManyResponseBody, UpdateManyBody, UpdateManyQueries, UpdateManyResponse } from "@clairejs/core";
+import { AbstractLogger, CreateManyRequestBody, CreateManyResponseBody, GetManyQueries, GetManyResponseBody, UpdateManyBody, UpdateManyQueries, UpdateManyResponse } from "@clairejs/core";
 import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
 import { IPrincipal } from "../../common/auth/IPrincipal";
 export interface ICrudRepository<T> {
-    createMany({ principal, body, tx, }: {
-        principal?: IPrincipal;
+    createMany({ principal, body, tx, logger, }: {
         body: CreateManyRequestBody<T>;
         tx: ITransaction;
+        logger?: AbstractLogger;
+        principal?: IPrincipal;
     }): Promise<CreateManyResponseBody<T>>;
-    getMany({ queries, ops, queryProvider, }: {
+    getMany({ queries, ops, queryProvider, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
         queryProvider: IQueryProvider;
+        logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
-    updateMany({ principal, queries, ops, body, tx, }: {
+    updateMany({ principal, queries, ops, body, tx, logger, }: {
         principal?: IPrincipal;
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         body: UpdateManyBody<T>;
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
-    deleteMany({ queries, ops, tx, }: {
+    deleteMany({ queries, ops, tx, logger, }: {
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
 }

package/dist/http/repository/ModelRepository.d.ts

@@ -5,34 +5,37 @@ import { ICrudRepository } from "./ICrudRepository";
 import { AbstractRepository } from "./AbstractRepository";
 export declare class ModelRepository<T extends AbstractModel> extends AbstractRepository<T> implements ICrudRepository<T> {
     protected readonly model: Constructor<T>;
-    protected readonly logger: AbstractLogger;
     private fileUploadHandler?;
-    constructor(model: Constructor<T>, logger: AbstractLogger);
+    constructor(model: Constructor<T>);
     private getNestedQueries;
     private getUploadHandler;
     private getRequestQueryConditionFromQuery;
     protected uriHandling(records: Partial<T>[]): Promise<() => Promise<void>>;
     protected beforeReturning(records: Partial<T>[]): Promise<void>;
-    createMany({ principal, body, tx, }: {
+    createMany({ principal, body, tx, logger, }: {
         principal?: IPrincipal;
         body: CreateManyRequestBody<T>;
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<CreateManyResponseBody<T>>;
-    updateMany({ principal, ops, queries, body, tx, }: {
+    updateMany({ principal, ops, queries, body, tx, logger, }: {
         principal?: IPrincipal;
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         body: UpdateManyBody<T>;
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
-    getMany({ queries, ops, queryProvider, }: {
+    getMany({ queries, ops, queryProvider, logger, }: {
         queries?: GetManyQueries<T>;
         ops?: QueryCondition<T>[];
         queryProvider: IQueryProvider;
+        logger?: AbstractLogger;
     }): Promise<GetManyResponseBody<T>>;
-    deleteMany({ queries, ops, tx, }: {
+    deleteMany({ queries, ops, tx, logger, }: {
         queries?: UpdateManyQueries<T>;
         ops?: QueryCondition<T>[];
         tx: ITransaction;
+        logger?: AbstractLogger;
     }): Promise<UpdateManyResponse<T>>;
 }

package/dist/http/repository/ModelRepository.js

@@ -6,12 +6,10 @@ import { LocaleTranslation } from "../../system/locale/LocaleTranslation";
 import { LocaleEntry } from "../../system/locale/LocaleEntry";
 export class ModelRepository extends AbstractRepository {
     model;
-    logger;
     fileUploadHandler;
-    constructor(model, logger) {
+    constructor(model) {
         super(model);
         this.model = model;
-        this.logger = logger;
     }
     getNestedQueries(queries) {
         return this.modelMetadata.fields
@@ -211,7 +209,7 @@ export class ModelRepository extends AbstractRepository {
         }
         await Promise.all(mappingOperations);
     }
-    async createMany({ principal, body, tx, }) {
+    async createMany({ principal, body, tx, logger, }) {
         const originalRecords = body.records;
         if (!originalRecords.length) {
             return { records: [] };
@@ -307,7 +305,7 @@ export class ModelRepository extends AbstractRepository {
             });
             if (hasManyRecords.length) {
                 //-- insert to db
-                const innerService = new ModelRepository(getModelById(field.hasMany.relationDto.id), this.logger);
+                const innerService = new ModelRepository(getModelById(field.hasMany.relationDto.id));
                 body.records = hasManyRecords;
                 const persistedInnerRecords = await innerService.createMany({ principal, body, tx });
                 //-- map back ids to hasManyRecords
@@ -331,10 +329,10 @@ export class ModelRepository extends AbstractRepository {
             }
         }
         //-- everything is ok, remove original Uris
-        cleanUp().catch((err) => this.logger.error("Error in clean up", err));
+        cleanUp().catch((err) => logger?.error("Error in clean up", err));
         return { records };
     }
-    async updateMany({ principal, ops, queries, body, tx, }) {
+    async updateMany({ principal, ops, queries, body, tx, logger, }) {
         const allConditions = ops || [];
         const hasManyFields = this.modelMetadata.fields.filter((f) => !!f.hasMany);
         const systemLocale = getSystemLocale();
@@ -481,7 +479,7 @@ export class ModelRepository extends AbstractRepository {
             if (tobeRemovedIds.length) {
                 await adapter.deleteMany({ _in: { id: tobeRemovedIds } });
             }
-            const modelService = new ModelRepository(model, this.logger);
+            const modelService = new ModelRepository(model);
             const added = await modelService.createMany({
                 principal,
                 body: { records: tobeAdded },
@@ -512,11 +510,11 @@ export class ModelRepository extends AbstractRepository {
             ];
         }
         //-- ok clean up
-        cleanUp().catch((err) => this.logger.error("Error in clean up", err));
+        cleanUp().catch((err) => logger?.error("Error in clean up", err));
         await this.beforeReturning(records);
         return { modified: this.project(records, projection) };
     }
-    async getMany({ queries, ops, queryProvider, }) {
+    async getMany({ queries, ops, queryProvider, logger: _logger, }) {
         const conditions = ops || [];
         if (queries?.fields) {
             conditions.push(...this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata));
@@ -601,7 +599,10 @@ export class ModelRepository extends AbstractRepository {
                 continue;
             }
             const model = getModelById(field.hasMany.relationDto.id);
-            const service = new ModelRepository(model, this.logger);
+            if (!model) {
+                throw Errors.NOT_FOUND(`Model not found by id: ${field.hasMany.relationDto.id}`);
+            }
+            const service = new ModelRepository(model);
             const innerRecords = !recordIds.length
                 ? { records: [] }
                 : await service.getMany({
@@ -621,7 +622,7 @@ export class ModelRepository extends AbstractRepository {
                 [...queries.projection, ...(queries.locale ? [] : finalProjection || [])].reduce(uniqueReducer, [])),
         };
     }
-    async deleteMany({ queries, ops, tx, }) {
+    async deleteMany({ queries, ops, tx, logger, }) {
         let allConditions = ops || [];
         if (queries?.fields) {
             const fieldOps = this.getRequestQueryConditionFromQuery(queries.fields, this.modelMetadata);
@@ -685,7 +686,7 @@ export class ModelRepository extends AbstractRepository {
             if (toBeRemovedUris.length) {
                 const fileUploadHandler = await this.getUploadHandler();
                 if (fileUploadHandler) {
-                    Promise.all(toBeRemovedUris.map((uri) => fileUploadHandler.removeFile(uri))).catch((err) => this.logger.error("Fail to remove some files", err));
+                    Promise.all(toBeRemovedUris.map((uri) => fileUploadHandler.removeFile(uri))).catch((err) => logger?.error("Fail to remove some files", err));
                 }
             }
             returning = tobeRemoved;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.16.5",
+    "version": "3.16.6",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",