@minimaltech/node-infra 0.5.9-22 → 0.5.9-24

package/dist/mixins/user-audit.mixin.js

@@ -13,11 +13,9 @@ exports.UserAuditMixin = void 0;
 const utilities_1 = require("../utilities");
 const repository_1 = require("@loopback/repository");
 const UserAuditMixin = (superClass, opts) => {
-    const { useRelation = false, creatorResolver, creatorKeyTo, modifierResolver, modifierKeyTo, } = opts ?? {};
+    const { useRelation = false, creatorResolver, creatorKeyTo, modifierResolver, modifierKeyTo, } = opts !== null && opts !== void 0 ? opts : {};
     if (!useRelation) {
         let Mixed = class Mixed extends superClass {
-            createdBy;
-            modifiedBy;
         };
         __decorate([
             (0, repository_1.property)({
@@ -26,6 +24,7 @@ const UserAuditMixin = (superClass, opts) => {
                     columnName: 'created_by',
                     dataType: 'integer',
                 },
+                // hidden: true,
             }),
             __metadata("design:type", Object)
         ], Mixed.prototype, "createdBy", void 0);
@@ -36,6 +35,7 @@ const UserAuditMixin = (superClass, opts) => {
                     columnName: 'modified_by',
                     dataType: 'integer',
                 },
+                // hidden: true,
             }),
             __metadata("design:type", Object)
         ], Mixed.prototype, "modifiedBy", void 0);
