@autofleet/sadot 0.7.0-beta.2 → 0.7.0-beta.2.2

package/dist/repository/value.js

@@ -73,8 +73,11 @@ exports.findValuesByModelIds = findValuesByModelIds;
  */
 const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     const names = Object.keys(valuesToUpdate);
-    logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
-        names, options, valuesToUpdate, identifiers,
+    logger_1.default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
+        names,
+        optionsKeys: options ? Object.keys(options) : null,
+        valuesToUpdate,
+        identifiers,
     });
     const { modelOptions, transaction } = options;
     const where = {
@@ -87,7 +90,7 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
     const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
     if (fieldDefinitions.length !== names.length) {
-        logger_1.default.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+        logger_1.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
         const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
         throw new errors_1.MissingDefinitionError(missingDefinitions);
     }

package/dist/scopes/filter.d.ts

@@ -24,14 +24,14 @@ export type CustomFieldFilterOptions = {
  * @param name - The model type name used to join custom_field_definitions.
  * @returns A function that takes conditions and returns the Sequelize options object.
  */
-export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap: replacements, scopeValue: conditions, }: {
-    replacementsMap: Record<string, string>;
-    scopeValue: Record<string, ConditionValue>;
+export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap, scopeValue }: {
+    replacementsMap: any;
+    scopeValue: any;
 }) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
 export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
