@autofleet/sadot 0.7.7-beta.0 → 0.7.7

package/src/hooks/create.ts

@@ -1,3 +1,4 @@
+import type { WhereOptions } from 'sequelize';
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
@@ -23,37 +24,54 @@ export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptio
 ): Promise<void> => {
   logger.debug('sadot - before create hook');
   const { fields } = options;
+  const { include, useEntityIdFromInclude } = modelOptions;
   const modelType = instance.constructor.name;
 
   const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-  // get all model's required definitions
-  const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, modelOptions);
+  const where: WhereOptions = {
+    modelType,
+    disabled: false,
+    ...(!useEntityIdFromInclude && { entityId: identifiers }),
+  };
+  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: false, transaction: options.transaction, include: include?.(identifiers) });
+  const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
 
   const customFieldsIdx = fields.indexOf('customFields');
-  const { customFields } = instance;
-  if (customFieldsIdx > -1 && customFields) {
-    const fieldsNames = Object.keys(customFields);
-    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
-    if (missingFields?.length > 0) {
-      throw new MissingRequiredCustomFieldError(missingFields);
-    }
-
-    await ValueRepo.updateValues(
-      modelType,
-      instance.id,
-      identifiers,
-      customFields,
-      {
-        transaction: options.transaction,
-        modelOptions,
-      },
-      true,
-    );
 
-    // eslint-disable-next-line no-param-reassign
-    fields.splice(customFieldsIdx, 1);
-  } else if (requiredFieldsNames?.length > 0) {
+  if ((customFieldsIdx === -1 || !instance.customFields) && requiredFieldsNames?.length > 0) {
     throw new MissingRequiredCustomFieldError(requiredFieldsNames);
   }
+  const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+  if (fieldsWithDefaultValue.length) {
+    // eslint-disable-next-line no-param-reassign
+    instance.customFields ||= {};
+    fieldsWithDefaultValue.filter((def) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
+      // eslint-disable-next-line no-param-reassign
+      instance.customFields[name] = defaultValue;
+    });
+  }
+  const { customFields } = instance;
+  if (customFieldsIdx === -1 || !customFields) {
+    return;
+  }
+  const fieldsNames = Object.keys(customFields);
+  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+  if (missingFields?.length > 0) {
+    throw new MissingRequiredCustomFieldError(missingFields);
+  }
+
+  await ValueRepo.updateValues(
+    modelType,
+    instance.id,
+    identifiers,
+    customFields,
+    {
+      transaction: options.transaction,
+      modelOptions,
+    },
+  );
+
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
 };

package/src/repository/definition.ts

