@autofleet/sadot 0.6.11 → 0.7.0-beta.2

package/dist/repository/value.js

@@ -73,11 +73,8 @@ exports.findValuesByModelIds = findValuesByModelIds;
  */
 const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     const names = Object.keys(valuesToUpdate);
-    logger_1.default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
-        names,
-        optionsKeys: options ? Object.keys(options) : null,
-        valuesToUpdate,
-        identifiers,
+    logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
+        names, options, valuesToUpdate, identifiers,
     });
     const { modelOptions, transaction } = options;
     const where = {
@@ -90,7 +87,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.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+        logger_1.default.info(`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,9 +24,15 @@ 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) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
+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) => (sort: CustomFieldSort[]) => {
+export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
+    replacementsMap: Record<string, string>;
+    scopeValue: string[];
+}) => {
     attributes?: undefined;
     order?: undefined;
     replacements?: undefined;

package/dist/scopes/filter.js

@@ -21,12 +21,36 @@ 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') {
+        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.
@@ -34,68 +58,25 @@ const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
  * @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) => (conditions) => {
+const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scopeValue: conditions, }) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
-    const ConditionNameRandomStr = (0, helpers_1.generateRandomString)();
-    const replacements = {};
-    replacements[ConditionNameRandomStr] = `${name}`;
     // Build the WHERE clause for custom field filtering
     const conditionsStrings = Object.entries(conditions)
-        .map(([key, condition]) => {
-        const replacemetKey = (0, helpers_1.generateRandomString)();
-        replacements[replacemetKey] = `${key}`;
-        const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
-        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 = (0, helpers_1.generateRandomString)();
-                    replacements[`${valRandom}`] = `${v}`;
-                    return castValueToJsonb(`:${valRandom}`);
-                }).join(',');
-                return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN ( ${values} ))`;
-            }
-            return condition
-                .map((c) => {
-                const valRep = (0, helpers_1.generateRandomString)();
-                replacements[valRep] = `${c.value}`;
-                const valueAsJsonb = castValueToJsonb(`:${valRep}`);
-                return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
-            }).join(AND_DELIMETER);
-        }
-        if (typeof condition === 'string' || typeof condition === 'number') {
-            const conditionRep = (0, helpers_1.generateRandomString)();
-            replacements[conditionRep] = `${condition}`;
-            const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
-            return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
-        }
-        if (condition?.operator) {
-            const valueRep = (0, helpers_1.generateRandomString)();
-            replacements[valueRep] = `${condition.value}`;
-            const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
-            return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
-        }
-        return false;
-    })
+        .map(([key, condition]) => buildConditionString(key, condition, replacements))
         .filter(Boolean);
     if (conditionsStrings.length === 0) {
-        return {};
+        return { replacements };
     }