-    replacementsMap: Record<string, string>;
-    scopeValue: string[];
+    replacementsMap: any;
+    scopeValue: any;
 }) => {
     attributes?: undefined;
     order?: undefined;
@@ -41,6 +41,6 @@ export declare const customFieldsSortScope: (name: string) => ({ replacementsMap
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
     order: import("sequelize/types/utils").Literal[];
-    replacements: Record<string, string>;
+    replacements: any;
 };
 export {};

package/dist/scopes/filter.js

@@ -21,36 +21,6 @@ const castIfNeeded = (conditionValue) => {
     return '';
 };
 const AND_DELIMETER = ' AND ';
-/**
- * Helper function to build condition strings for the WHERE clause.
- */
-// eslint-disable-next-line max-len
-const buildConditionString = (key, condition, replacements) => {
-    const replacementKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
-    if (!replacementKey)
-        return false;
-    if (Array.isArray(condition)) {
-        if (condition.length === 0)
-            return false;
-        if (typeof condition[0] === 'string') {
-            const values = condition.map((v) => `:${replacements[v]}`).join(',');
-            return `(custom_fields->> :${replacementKey}) IN (${values})`;
-        }
-        return condition.map((c) => {
-            const valRep = replacements[c.value];
-            return `(custom_fields->> :${replacementKey})${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
-        }).join(AND_DELIMETER);
-    }
-    if (typeof condition === 'string') {
-        const conditionRep = replacements[condition];
-        return `(custom_fields->> :${replacementKey}) ${castIfNeeded(condition)} = :${conditionRep}`;
-    }
-    if (condition?.operator) {
-        const valueRep = replacements[condition.value];
-        return `(custom_fields->> :${replacementKey}) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
-    }
-    return false;
-};
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -58,16 +28,51 @@ const buildConditionString = (key, condition, replacements) => {
  * @param name - The model type name used to join custom_field_definitions.
  * @returns A function that takes conditions and returns the Sequelize options object.
  */
-const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scopeValue: conditions, }) => {
+const customFieldsFilterScope = (name) => ({ replacementsMap, scopeValue }) => {
+    const conditions = scopeValue;
+    const replacements = replacementsMap;
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
     // Build the WHERE clause for custom field filtering
     const conditionsStrings = Object.entries(conditions)
-        .map(([key, condition]) => buildConditionString(key, condition, replacements))
+        .map(([key, condition]) => {
+        const replacemetKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
+        if (!replacemetKey)
+            return false;
+        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) => {
+                    const valRandom = Object.keys(replacements).find((randomString) => replacements[randomString] === v);
+                    return ` :${valRandom} `;
+                }).join(',');
+                return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
+            }
+            return condition
+                .map((c) => {
+                const valRep = Object.keys(replacements).find((key) => replacements[key] === c.value);
+                return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
+        }
+        if (typeof condition === 'string') {
+            const conditionRep = Object.keys(replacements).find((key) => replacements[key] === condition);
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
+        }
+        if (condition?.operator) {
+            const valueRep = Object.keys(replacements).find((key) => replacements[key] === condition.value);
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
+        }
+        return false;
+    })
         .filter(Boolean);
     if (conditionsStrings.length === 0) {
-        return { replacements };
+        return {
+            replacements,
+        };
     }
     const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
     const subQuery = `${'SELECT model_id FROM ('
@@ -94,21 +99,21 @@ const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort })
     }
     const randomStr = (0, helpers_1.generateRandomString)();
     const includes = Object.entries(sort).map(([key]) => {
-        const replacementKey = Object.keys(replacementsMap)
-            .find((randomString) => replacementsMap[randomString] === key);
-        return [
+        const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+        console.log('sort replacemetKey:', replacemetKey);
+        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 = :${replacementKey}
-        ) AS CustomFieldAggregation
-      )`),
-            randomStr,
-        ];
+            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 = :${replacemetKey}
+                          ) AS CustomFieldAggregation
+            )
+          `), randomStr,
+        ]);
     });
     const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.0-beta.2",
+  "version": "0.7.0-beta.2.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -62,6 +62,9 @@
   "peerDependencies": {
     "@autofleet/sheilta": ">=1.4.0-beta.2"
   },
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "author": "Autofleet",
   "license": "ISC"
 }

package/src/repository/value.ts

@@ -55,8 +55,11 @@ export const updateValues = async (
   options: FindOptions & { modelOptions?: ModelOptions } = {},
 ): Promise<CustomFieldValue[]> => {
   const names = Object.keys(valuesToUpdate);
-  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
-    names, options, valuesToUpdate, identifiers,
+  logger.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
+    names,
+    optionsKeys: options ? Object.keys(options) : null,
+    valuesToUpdate,
+    identifiers,
   });
   const { modelOptions, transaction } = options;
 
@@ -72,7 +75,7 @@ export const updateValues = async (
 
   const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
   if (fieldDefinitions.length !== names.length) {
-    logger.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+    logger.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
     const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
     throw new MissingDefinitionError(missingDefinitions);
   }

package/src/scopes/filter.ts

@@ -13,67 +13,31 @@ const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
  * More types to be added (TBA).
  */
 type ConditionWithOperator = {
-    operator: string;
-    value: string;
+  operator: string;
+  value: string;
 };
 export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
 
 export type CustomFieldSort = {
-    field: string;
-    direction: 'ASC' | 'DESC';
+  field: string;
+  direction: 'ASC' | 'DESC';
 }
 
 export type CustomFieldFilterOptions = {
-    where?: WhereOptions;
-    replacements?: Record<string, string>;
+  where?: WhereOptions;
+  replacements?: Record<string, string>;
 }
 
 const castIfNeeded = (conditionValue: string): string => {
   if (moment.isDate(conditionValue)) {
     return '::timestamp';
-  }
-  if (!Number.isNaN(Number(conditionValue))) {
+  } if (!Number.isNaN(Number(conditionValue))) {
     return '::numeric';
   }
   return '';
 };
 const AND_DELIMETER = ' AND ';
 
-/**
- * Helper function to build condition strings for the WHERE clause.
- */
-// eslint-disable-next-line max-len
-const buildConditionString = (key: string, condition: ConditionValue | ConditionValue[], replacements: Record<string, string>): string | false => {
-  const replacementKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
-  if (!replacementKey) return false;
-
-  if (Array.isArray(condition)) {
-    if (condition.length === 0) return false;
-
-    if (typeof condition[0] === 'string') {
-      const values = condition.map((v) => `:${replacements[v]}`).join(',');
-      return `(custom_fields->> :${replacementKey}) IN (${values})`;
-    }
-
-    return condition.map((c) => {
-      const valRep = replacements[c.value];
-      return `(custom_fields->> :${replacementKey})${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
-    }).join(AND_DELIMETER);
-  }
-
-  if (typeof condition === 'string') {
-    const conditionRep = replacements[condition];
-    return `(custom_fields->> :${replacementKey}) ${castIfNeeded(condition)} = :${conditionRep}`;
-  }
-
-  if (condition?.operator) {
-    const valueRep = replacements[condition.value];
-    return `(custom_fields->> :${replacementKey}) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
-  }
-
-  return false;
-};
-
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -83,33 +47,62 @@ const buildConditionString = (key: string, condition: ConditionValue | Condition
  */
 export const customFieldsFilterScope = (
   name: string,
-) => (
-  {
-    replacementsMap: replacements,
-    scopeValue: conditions,
-  }: { replacementsMap: Record<string, string>, scopeValue: Record<string, ConditionValue> },
-): CustomFieldFilterOptions => {
+) => ({ replacementsMap, scopeValue }): CustomFieldFilterOptions => {
+  const conditions: Record<string, ConditionValue> = scopeValue;
+  const replacements: Record<string, string> = replacementsMap;
   if (!conditions || Object.keys(conditions).length === 0) {
     return {};
   }
-
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
-    .map(([key, condition]) => buildConditionString(key, condition, replacements))
-    .filter(Boolean) as string[];
-
+    .map(
+      ([key, condition]) => {
+        const replacemetKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
+        if (!replacemetKey) return false;
+
+        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) => {
+              const valRandom = Object.keys(replacements).find((randomString) => replacements[randomString] === v);
+              return ` :${valRandom} `;
+            }).join(',');
+            return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
+          }
+          return condition
+            .map((c) => {
+              const valRep = Object.keys(replacements).find((key) => replacements[key] === c.value);
+              return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
+        }
+        if (typeof condition === 'string') {
+          const conditionRep = Object.keys(replacements).find((key) => replacements[key] === condition);
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
+        }
+        if (condition?.operator) {
+          const valueRep = Object.keys(replacements).find((key) => replacements[key] === condition.value);
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
+        }
+        return false;
+      },
+    )
+    .filter(Boolean);
   if (conditionsStrings.length === 0) {
-    return { replacements };
+    return {
+      replacements,
+    };
   }
-
   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}'`
-    + 'GROUP BY cv.model_id'
-    + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
+  + '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}'`
+  + 'GROUP BY cv.model_id'
+  + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
   return {
     where: {
       id: {
@@ -124,28 +117,27 @@ export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
 
 export const customFieldsSortScope = (
   name: string,
-) => ({ replacementsMap, scopeValue: sort }: { replacementsMap: Record<string, string>, scopeValue: string[] }) => {
+) => ({ replacementsMap, scopeValue: sort }) => {
   if (!sort || sort.length === 0) {
     return {};
   }
-
   const randomStr = generateRandomString();
   const includes = Object.entries(sort).map(([key]) => {
-    const replacementKey = Object.keys(replacementsMap)
-      .find((randomString) => replacementsMap[randomString] === key);
-    return [
+    const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+    console.log('sort replacemetKey:', replacemetKey);
+    return ([
       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 = :${replacementKey}
-        ) AS CustomFieldAggregation
-      )`),
-      randomStr,
-    ];
+            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 = :${replacemetKey}
+                          ) AS CustomFieldAggregation
+            )
+          `), randomStr,
+    ]);
   });
 
   const orders = Object.entries(sort).map(([, value]) => Sequelize.literal(`"${randomStr}" ${value}`));