xcally-nest-library 0.0.36 → 0.0.37-XM3778-bae91

package/src/core/infrastracture/databases/base.mongo.repository.ts

@@ -0,0 +1,371 @@
+import { IBaseMongoRepository } from '@/core/domain/interfaces/base.mongo.repository.interface';
+import { ObjectId } from 'mongodb';
+import { PaginateQuery, Paginated } from 'nestjs-paginate';
+import { EntityManager, MongoRepository, ObjectLiteral } from 'typeorm';
+import { ExtendedPaginateConfig } from './base.mongo.entity.interface';
+
+/**
+ * Represents a generic MongoDB repository for managing entities.
+ */
+export class BaseMongoRepository<E extends ObjectLiteral>
+  extends MongoRepository<E>
+  implements IBaseMongoRepository<E>
+{
+  public paginateConfig: ExtendedPaginateConfig<E>;
+
+  constructor(manager: EntityManager, entityCls: new () => E, paginateConfig?: ExtendedPaginateConfig<E>) {
+    super(entityCls, manager);
+    this.paginateConfig = paginateConfig || {
+      sortableColumns: [],
+    };
+  }
+
+  /**
+   * Retrieves a paginated list of entities based on the provided query.
+   *
+   * @param query - The pagination query parameters.
+   * @returns A promise that resolves to a paginated list of entities.
+   */
+  async getMany(query: PaginateQuery): Promise<Paginated<E>> {
+    //this implementation of pagination is considering skip and limit and not cursors
+
+    const page = query.page ?? 1;
+
+    //get the limit (combining config limits and query limits)
+    const defaultLimit = this.paginateConfig.defaultLimit ?? 20;
+    const maxLimit = this.paginateConfig.maxLimit ?? 100;
+    const inputLimit = query.limit ?? defaultLimit;
+    const limit = Math.min(inputLimit, maxLimit);
+
+    const skip = (page - 1) * limit;
+
+    // building complex filters (where clause)
+    const filter = this.buildMongoFilter(query, this.paginateConfig);
+
+    // building sort clause (multiple fields)
+    const sort = this.buildMongoSort(query);
+
+    // selecting fields (projection)
+    const selectCondition = this.buildMongoSelect(query, this.paginateConfig);
+
+    // fetching data and total count
+    const [data, totalItems] = await this.findAndCount({
+      where: filter as any,
+      order: sort as any,
+      skip,
+      take: limit,
+      select: selectCondition,
+    });
+
+    const totalPages = Math.ceil(totalItems / limit);
+
+    const meta = {
+      itemsPerPage: limit,
+      totalItems,
+      currentPage: page,
+      totalPages,
+      // cast these to any to avoid the extremely strict SortBy/E typings from nestjs-paginate
+      sortBy: (query.sortBy ?? []) as unknown as any,
+      searchBy: (query.searchBy ?? []) as unknown as any,
+      search: query.search ?? '',
+      select: selectCondition ?? [],
+      filter: query.filter ?? {},
+    };
+
+    const links = {
+      current: query.path ? `${query.path}?page=${page}&limit=${limit}` : '',
+      first: query.path ? `${query.path}?page=1&limit=${limit}` : undefined,
+      previous: page > 1 && query.path ? `${query.path}?page=${page - 1}&limit=${limit}` : undefined,
+      next: page < totalPages && query.path ? `${query.path}?page=${page + 1}&limit=${limit}` : undefined,
+      last: query.path ? `${query.path}?page=${totalPages}&limit=${limit}` : undefined,
+    };
+
+    const plainData = data.map(d => JSON.parse(JSON.stringify(d)));
+
+    // final cast: runtime structure matches Paginated<E>, cast to satisfy TS
+    return {
+      data: plainData,
+      meta: meta as unknown as Paginated<E>['meta'],
+      links: links as any,
+    } as Paginated<E>;
+  }
+
+  /**
+   * Retrieves an entity from the database based on its ID.
+   *
+   * @param id - The ID of the entity to retrieve (string or ObjectId).
+   * @returns A promise that resolves to the retrieved entity.
+   */
+  async findById(id: string | ObjectId): Promise<E> {
+    let objectId: ObjectId;
+
+    if (typeof id === 'string') {
+      if (!ObjectId.isValid(id)) {
+        throw new Error(`Invalid ObjectId string: ${id}`);
+      }
+      objectId = new ObjectId(id);
+    } else if (id instanceof ObjectId) {
+      objectId = id;
+    } else {
+      throw new Error(`Invalid id type: ${typeof id}`);
+    }
+
+    return this.findOne({
+      where: { _id: objectId },
+    });
+  }
+
+  protected buildMongoFilter(query: PaginateQuery, paginateConfig: ExtendedPaginateConfig<E>): Record<string, any> {
+    // apply filter whitelist from config
+    const { filter = {} } = query;
+    const filterConfig = paginateConfig.filterableColumns || {};
+    const allowedFilterColumns = new Set(Object.keys(filterConfig));
+    const dateCols = new Set(paginateConfig.dateColumns || []);
+
+    // conditions have positional order on $or $and operators
+    const orderedConditions: { field: string; ops: string[]; valuePart: string; isDate: boolean }[] = [];
+
+    // operator whitelist
+    for (const [field, rawValue] of Object.entries(filter)) {
+      if (!allowedFilterColumns.has(field)) {
+        console.warn(`Column filter not allowed: ${field}`);
+        continue;
+      }
+
+      // dates needs to be parsed correctly (transported as strings but stored as Date)
+      const isDate = dateCols.has(field);
+
+      // array values like e.g. $in ['val1','val2']
+      if (Array.isArray(rawValue)) {
+        for (const cond of rawValue) {
+          if (typeof cond !== 'string') continue;
+          const tokens = cond.split(':');
+          const ops = tokens.filter(t => t.startsWith('$'));
+          const valuePart = tokens.slice(tokens.findIndex(t => !t.startsWith('$'))).join(':');
+          orderedConditions.push({ field, ops, valuePart, isDate });
+        }
+        // every other case is a string
+      } else if (typeof rawValue === 'string') {
+        if (!rawValue.includes(':')) {
+          // simple single operator
+          orderedConditions.push({ field, ops: [], valuePart: rawValue, isDate });
+        } else {
+          // multiple operators in a single string value e.g. $not:$in:value
+          const tokens = rawValue.split(':');
+          const ops = tokens.filter(t => t.startsWith('$'));
+          const valuePart = tokens.slice(tokens.findIndex(t => !t.startsWith('$'))).join(':');
+          orderedConditions.push({ field, ops, valuePart, isDate });
+        }
+      }
+    }
+
+    // main AND group
+    const andGroup: any[] = [];
+    let lastCondition: any = null;
+
+    for (const { field, ops, valuePart, isDate } of orderedConditions) {
+      // remove the first logical operator if it is $or or $and and handle the others
+      const mainLogical = ops[0] === '$or' || ops[0] === '$and' ? ops[0] : null;
+      if (mainLogical) ops.shift();
+
+      // build logical condition for some special operators like $btw,$ilike...
+      const special = this.buildSpecialOperator(ops, valuePart, isDate);
+      let finalVal: any;
+
+      if (special) {
+        // handled by special operator builder
+        finalVal = special;
+      } else if (ops.length && ops[ops.length - 1] === '$in') {
+        // handle $in and $nin with comma separated values
+        const vals = valuePart.split(',').map(s => this.parsePrimitive(s.trim(), isDate));
+        finalVal = ops[0] === '$not' ? { $nin: vals } : { $in: vals };
+      } else {
+        // primitive type like $eq with string, number, boolean, dates..
+        finalVal = this.parsePrimitive(valuePart, isDate);
+        if (ops.length) {
+          const temp: Record<string, any> = {};
+          // apply remaining operators
+          this.applyOps(temp, ops, finalVal);
+          finalVal = temp;
+        }
+      }
+
+      const condition: Record<string, any> = { [field]: finalVal };
+
+      // $and, $or are applied backward to the previous condition positionally
+      if ((mainLogical === '$or' || mainLogical === '$and') && lastCondition) {
+        const prev = andGroup.pop();
+        const merged = { [mainLogical]: [prev, condition] };
+        andGroup.push(merged);
+        lastCondition = merged;
+      } else {
+        // otherwise is a simple push to the main AND group
+        andGroup.push(condition);
+        lastCondition = condition;
+      }
+    }
+
+    // final filtering conditions
+    const finalFilter = andGroup.length === 1 ? andGroup[0] : { $and: andGroup };
+
+    //console.log('Final MongoDB filter:', JSON.stringify(finalFilter, null, 2));
+    return finalFilter;
+  }
+
+  // transform string field into real stored type (needed because reflection doesn't work with generics<E>)
+  private parsePrimitive(raw: string, isDateField: boolean): any {
+    if (isDateField) {
+      const d = new Date(raw);
+      if (!isNaN(d.getTime())) return d;
+    }
+    if (raw === 'true') return true;
+    if (raw === 'false') return false;
+    if (raw !== '' && !Number.isNaN(Number(raw)) && !/^0\d+/.test(raw)) return Number(raw);
+    return raw;
+  }
+
+  // helper to apply nested operators
+  private applyOps(targetObj: Record<string, any>, ops: string[], value: any): void {
+    let ref = targetObj;
+    for (let i = 0; i < ops.length; i++) {
+      const op = ops[i];
+      const isLast = i === ops.length - 1;
+      if (isLast) ref[op] = value;
+      else {
+        if (ref[op] === undefined) ref[op] = {};
+        ref = ref[op];
+      }
+    }
+  }
+
+  // builds special operators like $btw, $sw, $ilike, $null, $contains.. (with regex support)
+  private buildSpecialOperator(ops: string[], valuePart: string, isDate: boolean): Record<string, any> | null {
+    const isNegated = ops.includes('$not');
+    const cleanOps = ops.filter(o => o !== '$not');
+    const values = valuePart.split(',').map(v => this.parsePrimitive(v.trim(), isDate));
+
+    const asSafeRegexString = (val: any): string => {
+      if (val == null) return '';
+      const s = String(val);
+      return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    };
+
+    switch (cleanOps[0]) {
+      case '$btw': {
+        const [from, to] = values;
+        const expr = { $gte: from, $lte: to };
+        return isNegated ? { $not: expr } : expr;
+      }
+      case '$sw': {
+        const regex = new RegExp(`^${asSafeRegexString(values[0])}`, 'i');
+        return isNegated ? { $not: regex } : { $regex: regex };
+      }
+      case '$ilike': {
+        const regex = new RegExp(asSafeRegexString(values[0]), 'i');
+        return isNegated ? { $not: regex } : { $regex: regex };
+      }
+      case '$null': {
+        return isNegated ? { $ne: null } : { $eq: null };
+      }
+      case '$contains': {
+        const expr = { $all: values };
+        return isNegated ? { $not: expr } : expr;
+      }
+      default:
+        return null;
+    }
+  }
+
+  // builds the sort object for MongoDB queries (multiple fields sorting)
+  protected buildMongoSort(query: PaginateQuery): Record<string, 1 | -1> {
+    const { sortBy = [] } = query;
+    const sort: Record<string, 1 | -1> = {};
+
+    sortBy.forEach(([field, direction]) => {
+      sort[field] = direction.toUpperCase() === 'ASC' ? 1 : -1;
+    });
+
+    // default: _id DESC
+    if (Object.keys(sort).length === 0) {
+      sort['_id'] = -1;
+    }
+
+    return sort;
+  }
+
+  // builds the projection fields for MongoDB queries
+  // for future use with cursor-based pagination
+  protected buildMongoProjectionFields(query: PaginateQuery, cursorColumn = '_id'): string[] | undefined {
+    const { select } = query;
+
+    if (select && select.length) {
+      const fields = [...select];
+      if (!fields.includes(cursorColumn)) {
+        fields.push(cursorColumn);
+      }
+      return fields;
+    }
+    return undefined;
+  }
+
+  // normalizes the cursor value to string (for pagination links)
+  // for future use with cursor-based pagination
+  protected normalizeCursorValue(val: any): string {
+    if (!val && val !== 0) return undefined;
+
+    if (val instanceof ObjectId && typeof val.toHexString === 'function') {
+      return val.toHexString();
+    }
+    if (val && val._bsontype === 'ObjectID' && typeof val.toHexString === 'function') {
+      return val.toHexString();
+    }
+
+    return String(val);
+  }
+
+  // builds the query string for pagination links
+  // for future use with cursor-based pagination
+  protected buildQueryString(obj: Record<string, any>): string {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(obj)) {
+      if (v === undefined || v === null) continue;
+      params.append(k, String(v));
+    }
+    return params.toString();
+  }
+
+  // filter the selected fields trough the whitelist coming from config
+  protected buildMongoSelect(query: PaginateQuery, paginateConfig: ExtendedPaginateConfig<E>): string[] | undefined {
+    const requestedSelect = query.select;
+
+    // no select requested -> no filtering needed
+    if (!requestedSelect || requestedSelect.length === 0) {
+      return undefined;
+    }
+
+    const allowedSelectColumns = new Set(paginateConfig.select || []);
+
+    // if no allowed columns, warn and return undefined
+    if (allowedSelectColumns.size === 0) {
+      console.warn('no columns are allowed for selection in config');
+      // undefined means -> use typeorm default (all columns)
+      return undefined;
+    }
+
+    // whitelist from config applied
+    const validSelect = requestedSelect.filter(field => {
+      const isAllowed = allowedSelectColumns.has(field);
+      if (!isAllowed) {
+        console.warn(`column not allowed: ${field}`);
+      }
+      return isAllowed;
+    });
+
+    // if no valid fields remain after filtering, return undefined to avoid errors
+    if (validSelect.length === 0) {
+      return undefined;
+    }
+
+    return validSelect;
+  }
+}

