@autofleet/sadot 0.7.0-beta.1 → 0.7.0-beta.2.1

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, scopeValue }: {
-    replacementsMap: any;
-    scopeValue: any;
+export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap: replacements, scopeValue: conditions, }: {
+    replacementsMap: Record<string, string>;
+    scopeValue: Record<string, ConditionValue>;
 }) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
 export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
-    replacementsMap: any;
-    scopeValue: any;
+    replacementsMap: Record<string, string>;
+    scopeValue: string[];
 }) => {
     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: any;
+    replacements: Record<string, string>;
 };
 export {};

package/dist/scopes/filter.js

@@ -21,6 +21,42 @@ const castIfNeeded = (conditionValue) => {
     return '';
 };
 const AND_DELIMETER = ' AND ';
+const OR_DELIMETER = ' OR ';
+const CD_TABLE_ALIAS = 'cd';
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = 'cv';
+const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
+const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
+/**
+ * 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' || typeof condition === 'number') {
+        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.
@@ -28,52 +64,16 @@ const AND_DELIMETER = ' AND ';
  * @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, scopeValue }) => {
-    const conditions = scopeValue;
-    const replacements = replacementsMap;
-    console.log('filter replacementsMap:', replacements);
+const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scopeValue: conditions, }) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
     // Build the WHERE clause for custom field filtering
     const conditionsStrings = Object.entries(conditions)
-        .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;
-    })
+        .map(([key, condition]) => buildConditionString(key, condition, replacements))
         .filter(Boolean);
     if (conditionsStrings.length === 0) {
-        return {
-            replacements,
-        };
+        return { replacements };
     }
     const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
     const subQuery = `${'SELECT model_id FROM ('
@@ -100,21 +100,21 @@ const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort })
     }
     const randomStr = (0, helpers_1.generateRandomString)();
     const includes = Object.entries(sort).map(([key]) => {
-        const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
-        console.log('sort replacemetKey:', replacemetKey);
-        return ([
+        const replacementKey = Object.keys(replacementsMap)
+            .find((randomString) => replacementsMap[randomString] === 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 = :${replacemetKey}
-                          ) 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 = :${replacementKey}
+        ) AS CustomFieldAggregation
+      )`),
+            randomStr,
+        ];
     });
     const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
     return {

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.2.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -9,7 +9,7 @@
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit --runInBand",
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
-    "build-to-local-repo": "npm run build && cp -r dist/* ../task-ms/node_modules/@autofleet/sadot/dist",
+    "build-to-local-repo": "npm run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",
     "watch": "npm-watch build-to-local-repo",
     "publish-dev": "npm run build && npm publish --tag dev"
@@ -59,6 +59,12 @@
     "typescript": "^5.3.3",
     "typescript-eslint": "^0.0.1-alpha.0"
   },
+  "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

@@ -31,12 +31,55 @@ export type CustomFieldFilterOptions = {
 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 ';
+const OR_DELIMETER = ' OR ';
+
+const CD_TABLE_ALIAS = 'cd';
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = 'cv';
+const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
+const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
+
+/**
+ * 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'|| typeof condition === 'number') {
+    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.
@@ -47,54 +90,22 @@ const AND_DELIMETER = ' AND ';
  */
 export const customFieldsFilterScope = (
   name: string,
-) => ({ replacementsMap, scopeValue }): CustomFieldFilterOptions => {
-  const conditions: Record<string, ConditionValue> = scopeValue;
-  const replacements: Record<string, string> = replacementsMap;
-  console.log('filter replacementsMap:', replacements);
+) => (
+  {
+    replacementsMap: replacements,
+    scopeValue: conditions,
+  }: { replacementsMap: Record<string, string>, scopeValue: Record<string, ConditionValue> },
+): CustomFieldFilterOptions => {
   if (!conditions || Object.keys(conditions).length === 0) {
     return {};
   }
+
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
-    .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);
+    .map(([key, condition]) => buildConditionString(key, condition, replacements))
+    .filter(Boolean) as string[];
   if (conditionsStrings.length === 0) {
-    return {
-      replacements,
-    };
+    return { replacements };
   }
   const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
   const subQuery = `${'SELECT model_id FROM ('
@@ -118,27 +129,28 @@ export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
 
 export const customFieldsSortScope = (
   name: string,
-) => ({ replacementsMap, scopeValue: sort }) => {
+) => ({ replacementsMap, scopeValue: sort }: { replacementsMap: Record<string, string>, scopeValue: string[] }) => {
   if (!sort || sort.length === 0) {
     return {};
   }
+
   const randomStr = generateRandomString();
   const includes = Object.entries(sort).map(([key]) => {
-    const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
-    console.log('sort replacemetKey:', replacemetKey);
-    return ([
+    const replacementKey = Object.keys(replacementsMap)
+      .find((randomString) => replacementsMap[randomString] === key);
+    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 = :${replacemetKey}
-                          ) 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 = :${replacementKey}
+        ) AS CustomFieldAggregation
+      )`),
+      randomStr,
+    ];
   });
 
   const orders = Object.entries(sort).map(([, value]) => Sequelize.literal(`"${randomStr}" ${value}`));

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

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