@@ -51,8 +51,6 @@ const UserAuditMixin = (superClass, opts) => {
         throw (0, utilities_1.getError)({ message: '[UserAuditMixin] Invalid modifierResolver' });
     }
     let Mixed = class Mixed extends superClass {
-        createdBy;
-        modifiedBy;
     };
     __decorate([
         (0, repository_1.belongsTo)(creatorResolver, { keyFrom: 'createdBy', keyTo: creatorKeyTo, name: 'creator' }, {

package/dist/mixins/vector.mixin.js

@@ -13,18 +13,15 @@ exports.VectorMixin = void 0;
 const utilities_1 = require("../utilities");
 const repository_1 = require("@loopback/repository");
 const VectorMixin = (superClass, options) => {
+    var _a, _b, _c;
     const { uuid, embedding } = options;
-    const vectorType = embedding?.vectorType ?? 'vector';
-    if (!embedding?.vectorSize) {
+    const vectorType = (_a = embedding === null || embedding === void 0 ? void 0 : embedding.vectorType) !== null && _a !== void 0 ? _a : 'vector';
+    if (!(embedding === null || embedding === void 0 ? void 0 : embedding.vectorSize)) {
         throw (0, utilities_1.getError)({
-            message: `[VectorMixin] Invalid vector size | class: ${superClass.name} | vectorSize: ${embedding?.vectorSize}`,
+            message: `[VectorMixin] Invalid vector size | class: ${superClass.name} | vectorSize: ${embedding === null || embedding === void 0 ? void 0 : embedding.vectorSize}`,
         });
     }
     class Mixed extends superClass {
-        uuid;
-        embedding;
-        metadata;
-        details;
     }
     __decorate([
         (0, repository_1.property)({
@@ -32,7 +29,7 @@ const VectorMixin = (superClass, options) => {
             required: true,
             defaultFn: 'uuidv4',
             postgresql: {
-                columnName: uuid?.columnName ?? 'uuid',
+                columnName: (_b = uuid === null || uuid === void 0 ? void 0 : uuid.columnName) !== null && _b !== void 0 ? _b : 'uuid',
                 dataType: 'text',
             },
         }),
@@ -42,7 +39,7 @@ const VectorMixin = (superClass, options) => {
         (0, repository_1.property)({
             type: 'any',
             postgresql: {
-                columnName: embedding?.columnName ?? 'embedding',
+                columnName: (_c = embedding === null || embedding === void 0 ? void 0 : embedding.columnName) !== null && _c !== void 0 ? _c : 'embedding',
                 dataType: `${vectorType}(${(0, utilities_1.int)(embedding.vectorSize)})`,
             },
         }),

package/dist/tsconfig.base.json

@@ -2,7 +2,7 @@
   "$schema": "http://json.schemastore.org/tsconfig",
   "extends": "@loopback/build/config/tsconfig.common.json",
   "compilerOptions": {
-    "target": "es2023",
+    "target": "es2015",
     "module": "nodenext",
 
     /* Bundler mode */
@@ -10,23 +10,23 @@
     "experimentalDecorators": true,
     "importHelpers": false,
     "esModuleInterop": true,
-    "removeComments": true,
+    "removeComments": false,
     "moduleResolution": "nodenext",
-
+    
     /* Optimization */
     "declaration": true,
     "declarationMap": false,
     "sourceMap": false,
     "inlineSourceMap": false,
     "inlineSources": false,
-
+    
     /* Linting */
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noImplicitOverride": true,
     "noFallthroughCasesInSwitch": true,
-
+    
     /* Paths */
     "outDir": "dist",
     "rootDir": "src",
@@ -34,6 +34,7 @@
     "paths": {
       "@/*": ["./*"]
     }
+
   },
   "include": ["src", "./*.config.*", ".prettierrc.*"],
   "exclude": ["node_modules", "dist"]

package/dist/utilities/date.utility.js

@@ -2,6 +2,7 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dayjs = exports.hrTime = exports.getDateTz = exports.getNextWeekday = exports.getPreviousWeekday = exports.isWeekday = exports.sleep = void 0;
 const dayjs_1 = __importDefault(require("dayjs"));
@@ -17,19 +18,28 @@ dayjs_1.default.extend(utc_1.default);
 dayjs_1.default.extend(timezone_1.default);
 dayjs_1.default.extend(weekday_1.default);
 dayjs_1.default.extend(isoWeek_1.default);
-const tz = process.env.APP_ENV_APPLICATION_TIMEZONE ?? 'Asia/Ho_Chi_Minh';
+const tz = (_a = process.env.APP_ENV_APPLICATION_TIMEZONE) !== null && _a !== void 0 ? _a : 'Asia/Ho_Chi_Minh';
 dayjs_1.default.tz.setDefault(tz);
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
 exports.sleep = sleep;
 const isWeekday = (date) => {
-    const isoWeekday = (0, dayjs_1.default)(date)?.isoWeekday();
+    var _a;
+    const isoWeekday = (_a = (0, dayjs_1.default)(date)) === null || _a === void 0 ? void 0 : _a.isoWeekday();
     return isoWeekday > 0 && isoWeekday < 6;
 };
 exports.isWeekday = isWeekday;
+/* export const getPreviousWeekday = () => {
+  let date = dayjs();
+  while (!isWeekday(date)) {
+    date = date.subtract(1, 'day');
+  }
+
+  return date;
+}; */
 const getPreviousWeekday = (opts) => {
-    const { date } = opts ?? { date: (0, dayjs_1.default)() };
+    const { date } = opts !== null && opts !== void 0 ? opts : { date: (0, dayjs_1.default)() };
     let rs = (0, dayjs_1.default)(date).clone().subtract(1, 'day');
     while (!(0, exports.isWeekday)(rs.toISOString())) {
         rs = rs.subtract(1, 'day');
@@ -37,8 +47,16 @@ const getPreviousWeekday = (opts) => {
     return rs;
 };
 exports.getPreviousWeekday = getPreviousWeekday;
+/* export const getNextWeekday = () => {
+  let date = dayjs();
+  while (!isWeekday(date)) {
+    date = date.add(1, 'day');
+  }
+
+  return date;
+}; */
 const getNextWeekday = (opts) => {
-    const { date } = opts ?? { date: (0, dayjs_1.default)() };
+    const { date } = opts !== null && opts !== void 0 ? opts : { date: (0, dayjs_1.default)() };
     let rs = (0, dayjs_1.default)(date).clone().add(1, 'day');
     while (!(0, exports.isWeekday)(rs.toISOString())) {
         rs = rs.add(1, 'day');
@@ -53,6 +71,6 @@ const getDateTz = (opts) => {
 exports.getDateTz = getDateTz;
 const hrTime = () => {
     const curr = process.hrtime();
-    return (0, parse_utility_1.float)(curr[0] + curr[1] / 10 ** 9, 9);
+    return (0, parse_utility_1.float)(curr[0] + curr[1] / Math.pow(10, 9), 9);
 };
 exports.hrTime = hrTime;

package/dist/utilities/error.utility.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getError = exports.ApplicationError = void 0;
 class ApplicationError extends Error {
-    statusCode;
-    messageCode;
     constructor(opts) {
         const { message, messageCode, statusCode = 400 } = opts;
         super(message);

package/dist/utilities/model.utility.js

@@ -3,17 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdType = exports.getIdSchema = void 0;
 const metadata_1 = require("@loopback/metadata");
 const rest_1 = require("@loopback/rest");
+// --------------------------------------------------------------------------------------------------------------
 const getIdSchema = (entity) => {
+    var _a;
     const idProp = entity.getIdProperties()[0];
     const modelSchema = (0, rest_1.jsonToSchemaObject)((0, rest_1.getJsonSchema)(entity));
-    return modelSchema.properties?.[idProp];
+    return (_a = modelSchema.properties) === null || _a === void 0 ? void 0 : _a[idProp];
 };
 exports.getIdSchema = getIdSchema;
+// --------------------------------------------------------------------------------------------------------------
 const getIdType = (entity) => {
+    var _a;
     let idType = 'number';
     try {
         const idMetadata = metadata_1.MetadataInspector.getPropertyMetadata('loopback:model-properties', entity, 'id');
-        idType = idMetadata?.type ?? 'number';
+        idType = (_a = idMetadata === null || idMetadata === void 0 ? void 0 : idMetadata.type) !== null && _a !== void 0 ? _a : 'number';
     }
     catch (e) {
         console.error("[getIdType] Failed to inspect entity id type! Use 'number' by default | Error: ", e);

package/dist/utilities/parse.utility.d.ts

@@ -10,8 +10,24 @@ export declare const toStringDecimal: (input: any, digit?: number, options?: {
     useLocaleFormat: boolean;
 }) => string | 0;
 export declare const getNumberValue: (input: string, method?: "int" | "float") => number;
+/**
+ * Returns an object with the key as the value of the `keyMap` and the value as the object itself.
+ *
+ * @param arr - The input array
+ * @param keyMap - The property key to use as the key in the resulting object
+ *
+ * Note: In case of duplicate keys, the last element will be used.
+ */
 export declare const parseArrayToRecordWithKey: <T extends Record<K, PropertyKey>, K extends keyof T>(opts: {
     arr: T[];
     keyMap: K;
 }) => Record<T[K], T>;
+/**
+ * Return a map with the key as the value of the `keyMap` and the value as the object itself.
+ *
+ * @param arr - The input array
+ * @param keyMap - The property key to use as the key in the resulting object
+ *
+ * Note: In case of duplicate keys, the last element will be used.
+ */
 export declare const parseArrayToMapWithKey: <T extends Record<K, PropertyKey>, K extends keyof T>(arr: T[], keyMap: K) => Map<T[K], T>;

package/dist/utilities/parse.utility.js

@@ -7,6 +7,7 @@ exports.parseArrayToMapWithKey = exports.parseArrayToRecordWithKey = exports.get
 const get_1 = __importDefault(require("lodash/get"));
 const round_1 = __importDefault(require("lodash/round"));
 const error_utility_1 = require("./error.utility");
+// -------------------------------------------------------------------------
 const INTL_0_DIGITS_FORMATER = new Intl.NumberFormat('en-US', {
     maximumFractionDigits: 0,
     minimumFractionDigits: 0,
@@ -15,14 +16,17 @@ const INTL_2_DIGITS_FORMATER = new Intl.NumberFormat('en-US', {
     maximumFractionDigits: 2,
     minimumFractionDigits: 2,
 });
+// -------------------------------------------------------------------------
 const getUID = () => Math.random().toString(36).slice(2).toUpperCase();
 exports.getUID = getUID;
+// -------------------------------------------------------------------------
 const toCamel = (s) => {
     return s.replace(/([-_][a-z])/gi, (sub) => {
         return sub.toUpperCase().replace('-', '').replace('_', '');
     });
 };
 exports.toCamel = toCamel;
+// -------------------------------------------------------------------------
 const keysToCamel = (object) => {
     const n = {};
     const keys = Object.keys(object);
@@ -44,6 +48,10 @@ const keysToCamel = (object) => {
                 n[(0, exports.toCamel)(key)] = (0, exports.keysToCamel)(value);
                 break;
             }
+            /* case 'array': {
+              n[toCamel(key)] = value;
+              break;
+            } */
             default: {
                 n[(0, exports.toCamel)(key)] = value;
                 break;
@@ -53,6 +61,7 @@ const keysToCamel = (object) => {
     return n;
 };
 exports.keysToCamel = keysToCamel;
+// -------------------------------------------------------------------------
 const isInt = (n) => {
     if (isNaN(n)) {
         return false;
@@ -60,6 +69,7 @@ const isInt = (n) => {
     return Number.isInteger(n) || Math.floor(Number(n)) === n || Number(n) % 1 === 0;
 };
 exports.isInt = isInt;
+// -------------------------------------------------------------------------
 const isFloat = (input) => {
     if (isNaN(input)) {
         return false;
@@ -67,32 +77,38 @@ const isFloat = (input) => {
     return Number(input) === input || Number(input) % 1 !== 0;
 };
 exports.isFloat = isFloat;
+// -------------------------------------------------------------------------
 const int = (input) => {
+    var _a, _b;
     if (!input || isNaN(input)) {
         return 0;
     }
-    const normalized = input?.toString()?.replace(/,/g, '');
-    return Number.parseInt(normalized, 10) ?? 0;
+    const normalized = (_a = input === null || input === void 0 ? void 0 : input.toString()) === null || _a === void 0 ? void 0 : _a.replace(/,/g, '');
+    return (_b = Number.parseInt(normalized, 10)) !== null && _b !== void 0 ? _b : 0;
 };
 exports.int = int;
+// -------------------------------------------------------------------------
 const float = (input, digit = 2) => {
+    var _a;
     if (!input || isNaN(input)) {
         return 0;
     }
-    const normalized = input?.toString()?.replace(/,/g, '');
+    const normalized = (_a = input === null || input === void 0 ? void 0 : input.toString()) === null || _a === void 0 ? void 0 : _a.replace(/,/g, '');
     return (0, round_1.default)(Number.parseFloat(normalized), digit);
 };
 exports.float = float;
+// -------------------------------------------------------------------------
 const toBoolean = (input) => {
-    return ((input !== 'false' &&
+    var _a;
+    return ((_a = (input !== 'false' &&
         input !== '0' &&
         input !== false &&
         input !== 0 &&
         input !== null &&
-        input !== undefined) ??
-        Boolean(input));
+        input !== undefined)) !== null && _a !== void 0 ? _a : Boolean(input));
 };
 exports.toBoolean = toBoolean;
+// -------------------------------------------------------------------------
 const toStringDecimal = (input, digit = 2, options = { useLocaleFormat: true }) => {
     const { useLocaleFormat } = options;
     if (isNaN(input)) {
@@ -121,6 +137,7 @@ const toStringDecimal = (input, digit = 2, options = { useLocaleFormat: true })
     return formater.format(number);
 };
 exports.toStringDecimal = toStringDecimal;
+// -------------------------------------------------------------------------
 const getNumberValue = (input, method = 'int') => {
     if (!input) {
         return 0;
@@ -146,6 +163,15 @@ const getNumberValue = (input, method = 'int') => {
     }
 };
 exports.getNumberValue = getNumberValue;
+// ---------------------------------------------------------
+/**
+ * Returns an object with the key as the value of the `keyMap` and the value as the object itself.
+ *
+ * @param arr - The input array
+ * @param keyMap - The property key to use as the key in the resulting object
+ *
+ * Note: In case of duplicate keys, the last element will be used.
+ */
 const parseArrayToRecordWithKey = (opts) => {
     const { arr, keyMap } = opts;
     const resultRecord = {};
@@ -163,6 +189,15 @@ const parseArrayToRecordWithKey = (opts) => {
     return resultRecord;
 };
 exports.parseArrayToRecordWithKey = parseArrayToRecordWithKey;
+// ---------------------------------------------------------
+/**
+ * Return a map with the key as the value of the `keyMap` and the value as the object itself.
+ *
+ * @param arr - The input array
+ * @param keyMap - The property key to use as the key in the resulting object
+ *
+ * Note: In case of duplicate keys, the last element will be used.
+ */
 const parseArrayToMapWithKey = (arr, keyMap) => {
     const resultMap = new Map();
     if (!arr.length) {

package/dist/utilities/performance.utility.js

@@ -8,6 +8,7 @@ const getPerformanceCheckpoint = () => {
 };
 exports.getPerformanceCheckpoint = getPerformanceCheckpoint;
 const getExecutedPerformance = (opts) => {
-    return (0, _1.float)(performance.now() - opts.from, opts.digit ?? DEFAULT_PERFORMANCE_DECIMAL);
+    var _a;
+    return (0, _1.float)(performance.now() - opts.from, (_a = opts.digit) !== null && _a !== void 0 ? _a : DEFAULT_PERFORMANCE_DECIMAL);
 };
 exports.getExecutedPerformance = getExecutedPerformance;

package/dist/utilities/promise.utility.d.ts

@@ -1,5 +1,22 @@
 import { ValueOrPromise } from '../common';
 type TTask<T> = () => Promise<T>;
+/**
+ *  Execute all tasks with limit number of asyncronous tasks.
+ *  Whenever 1 task's resolved next task will be executed.
+ *
+ *  @example
+ *  With 20 tasks need to execute with limit is 5 tasks asyncronous
+ *  ```
+ *  const tasks = <Array of 20 functions which return promises>
+ *  await executePromiseWithLimit({
+ *    tasks,
+ *    limit: 5,
+      onTaskDone: (opts: { result: any }) => {
+        // Do something on task done
+      },
+ *  })
+ *  ```
+ */
 export declare const executePromiseWithLimit: <T>(opts: {
     tasks: Array<TTask<T>>;
     limit: number;

package/dist/utilities/promise.utility.js

@@ -1,7 +1,33 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executePromiseWithLimit = void 0;
-const executePromiseWithLimit = async (opts) => {
+/**
+ *  Execute all tasks with limit number of asyncronous tasks.
+ *  Whenever 1 task's resolved next task will be executed.
+ *
+ *  @example
+ *  With 20 tasks need to execute with limit is 5 tasks asyncronous
+ *  ```
+ *  const tasks = <Array of 20 functions which return promises>
+ *  await executePromiseWithLimit({
+ *    tasks,
+ *    limit: 5,
+      onTaskDone: (opts: { result: any }) => {
+        // Do something on task done
+      },
+ *  })
+ *  ```
+ */
+const executePromiseWithLimit = (opts) => __awaiter(void 0, void 0, void 0, function* () {
     const { tasks, limit, onTaskDone } = opts;
     const results = [];
     const executing = new Set();
@@ -13,11 +39,11 @@ const executePromiseWithLimit = async (opts) => {
         executing.add(promise);
         results.push(promise);
         if (executing.size >= limit) {
-            const done = await Promise.race(executing);
-            onTaskDone?.({ result: done });
+            const done = yield Promise.race(executing);
+            onTaskDone === null || onTaskDone === void 0 ? void 0 : onTaskDone({ result: done });
         }
     }
-    await Promise.all(executing);
+    yield Promise.all(executing);
     return Promise.all(results);
-};
+});
 exports.executePromiseWithLimit = executePromiseWithLimit;

package/dist/utilities/query.utility.js

@@ -11,27 +11,29 @@ const snakeCase_1 = __importDefault(require("lodash/snakeCase"));
 const error_utility_1 = require("./error.utility");
 const getTableDefinition = (opts) => {
     const { model, alias } = opts;
-    const tableAlias = alias ?? model.name.toLowerCase();
+    const tableAlias = alias !== null && alias !== void 0 ? alias : model.name.toLowerCase();
     const tableNameWithAlias = `"${model.name}" ${tableAlias}`;
     const tableColumns = Object.entries(model.definition.properties)
         .map(([key, value]) => {
-        const columnName = value?.name ?? value?.postgresql?.columnName ?? key;
+        var _a, _b, _c;
+        const columnName = (_c = (_a = value === null || value === void 0 ? void 0 : value.name) !== null && _a !== void 0 ? _a : (_b = value === null || value === void 0 ? void 0 : value.postgresql) === null || _b === void 0 ? void 0 : _b.columnName) !== null && _c !== void 0 ? _c : key;
         return {
             [`${key}`]: `${tableAlias}.${columnName}`,
         };
     })
         .reduce((acc, cur) => {
-        return { ...acc, ...cur };
+        return Object.assign(Object.assign({}, acc), cur);
     }, {});
     const tableColumnsNoAlias = Object.entries(model.definition.properties)
         .map(([key, value]) => {
-        const columnName = value?.name ?? value?.postgresql?.columnName ?? key;
+        var _a, _b, _c;
+        const columnName = (_c = (_a = value === null || value === void 0 ? void 0 : value.name) !== null && _a !== void 0 ? _a : (_b = value === null || value === void 0 ? void 0 : value.postgresql) === null || _b === void 0 ? void 0 : _b.columnName) !== null && _c !== void 0 ? _c : key;
         return {
             [`${key}`]: `${columnName}`,
         };
     })
         .reduce((acc, cur) => {
-        return { ...acc, ...cur };
+        return Object.assign(Object.assign({}, acc), cur);
     }, {});
     return {
         table: { name: model.name, alias: tableAlias, nameWithQuotation: `"${model.name}"` },
@@ -41,22 +43,23 @@ const getTableDefinition = (opts) => {
     };
 };
 exports.getTableDefinition = getTableDefinition;
+// --------------------------------------------------------------------------------
 const getValue = (value) => {
     switch (typeof value) {
         case null: {
             return 'null';
         }
         case 'number': {
-            return value?.toString();
+            return value === null || value === void 0 ? void 0 : value.toString();
         }
         case 'boolean': {
             return value;
         }
         case 'string': {
-            if (value?.toString().trim() === '') {
+            if ((value === null || value === void 0 ? void 0 : value.toString().trim()) === '') {
                 return "''";
             }
-            return `'${value?.toString().replace(/'/g, "''")}'`;
+            return `'${value === null || value === void 0 ? void 0 : value.toString().replace(/'/g, "''")}'`;
         }
         default: {
             return `'${value}'`;
@@ -64,6 +67,7 @@ const getValue = (value) => {
     }
 };
 exports.getValue = getValue;
+// --------------------------------------------------------------------------------
 const buildBatchUpdateQuery = (opts) => {
     const { data, tableName, keys, setKeys, whereKeys, whereRaws = [] } = opts;
     const withAlias = 't';
@@ -73,6 +77,7 @@ const buildBatchUpdateQuery = (opts) => {
             message: '[batchUpdate] Missing required fields',
         });
     }
+    // ----------------------------------------
     const formattedData = data.map(obj => (0, pick_1.default)(obj, ...keys));
     const withValues = formattedData.map(obj => {
         const values = [];
@@ -92,6 +97,7 @@ const buildBatchUpdateQuery = (opts) => {
         return `(${values.toString()})`;
     });
     const withKeys = keys.map(key => (0, snakeCase_1.default)(String(key))).sort();
+    // ----------------------------------------
     const updateSets = [];
     for (const key of setKeys) {
         switch (typeof key) {
@@ -108,6 +114,7 @@ const buildBatchUpdateQuery = (opts) => {
             }
         }
     }
+    // ----------------------------------------
     const updateWheres = [];
     for (const key of whereKeys) {
         switch (typeof key) {
@@ -124,6 +131,7 @@ const buildBatchUpdateQuery = (opts) => {
             }
         }
     }
+    // ----------------------------------------
     return `WITH ${withAlias} (${withKeys}) AS (VALUES ${withValues})
 UPDATE "${tableName}"
 SET ${updateSets.join(', ')}

package/dist/utilities/request.utility.js

@@ -7,9 +7,10 @@ exports.getRequestRemark = exports.getRequestIp = exports.getRequestId = exports
 const rest_1 = require("@loopback/rest");
 const get_1 = __importDefault(require("lodash/get"));
 const multer_1 = __importDefault(require("multer"));
+// -------------------------------------------------------------------------
 const parseMultipartBody = (opts) => {
     const { storage: cStorage, request, response } = opts;
-    const storage = cStorage ?? multer_1.default.memoryStorage();
+    const storage = cStorage !== null && cStorage !== void 0 ? cStorage : multer_1.default.memoryStorage();
     const upload = (0, multer_1.default)({ storage });
     return new Promise((resolve, reject) => {
         upload.any()(request, response, (err) => {
@@ -22,18 +23,23 @@ const parseMultipartBody = (opts) => {
     });
 };
 exports.parseMultipartBody = parseMultipartBody;
+// -------------------------------------------------------------------------
 const getSchemaObject = (ctor) => {
     return ctor ? (0, rest_1.getModelSchemaRef)(ctor).definitions[ctor.name] : {};
 };
 exports.getSchemaObject = getSchemaObject;
+// -------------------------------------------------------------------------
 const getRequestId = (opts) => {
     return (0, get_1.default)(opts.request, 'requestId');
 };
 exports.getRequestId = getRequestId;
+// -------------------------------------------------------------------------
 const getRequestIp = (opts) => {
-    return (0, get_1.default)(opts.request, 'requestForwardedIp') ?? 'N/A';
+    var _a;
+    return (_a = (0, get_1.default)(opts.request, 'requestForwardedIp')) !== null && _a !== void 0 ? _a : 'N/A';
 };
 exports.getRequestIp = getRequestIp;
+// -------------------------------------------------------------------------
 const getRequestRemark = (opts) => {
     return (0, get_1.default)(opts.request, 'requestedRemark');
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minimaltech/node-infra",
-  "version": "0.5.9-22",
+  "version": "0.5.9-24",
   "description": "Minimal Technology - NodeJS Infrastructure - Loopback 4 Framework",
   "keywords": [
     "web",
@@ -141,13 +141,12 @@
     "@types/multer": "^2.0.0",
     "@types/node": "^24.7.2",
     "eslint": "^9.36.0",
-    "mocha": "^11.7.2",
     "prettier": "^3.6.2",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.16",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.9.3"
+    "typescript": "~5.9.3"
   },
   "sideEffects": false,
   "scripts": {