@autofleet/sadot 0.10.2 → 0.10.3

package/src/scopes/helpers/filter.helpers.ts

@@ -0,0 +1,227 @@
+import type { WhereOptions } from 'sequelize';
+
+/**
+ * Type representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+export type ConditionWithOperator = {
+  operator: string;
+  value: string;
+};
+export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+
+export type CustomFieldSort = {
+  field: string;
+  direction: 'ASC' | 'DESC';
+}
+
+export type CustomFieldFilterOptions = {
+  where?: WhereOptions;
+  replacements?: Record<string, string>;
+}
+
+export enum SubQueryType {
+  VALUES = 'values',
+  ENTRIES = 'entries',
+}
+
+export const isConditionStringArray = (input: any): input is string[] => Array.isArray(input) && typeof input[0] === 'string';
+export const isBooleanString = (input: string): boolean => ['true', 'false'].includes(input.toString());
+export const isDate = (input: any): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+
+export const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
+export const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
+export const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
+export const castValueToJsonbNumeric = (value: string) => castValueToJsonb(value, 'numeric');
+export const castIfNeeded = (columnName: string, conditionValue: string): string => {
+  if (isDate(conditionValue)) {
+    return castValueToJsonb(columnName, 'timestamp');
+  }
+  return columnName;
+};
+
+export const AND_DELIMITER = ' AND ';
+export const OR_DELIMITER = ' OR ';
+export const CD_TABLE_ALIAS = 'cd';
+export const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+export const CV_TABLE_ALIAS = 'cv';
+export const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
+export const CE_TABLE_ALIAS = 'ce';
+
+const getSingleConditionWithOperator = (value: any, operator: string, replacementKey: string, reverseReplacementsMap: Map<string, string>) => {
+  let type = 'text';
+  if (isDate(value)) {
+    type = 'date';
+  } else if (!Number.isNaN(Number(value))) {
+    type = 'numeric';
+  } else if (isBooleanString(value)) {
+    type = 'boolean';
+  }
+  const replacedValue = reverseReplacementsMap.get(value);
+
+  return `(jsonb_extract_path_text(${CE_TABLE_ALIAS}.custom_fields, :${replacementKey})::${type}) ${operator} :${replacedValue}`;
+};
+
+const getFormattedValue = (value: string) => {
+  let formattedValue: string | number | boolean = value;
+  if (isBooleanString(value)) {
+    formattedValue = value === 'true';
+  } else if (!Number.isNaN(Number(value))) {
+    formattedValue = Number(value);
+  }
+
+  return formattedValue;
+};
+
+const getJSONSubQuery = (value: string, key: string) => {
+  const formattedValue = getFormattedValue(value);
+  const jsonQuery = JSON.stringify({ [key]: formattedValue });
+  let jsonQueryWithStringBoolean;
+  if (isBooleanString(value)) {
+    jsonQueryWithStringBoolean = `${CE_TABLE_ALIAS}.custom_fields @> '${JSON.stringify({ [key]: value })}'`;
+  }
+  return `
+    (
+      ${jsonQueryWithStringBoolean ? `${jsonQueryWithStringBoolean} OR` : ''}
+      ${CE_TABLE_ALIAS}.custom_fields @> '${jsonQuery}'
+    )
+  `;
+};
+
+export const getFilterCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, conditionsStrings: Array<string | boolean>): string => {
+  switch (queryType) {
+    case SubQueryType.VALUES:
+      return `
+        SELECT ${CV_TABLE_ALIAS}.model_id
+        FROM custom_field_values AS ${CV_TABLE_ALIAS}
+        INNER JOIN custom_field_definitions AS ${CD_TABLE_ALIAS} ON ${CV_TABLE_ALIAS}.custom_field_definition_id = ${CD_TABLE_ALIAS}.id
+        ${AND_DELIMITER}${CD_TABLE_ALIAS}.model_type = '${modelType}'
+        WHERE ${conditionsStrings.join(OR_DELIMITER)}
+        ${AND_DELIMITER}${CV_TABLE_ALIAS}.deleted_at IS NULL${AND_DELIMITER}${CD_TABLE_ALIAS}.deleted_at IS NULL
+        GROUP BY ${CV_TABLE_ALIAS}.model_id
+        HAVING COUNT(DISTINCT ${CV_TABLE_ALIAS}.custom_field_definition_id) = ${conditionsStrings.length}
+      `.replace(/\n/g, '');
+    case SubQueryType.ENTRIES:
+      return `
+        SELECT ce.model_id
+        FROM custom_field_entries ce
+        JOIN custom_field_definitions cfd
+        ON ce.model_type = cfd.model_type
+        AND ce.entity_id = cfd.entity_id
+        WHERE
+          cfd.deleted_at IS NULL AND
+          ${conditionsStrings.join(AND_DELIMITER)}
+      `;
+    default:
+      throw new Error('Invalid query type');
+  }
+};
+
+export const getSortCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, replacementKey: string): string => {
+  switch (queryType) {
+    case SubQueryType.VALUES:
+      return `(
+              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_DELIMITER}cd.model_type = '${modelType}'
+                      WHERE cv.model_id = "${modelType}"."id"
+                            ${AND_DELIMITER}cd.name = :${replacementKey}
+                            ) AS CustomFieldAggregation
+              )
+            `;
+    case SubQueryType.ENTRIES:
+      return `(
+        SELECT
+            customFields.value
+        FROM
+            custom_field_entries AS ${CE_TABLE_ALIAS},
+            jsonb_each_text(custom_fields) AS customFields
+        WHERE
+          customFields.key = :${replacementKey}${AND_DELIMITER}
+          ${CE_TABLE_ALIAS}.model_type = '${modelType}'${AND_DELIMITER}
+          ${CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
+        )
+      `;
+    default:
+      throw new Error('Invalid query type');
+  }
+};
+
+export const formatConditionsForValues = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
+  const replacementKey = reverseReplacementsMap.get(key);
+  if (!replacementKey) {
+    return false;
+  }
+
+  const columnCondition = `(${CD_NAME_COLUMN} = :${replacementKey})`;
+  if (Array.isArray(condition)) {
+    if (condition.length === 0) {
+      // if empty array, the condition is ignored
+      return false;
+    }
+
+    if (isConditionStringArray(condition)) {
+      const values = condition.flatMap((v) => {
+        const valRandom = reverseReplacementsMap.get(v);
+        if (isBooleanString(v)) {
+          return [castValueToJsonbText(`:${valRandom}`), castValueToJsonbBoolean(`:${valRandom}`)];
+        }
+        if (!Number.isNaN(Number(v))) {
+          return castValueToJsonbNumeric(`:${valRandom}`);
+        }
+        return castValueToJsonbText(`:${valRandom}`);
+      }).join(',');
+      return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${values}))`;
+    }
+    return condition.map((c) => {
+      const valRep = reverseReplacementsMap.get(c.value);
+      const valueAsJsonb = castValueToJsonbText(`:${valRep}`);
+
+      return `(${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
+    }).join(AND_DELIMITER);
+  }
+  if (typeof condition === 'string' || typeof condition === 'number') {
+    const conditionRep = reverseReplacementsMap.get(condition);
+    const valueAsJsonb = !Number.isNaN(Number(condition)) ? castValueToJsonbNumeric(`:${conditionRep}`) : castValueToJsonbText(`:${conditionRep}`);
+    const valueAsJsonbBoolean = isBooleanString(condition) ? `${OR_DELIMITER}${CV_VALUE_COLUMN} = ${castValueToJsonbBoolean(`:${conditionRep}`)}` : '';
+    return `(${columnCondition}${AND_DELIMITER}(${castIfNeeded(CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
+  }
+  if (condition?.operator) {
+    const valueRep = reverseReplacementsMap.get(condition.value);
+    const valueAsJsonb = castValueToJsonbText(`:${valueRep}`);
+    return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
+  }
+  return false;
+};
+
+export const formatConditionsForEntries = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
+  const replacementKey = reverseReplacementsMap.get(key);
+  if (!replacementKey) {
+    return false;
+  }
+
+  if (Array.isArray(condition)) {
+    if (condition.length === 0) {
+      // if empty array, the condition is ignored
+      return false;
+    }
+
+    if (isConditionStringArray(condition)) {
+      const values = condition.map((value) => getJSONSubQuery(value, key)).join(`${OR_DELIMITER}\n`);
+      return `( ${values})`;
+    }
+    return condition.map((c) => getSingleConditionWithOperator(c.value, c.operator, replacementKey, reverseReplacementsMap)).join(AND_DELIMITER);
+  }
+
+  if (typeof condition === 'string' || typeof condition === 'number') {
+    return getJSONSubQuery(condition, key);
+  }
+
+  if (condition?.operator) {
+    return getSingleConditionWithOperator(condition.value, condition.operator, replacementKey, reverseReplacementsMap);
+  }
+  return false;
+};

package/src/utils/init.ts

@@ -16,7 +16,7 @@ import {
 } from '../hooks';
 import { customFieldsFilterScope } from '../scopes';
 import logger from './logger';
-import type { ModelFetcher, Models } from '../types';
+import type { CustomFieldOptions, ModelFetcher, Models } from '../types';
 import { customFieldsSortScope } from '../scopes/filter';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
@@ -49,9 +49,9 @@ export const addHooks = (
       model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
       model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes, modelOptions, sadotOptions));
       model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes, modelOptions, sadotOptions));
-      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes, 'afterFind', modelOptions));
-      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes, null, modelOptions));
-      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes, null, modelOptions));
+      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes, 'afterFind', modelOptions, sadotOptions));
+      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes, null, modelOptions, sadotOptions));
+      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes, null, modelOptions, sadotOptions));
     } catch (e) {
       logger.error(`Could not add custom fields hook to model ${name}. `, e);
     }
@@ -90,7 +90,7 @@ const addAssociations = (model: ModelCtor, modelName: string): void => {
   CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
 };
 
-export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
+export const addScopes = (models: Models[], getModel: ModelFetcher, options: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false }): void => {
   models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
@@ -104,8 +104,8 @@ export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
       // Necessary associations for the filtering scope
       addAssociations(model, name);
       // Add filter scope
-      model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name));
-      model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name));
+      model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name, options));
+      model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name, options));
     } catch (e) {
       logger.error(`Could not add custom fields scopes to model ${name}. `, e);
     }