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

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,42 +21,6 @@ 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.
@@ -64,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 ('
@@ -100,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.1",
+  "version": "0.7.0-beta.2.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/scopes/filter.ts

@@ -13,73 +13,30 @@ 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 ';
-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.
@@ -90,31 +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: {
@@ -129,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}`));