-    const customFieldConditions = conditionsStrings.join(OR_DELIMETER);
-    const subQuery = `
-    SELECT cv.model_id
-    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 = :${ConditionNameRandomStr}
-    WHERE ${customFieldConditions}
-    GROUP BY cv.model_id
-    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
-  `.replace(/\n/g, '');
+    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}`;
     return {
         where: {
             id: {
@@ -107,28 +88,27 @@ const customFieldsFilterScope = (name) => (conditions) => {
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-const customFieldsSortScope = (name) => (sort) => {
+const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort }) => {
     if (!sort || sort.length === 0) {
         return {};
     }
     const randomStr = (0, helpers_1.generateRandomString)();
-    const replacements = {};
     const includes = Object.entries(sort).map(([key]) => {
-        const keyRandomReplacement = (0, helpers_1.generateRandomString)();
-        replacements[keyRandomReplacement] = `${key}`;
-        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 = :${keyRandomReplacement}
-                          ) 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 {
@@ -136,7 +116,7 @@ const customFieldsSortScope = (name) => (sort) => {
             include: includes,
         },
         order: orders,
-        replacements,
+        replacements: replacementsMap,
     };
 };
 exports.customFieldsSortScope = customFieldsSortScope;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.11",
+  "version": "0.7.0-beta.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -59,8 +59,8 @@
     "typescript": "^5.3.3",
     "typescript-eslint": "^0.0.1-alpha.0"
   },
-  "engines": {
-    "node": ">=16.0.0"
+  "peerDependencies": {
+    "@autofleet/sheilta": ">=1.4.0-beta.2"
   },
   "author": "Autofleet",
   "license": "ISC"

package/src/repository/value.ts

@@ -55,11 +55,8 @@ export const updateValues = async (
   options: FindOptions & { modelOptions?: ModelOptions } = {},
 ): Promise<CustomFieldValue[]> => {
   const names = Object.keys(valuesToUpdate);
-  logger.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
-    names,
-    optionsKeys: options ? Object.keys(options) : null,
-    valuesToUpdate,
-    identifiers,
+  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
+    names, options, valuesToUpdate, identifiers,
   });
   const { modelOptions, transaction } = options;
 
@@ -75,7 +72,7 @@ export const updateValues = async (
 
   const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
   if (fieldDefinitions.length !== names.length) {
-    logger.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+    logger.info(`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,19 +31,48 @@ 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') {
+    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.
@@ -54,72 +83,33 @@ const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
  */
 export const customFieldsFilterScope = (
   name: string,
-) => (conditions: Record<string, ConditionValue>): CustomFieldFilterOptions => {
+) => (
+  {
+    replacementsMap: replacements,
+    scopeValue: conditions,
+  }: { replacementsMap: Record<string, string>, scopeValue: Record<string, ConditionValue> },
+): CustomFieldFilterOptions => {
   if (!conditions || Object.keys(conditions).length === 0) {
     return {};
   }
-  const ConditionNameRandomStr = generateRandomString();
-  const replacements: Record<string, string> = {};
-  replacements[ConditionNameRandomStr] = `${name}`;
 
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
-    .map(
-      ([key, condition]) => {
-        const replacemetKey = generateRandomString();
-        replacements[replacemetKey] = `${key}`;
-        const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
-        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 = generateRandomString();
-              replacements[`${valRandom}`] = `${v}`;
-              return castValueToJsonb(`:${valRandom}`);
-            }).join(',');
-            return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN ( ${values} ))`;
-          }
-          return condition
-            .map((c) => {
-              const valRep = generateRandomString();
-              replacements[valRep] = `${c.value}`;
-              const valueAsJsonb = castValueToJsonb(`:${valRep}`);
-              return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
-            }).join(AND_DELIMETER);
-        }
-        if (typeof condition === 'string' || typeof condition === 'number') {
-          const conditionRep = generateRandomString();
-          replacements[conditionRep] = `${condition}`;
-          const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
-          return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
-        }
-        if (condition?.operator) {
-          const valueRep = generateRandomString();
-          replacements[valueRep] = `${condition.value}`;
-          const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
-          return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
-        }
-
-        return false;
-      },
-    )
-    .filter(Boolean);
+    .map(([key, condition]) => buildConditionString(key, condition, replacements))
+    .filter(Boolean) as string[];
+
   if (conditionsStrings.length === 0) {
-    return {};
+    return { replacements };
   }
-  const customFieldConditions = conditionsStrings.join(OR_DELIMETER);
-  const subQuery = `
-    SELECT cv.model_id
-    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 = :${ConditionNameRandomStr}
-    WHERE ${customFieldConditions}
-    GROUP BY cv.model_id
-    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
-  `.replace(/\n/g, '');
+
+  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}`;
   return {
     where: {
       id: {
@@ -134,28 +124,28 @@ export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
 
 export const customFieldsSortScope = (
   name: string,
-) => (sort: CustomFieldSort[]) => {
+) => ({ replacementsMap, scopeValue: sort }: { replacementsMap: Record<string, string>, scopeValue: string[] }) => {
   if (!sort || sort.length === 0) {
     return {};
   }
+
   const randomStr = generateRandomString();
-  const replacements: Record<string, string> = {};
   const includes = Object.entries(sort).map(([key]) => {
-    const keyRandomReplacement = generateRandomString();
-    replacements[keyRandomReplacement] = `${key}`;
-    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 = :${keyRandomReplacement}
-                          ) 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}`));
@@ -164,6 +154,6 @@ export const customFieldsSortScope = (
       include: includes,
     },
     order: orders,
-    replacements,
+    replacements: replacementsMap,
   };
 };