@autofleet/sadot 0.6.7 → 0.6.8-beta.1

package/dist/scopes/filter.d.ts

@@ -15,23 +15,19 @@ export type CustomFieldSort = {
 };
 export type CustomFieldFilterOptions = {
     where?: WhereOptions;
+    replacements?: Record<string, string>;
 };
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
 export declare const customFieldsFilterScope: (name: string) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
 export declare const customFieldsSortScope: (name: string) => (sort: CustomFieldSort[]) => {
     attributes?: undefined;
     order?: undefined;
+    replacements?: undefined;
 } | {
     attributes: {
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
     order: import("sequelize/types/utils").Literal[];
+    replacements: Record<string, string>;
 };
 export {};

package/dist/scopes/filter.js

@@ -1,49 +1,68 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterScope = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
+const moment_1 = __importDefault(require("moment"));
+const helpers_1 = require("../utils/helpers");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 const castIfNeeded = (conditionValue) => {
-    if (!Number.isNaN(Date.parse(conditionValue))) {
+    if (moment_1.default.isDate(conditionValue)) {
         return '::timestamp';
     }
+    if (!Number.isNaN(Number(conditionValue))) {
+        return '::numeric';
+    }
     return '';
 };
 const AND_DELIMETER = ' AND ';
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
 const customFieldsFilterScope = (name) => (conditions) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
+    const randomStr = (0, helpers_1.generateRandomString)();
+    const replacementMapPrefix = `customFieldsFilterScopeConditionMap_${randomStr}`;
+    const replacements = {};
+    replacements[`customFieldsFilterScopeConditionName_${randomStr}`] = `${name}`;
     // Build the WHERE clause for custom field filtering
     const conditionsStrings = Object.entries(conditions)
-        .map(([key, condition]) => {
+        .map(([key, condition], index) => {
+        const replacemetKey = `${replacementMapPrefix}Key${index}`;
+        replacements[replacemetKey] = `${key}`;
         if (Array.isArray(condition)) {
             if (condition.length === 0) {
                 // if empty array, the condition is ignored
                 return false;
             }
             if (typeof condition[0] === 'string') {
-                const values = condition.map((v) => `'${v}'`).join(',');
-                return `(custom_fields->>'${key}') IN (${values})`;
+                const values = condition.map((v) => {
+                    const valRandom = (0, helpers_1.generateRandomString)();
+                    replacements[`${valRandom}`] = `${v}`;
+                    return ` :${valRandom} `;
+                }).join(',');
+                return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
             }
             return condition
-                .map((c) => `(custom_fields->>'${key}')${castIfNeeded(c.value)} ${c.operator} '${c.value}'`).join(AND_DELIMETER);
+                .map((c, cIndex) => {
+                const valRep = `${replacementMapPrefix}Values${index}${cIndex}`;
+                replacements[valRep] = `${c.value}`;
+                return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
         }
         if (typeof condition === 'string') {
-            return `(custom_fields->>'${key}')${castIfNeeded(condition)} = '${condition}'`;
+            const conditionRep = `${replacementMapPrefix}Condition${index}`;
+            replacements[conditionRep] = `${condition}`;
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
         }
         if (condition?.operator) {
-            return `(custom_fields->>'${key}')${castIfNeeded(condition.value)} ${condition.operator} '${condition.value}'`;
+            const valueRep = `${replacementMapPrefix}Values${index}`;
+            replacements[valueRep] = `${condition.value}`;
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
         }
         return false;
     })
@@ -56,15 +75,16 @@ const customFieldsFilterScope = (name) => (conditions) => {
         + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
         + 'FROM custom_field_values AS cv '
         + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
-        + `AND cd.model_type = '${name}' `
+        + `AND cd.model_type = :${`customFieldsFilterScopeConditionName_${randomStr}`} `
         + 'GROUP BY cv.model_id'
-        + ') AS CustomFieldAggregation WHERE '}${customFieldConditions}`;
+        + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
     return {
         where: {
             id: {
                 [sequelize_1.Op.in]: sequelize_typescript_1.Sequelize.literal(`(${subQuery})`),
             },
         },
+        replacements,
     };
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
@@ -73,26 +93,33 @@ const customFieldsSortScope = (name) => (sort) => {
     if (!sort || sort.length === 0) {
         return {};
     }
-    const includes = Object.entries(sort).map(([key]) => ([
-        sequelize_typescript_1.Sequelize.literal(`(
+    const randomStr = (0, helpers_1.generateRandomString)();
+    const replacements = {};
+    const includes = Object.entries(sort).map(([key], index) => {
+        const keyReplacement = `key_${randomStr}_${index}`;
+        replacements[`keyCustomFields_${randomStr}_${index}`] = `customFields_${key}`;
+        replacements[keyReplacement] = `${key}`;
+        return ([
+            sequelize_typescript_1.Sequelize.literal(`(
             SELECT value
             FROM (SELECT cv.model_id, cv.value
                   FROM custom_field_values AS cv INNER JOIN custom_field_definitions AS cd
                     ON cv.custom_field_definition_id = cd.id
                     AND cd.model_type = '${name}'
                     WHERE cv.model_id = "${name}"."id"
-                          AND cd.name = '${key}'
+                          AND cd.name = :${keyReplacement}
                           ) AS CustomFieldAggregation
             )
-          `),
-        `customFields_${key}`,
-    ]));
-    const orders = Object.entries(sort).map(([key, value]) => sequelize_typescript_1.Sequelize.literal(`"customFields_${key}" ${value}`));
+          `), randomStr,
+        ]);
+    });
+    const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
     return {
         attributes: {
             include: includes,
         },
         order: orders,
+        replacements,
     };
 };
 exports.customFieldsSortScope = customFieldsSortScope;

package/dist/tests/helpers/database-config.d.ts

@@ -10,7 +10,10 @@ declare const _default: {
             underscored: boolean;
             underscoredAll: boolean;
         };
-        logging: boolean;
+        logging: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
     };
 };
 export default _default;

package/dist/tests/helpers/database-config.js

@@ -12,6 +12,6 @@ exports.default = {
             underscored: true,
             underscoredAll: true,
         },
-        logging: false,
+        logging: console.log,
     },
 };

package/dist/utils/helpers/index.d.ts

@@ -21,5 +21,6 @@ interface CustomFieldsSearchPayload {
     where: WhereOptions;
     replacements: BindOrReplacements;
 }
+export declare const generateRandomString: (length?: number) => string;
 export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
 export {};

package/dist/utils/helpers/index.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCustomFieldSearchQueryPayload = void 0;
+exports.generateCustomFieldSearchQueryPayload = exports.generateRandomString = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const constants_1 = require("../constants");
+const generateRandomString = (length = 5) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+};
+exports.generateRandomString = generateRandomString;
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
     constants_1.CustomFieldDefinitionType.DATETIME,
     constants_1.CustomFieldDefinitionType.DATE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.7",
+  "version": "0.6.8-beta.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -36,6 +36,7 @@
     "@autofleet/logger": "^2.0.5",
     "express": "^4.18.2",
     "joi": "^17.7.0",
+    "moment": "^2.30.1",
     "pg": "^8.10.0",
     "reflect-metadata": "^0.1.13",
     "sequelize": "^6.31.1",
@@ -52,12 +53,12 @@
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
     "npm-watch": "^0.11.0",
+    "ts-jest": "^29.1.2",
     "ts-node": "^8.6.2",
     "typescript": "^5.3.3",
     "typescript-eslint": "^0.0.1-alpha.0"
   },
   "author": "Autofleet",
   "license": "ISC"
-}
+}

package/src/scopes/filter.ts

@@ -2,6 +2,8 @@
 import { Op, type WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
+import moment from 'moment';
+import { generateRandomString } from '../utils/helpers';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
@@ -22,51 +24,68 @@ export type CustomFieldSort = {
 }
 
 export type CustomFieldFilterOptions = {
-  where?: WhereOptions;
+    where?: WhereOptions;
+    replacements?: Record<string, string>;
 }
 
 const castIfNeeded = (conditionValue: string): string => {
-  if (!Number.isNaN(Date.parse(conditionValue))) {
+  if (moment.isDate(conditionValue)) {
     return '::timestamp';
+  } if (!Number.isNaN(Number(conditionValue))) {
+    return '::numeric';
   }
   return '';
 };
 const AND_DELIMETER = ' AND ';
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
+
 export const customFieldsFilterScope = (
   name: string,
 ) => (conditions: Record<string, ConditionValue>): CustomFieldFilterOptions => {
   if (!conditions || Object.keys(conditions).length === 0) {
     return {};
   }
+  const randomStr = generateRandomString();
+  const replacementMapPrefix = `customFieldsFilterScopeConditionMap_${randomStr}`;
+  const replacements: Record<string, string> = {};
+  replacements[`customFieldsFilterScopeConditionName_${randomStr}`] = `${name}`;
+
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
     .map(
-      ([key, condition]) => {
+      ([key, condition], index) => {
+        const replacemetKey = `${replacementMapPrefix}Key${index}`;
+        replacements[replacemetKey] = `${key}`;
         if (Array.isArray(condition)) {
           if (condition.length === 0) {
             // if empty array, the condition is ignored
             return false;
           }
           if (typeof condition[0] === 'string') {
-            const values = condition.map((v) => `'${v}'`).join(',');
-            return `(custom_fields->>'${key}') IN (${values})`;
+            const values = condition.map((v) => {
+              const valRandom = generateRandomString();
+              replacements[`${valRandom}`] = `${v}`;
+              return ` :${valRandom} `;
+            }).join(',');
+            return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
           }
           return condition
-            .map((c) => `(custom_fields->>'${key}')${castIfNeeded(c.value)} ${c.operator} '${c.value}'`).join(AND_DELIMETER);
+            .map((c, cIndex) => {
+              const valRep = `${replacementMapPrefix}Values${index}${cIndex}`;
+              replacements[valRep] = `${c.value}`;
+              return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
         }
         if (typeof condition === 'string') {
-          return `(custom_fields->>'${key}')${castIfNeeded(condition)} = '${condition}'`;
+          const conditionRep = `${replacementMapPrefix}Condition${index}`;
+          replacements[conditionRep] = `${condition}`;
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
         }
         if (condition?.operator) {
-          return `(custom_fields->>'${key}')${castIfNeeded(condition.value)} ${condition.operator} '${condition.value}'`;
+          const valueRep = `${replacementMapPrefix}Values${index}`;
+          replacements[valueRep] = `${condition.value}`;
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
         }
+
         return false;
       },
     )
@@ -75,21 +94,20 @@ export const customFieldsFilterScope = (
     return {};
   }
   const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
-
   const subQuery = `${'SELECT model_id FROM ('
     + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
     + 'FROM custom_field_values AS cv '
     + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
-    + `AND cd.model_type = '${name}' `
+    + `AND cd.model_type = :${`customFieldsFilterScopeConditionName_${randomStr}`} `
     + 'GROUP BY cv.model_id'
-    + ') AS CustomFieldAggregation WHERE '}${customFieldConditions}`;
-
+    + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
   return {
     where: {
       id: {
         [Op.in]: Sequelize.literal(`(${subQuery})`),
       },
     },
+    replacements,
   };
 };
 
@@ -101,8 +119,13 @@ export const customFieldsSortScope = (
   if (!sort || sort.length === 0) {
     return {};
   }
-  const includes = Object.entries(sort).map(([key]) =>
-    ([
+  const randomStr = generateRandomString();
+  const replacements: Record<string, string> = {};
+  const includes = Object.entries(sort).map(([key], index) => {
+    const keyReplacement = `key_${randomStr}_${index}`;
+    replacements[`keyCustomFields_${randomStr}_${index}`] = `customFields_${key}`;
+    replacements[keyReplacement] = `${key}`;
+    return ([
       Sequelize.literal(`(
             SELECT value
             FROM (SELECT cv.model_id, cv.value
@@ -110,18 +133,19 @@ export const customFieldsSortScope = (
                     ON cv.custom_field_definition_id = cd.id
                     AND cd.model_type = '${name}'
                     WHERE cv.model_id = "${name}"."id"
-                          AND cd.name = '${key}'
+                          AND cd.name = :${keyReplacement}
                           ) AS CustomFieldAggregation
             )
-          `),
-      `customFields_${key}`,
-    ]));
+          `), randomStr,
+    ]);
+  });
 
-  const orders = Object.entries(sort).map(([key, value]) => Sequelize.literal(`"customFields_${key}" ${value}`));
+  const orders = Object.entries(sort).map(([, value]) => Sequelize.literal(`"${randomStr}" ${value}`));
   return {
     attributes: {
       include: includes,
     },
     order: orders,
+    replacements,
   };
 };

package/src/tests/helpers/database-config.ts

@@ -10,6 +10,6 @@ export default {
       underscored: true,
       underscoredAll: true,
     },
-    logging: false,
+    logging: console.log,
   },
 };

package/src/utils/helpers/index.ts

@@ -25,6 +25,11 @@ interface CustomFieldsSearchPayload {
   replacements: BindOrReplacements;
 }
 
+export const generateRandomString = (length = 5): string => {
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+};
+
 export const generateCustomFieldSearchQueryPayload = (
   searchTerm: string,
   model: ModelStatic,