@@ -1,4 +1,7 @@
-import { Op, type FindOptions, type WhereOptions } from 'sequelize';
+import {
+  Op,
+  type Includeable, type Transaction, type FindOptions, type WhereOptions,
+} from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { ModelOptions } from '../types';
@@ -6,9 +9,15 @@ import type { ModelOptions } from '../types';
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
+interface SadotFindOptions {
+  withDisabled?: boolean;
+  transaction?: Transaction;
+  include?: Includeable | Includeable[];
+}
+
 export const findAll = (
   where: WhereOptions,
-  options: any = { withDisabled: false },
+  options: SadotFindOptions = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
   const queryModel = options.withDisabled
     ? CustomFieldDefinition.unscoped()
@@ -24,12 +33,12 @@ export const findAll = (
 
 export const findByIds = (
   ids: string[],
-  options: any = { withDisabled: false },
+  options: SadotFindOptions = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => findAll({ id: { [Op.in]: ids } }, options);
 
 export const findById = (
   id: string,
-  options: any = { withDisabled: false },
+  options: Pick<SadotFindOptions, 'withDisabled'> = { withDisabled: false },
 ): Promise<CustomFieldDefinition | null> => {
   const { withDisabled } = options;
   if (withDisabled) {
@@ -87,13 +96,13 @@ export const update = async (
   return updatedDefinition;
 };
 
-export const disable = (id: string): Promise<any> =>
+export const disable = (id: string): Promise<[affectedCount: number]> =>
   CustomFieldDefinition.update(
     { disabled: true },
     { where: { id } },
   );
 
-export const destroy = (id: string): Promise<any> =>
+export const destroy = (id: string): Promise<number> =>
   CustomFieldDefinition.destroy({ where: { id } });
 
 /**

package/src/repository/value.ts

@@ -67,7 +67,6 @@ export const updateValues = async (
   identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
   options: FindOptions & { modelOptions?: ModelOptions } = {},
-  defineAllDefaults = false,
 ): Promise<CustomFieldValue[]> => {
   const names = Object.keys(valuesToUpdate);
   logger.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
@@ -81,12 +80,10 @@ export const updateValues = async (
   const where: WhereOptions = {
     modelType,
     name: names,
+    ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
   };
 
-  if (!options.modelOptions?.useEntityIdFromInclude) {
-    where.entityId = identifiers;
-  }
-  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
+  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) {
@@ -101,31 +98,18 @@ export const updateValues = async (
     logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
   }
 
-  const visitedFields = new Set<CustomFieldDefinition>();
-
   const values: CreateCustomFieldValue[] = names.map((name) => {
     const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-    visitedFields.add(fieldDefinition);
     const formatFunction = formatFunctions[fieldDefinition.fieldType];
+    const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
     return {
       modelId,
-      value: (formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name]) ?? fieldDefinition.defaultValue,
       updatedAt: new Date(),
       customFieldDefinitionId: fieldDefinition.id,
+      value: value !== undefined ? value : fieldDefinition.defaultValue,
     };
   });
 
-  if (defineAllDefaults) {
-    fieldDefinitions.filter((def) => !visitedFields.has(def) && ![null, undefined].includes(def.defaultValue)).forEach(({ id, defaultValue }) => {
-      values.push({
-        modelId,
-        value: defaultValue,
-        updatedAt: new Date(),
-        customFieldDefinitionId: id,
-      });
-    });
-  }
-
   return Promise.all(values.map(async (value) => {
     const [cfv] = await CustomFieldValue.upsert(value, {
       transaction: options.transaction,

package/src/scopes/filter.ts

@@ -3,7 +3,6 @@ import { Op, type WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 import { generateRandomString } from '../utils/helpers';
-import logger from '../utils/logger';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
@@ -46,11 +45,11 @@ const castIfNeeded = (conditionValue: string): string => {
 };
 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::varchar)`;
+const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
+const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
 
 /**
  * A Sequelize scope for filtering models by custom fields.
@@ -77,8 +76,8 @@ export const customFieldsFilterScope = (
         const replacemetKey = Object.keys(replacements).find(
           (randomString) => replacements[randomString] === key,
         );
-        if (!replacemetKey) return false;
         const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
+        if (!replacemetKey) return false;
 
         if (Array.isArray(condition)) {
           if (condition.length === 0) {
@@ -90,29 +89,32 @@ export const customFieldsFilterScope = (
               const valRandom = Object.keys(replacements).find(
                 (randomString) => replacements[randomString] === v,
               );
-              return `'"' || :${valRandom} || '"'`;
+              return castValueToJsonb(`:${valRandom}`);
             }).join(',');
-            return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN ( ${values} ))`;
+            return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN (${values}))`;
           }
           return condition
             .map((c) => {
               const valRep = Object.keys(replacements).find(
                 (replacementKey) => replacements[replacementKey] === c.value,
               );
-              return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} '"' || :${valRep} || '"' )`;
+              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 = Object.keys(replacements).find(
             (replacementKey) => replacements[replacementKey] === condition,
           );
-          return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = '"' || :${conditionRep} || '"')`;
+          const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
+          return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
         }
         if (condition?.operator) {
           const valueRep = Object.keys(replacements).find(
             (replacementKey) => replacements[replacementKey] === condition.value,
           );
-          return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} '"' || :${valueRep} || '"')`;
+          const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
+          return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
         }
         return false;
       },
@@ -123,15 +125,15 @@ export const customFieldsFilterScope = (
   }
   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 = '${name}'
-  WHERE ${customFieldConditions}
-  GROUP BY cv.model_id
-  HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
-`.replace(/\n/g, '');
-  logger.info('custom fields filter scope', { subQuery, replacements });
+    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
+    
+    WHERE ${customFieldConditions}
+    GROUP BY cv.model_id
+    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
+  `.replace(/\n/g, '');
+  console.log(subQuery);
   return {
     where: {
       id: {