package/src/core/infrastracture/databases/base.repository.ts

@@ -1,6 +1,6 @@
 import { Repository, EntityManager, Equal, FindOptionsWhere, ObjectLiteral } from 'typeorm';
 import { PaginateConfig, PaginateQuery, Paginated, paginate } from 'nestjs-paginate';
-import { IBaseRepository } from '@domain/interfaces/base.repository.interface';
+import { IBaseRepository } from '@/core/domain/interfaces/base.repository.interface';
 
 /**
  * Represents a generic repository for managing entities.

package/src/modules/logger/pino/logger.module.ts

@@ -25,7 +25,7 @@ export class LoggerModule {
     };
 
     const providers = [LoggerService, loggerOptions];
-    const exports = [LoggerService, loggerOptions];
+    const exports = [LoggerService, loggerOptions, ClsModule];
     return {
       module: LoggerModule,
       providers,

package/src/modules/logger/pino/logger.service.ts

@@ -22,9 +22,9 @@ export class LoggerService {
   ) {}
 
   private withAdditionalTraceId(meta?: LoggerMeta) {
-    const xctraceid: string | undefined = this.cls.get('xctraceid');
-    const xcactionid: string | undefined = this.cls.get('xcactionid');
-    return { ...meta, xctraceid, xcactionid };
+    const xcTraceId: string | undefined = this.cls.get('xcTraceId');
+    const xcActionId: string | undefined = this.cls.get('xcActionId');
+    return { ...meta, xcTraceId: xcTraceId ?? meta?.xcTraceId, xcActionId: xcActionId ?? meta?.xcActionId };
   }
 
   debug(msg: string, meta?: LoggerMeta): void {
@@ -60,7 +60,7 @@ export class LoggerService {
   // Esempio di uso corretto:
   someMethod() {
     this.cls.run(() => {
-      this.cls.set('xctraceid', 'my-trace-id');
+      this.cls.set('xcTraceId', 'my-trace-id');
       // Tutto il codice asincrono che parte da qui vedrà il valore
       this.logger.info('Log con trace id'); // Qui funziona
       setTimeout(() => {

package/tsconfig.json

@@ -17,6 +17,7 @@
     "strictBindCallApply": false,
     "forceConsistentCasingInFileNames": false,
     "noFallthroughCasesInSwitch": false,
+    "resolveJsonModule": true,
     "paths": {
       "@/*": ["./src/*"],
       "@interfaces-pb/*": ["./interfaces-pb/*"],

package/dist/src/modules/db-hooks-subscriber/db-hooks-subscriber.module.d.ts

@@ -1,2 +0,0 @@
-export declare class DbHooksSubscriberModule {
-}

package/dist/src/modules/db-hooks-subscriber/db-hooks-subscriber.module.js

@@ -1,22 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbHooksSubscriberModule = void 0;
-const common_1 = require("@nestjs/common");
-const nestjs_cls_1 = require("nestjs-cls");
-let DbHooksSubscriberModule = class DbHooksSubscriberModule {
-};
-exports.DbHooksSubscriberModule = DbHooksSubscriberModule;
-exports.DbHooksSubscriberModule = DbHooksSubscriberModule = __decorate([
-    (0, common_1.Module)({
-        imports: [
-            nestjs_cls_1.ClsModule,
-        ],
-    })
-], DbHooksSubscriberModule);
-//# sourceMappingURL=db-hooks-subscriber.module.js.map

package/dist/src/modules/db-hooks-subscriber/db-hooks-subscriber.module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"db-hooks-subscriber.module.js","sourceRoot":"","sources":["../../../../src/modules/db-hooks-subscriber/db-hooks-subscriber.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,2CAAuC;AAShC,IAAM,uBAAuB,GAA7B,MAAM,uBAAuB;CAAG,CAAA;AAA1B,0DAAuB;kCAAvB,uBAAuB;IAPnC,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,sBAAS;SAEV;KAEF,CAAC;GACW,uBAAuB,CAAG"}