@autofleet/sadot 0.13.2-beta.7 → 0.13.3-beta-c0a9f0d7.0

package/.env

@@ -0,0 +1,4 @@
+AF_SERVICE_NAME=sadot_package_test
+NODE_ENV=test
+DB_USERNAME=postgres
+DB_PASSWORD=postgres

package/dist/hooks/hooks.js

@@ -222,10 +222,7 @@ const formatDates = (fieldDefinitions, instance) => {
                     throw new errors_2.InvalidValueError(value, name, validationError);
                 }
                 // eslint-disable-next-line no-param-reassign
-                const typeofjoi = typeof joiValue;
-                logger_1.default.info('sadot - formatting date', { name, value, joiValue, type: typeof joiValue });
                 instance.customFields[name] = joiValue.toISOString();
-                new Date().toString;
             }
         }
     });

package/dist/index.js

@@ -54,10 +54,7 @@ const useCustomFields = async (app, getModel, options) => {
     }
     // The order is important
     (0, init_1.addHooks)(models, getModel, { useCustomFieldsEntries });
-    await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries }).catch((e) => {
-        logger_1.default.error('sadot - error while initializing custom fields tables', e);
-        throw e;
-    });
+    await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries });
     (0, init_1.addScopes)(models, getModel, { useCustomFieldsEntries });
     (0, init_1.applyCustomAssociation)(models);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);

package/dist/models/index.d.ts

@@ -13,6 +13,6 @@ interface InitTablesOptions {
     schemaVersion?: string;
     useCustomFieldsEntries?: boolean;
 }
-declare const initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], { schemaPrefix, schemaVersion, useCustomFieldsEntries, }: InitTablesOptions) => Promise<void>;
+declare const initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], { schemaPrefix, schemaVersion, useCustomFieldsEntries, }?: InitTablesOptions) => Promise<void>;
 declare const initTestModels: (sequelize: Sequelize) => Promise<void>;
 export { CustomFieldValue, CustomFieldDefinition, CustomFieldEntries, CustomValidator, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };

package/dist/models/index.js

@@ -27,7 +27,7 @@ const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.de
 const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
 const SCHEMA_VERSION = '49c9dd1d-b1cc-445b-a911-fd349d783110';
-const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, }) => {
+const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, } = {}) => {
     const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
     logger_1.default.info('custom-fields: initialize custom-fields tables');
     // Detect models and import them to the orm

package/dist/scopes/filter.d.ts

@@ -12,7 +12,6 @@ type customFieldsFilterScopeParams = {
  * @returns A function that takes conditions and returns the Sequelize options object.
  */
 export declare const customFieldsFilterScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
-export declare const scopeName: "filterByCustomFields";
 export declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap, scopeValue: sort }: {
     replacementsMap: any;
     scopeValue: any;
@@ -24,7 +23,7 @@ export declare const customFieldsSortScope: (name: string, options?: Pick<Custom
     attributes: {
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
-    order: import("sequelize/types/utils").Literal[];
+    order: any[][];
     replacements: any;
 };
 export {};

package/dist/scopes/filter.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterScope = void 0;
+exports.customFieldsSortScope = exports.customFieldsFilterScope = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
-const helpers_1 = require("../utils/helpers");
 const filter_helpers_1 = require("./helpers/filter.helpers");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 /**
@@ -46,23 +45,23 @@ const customFieldsFilterScope = (name, options) => ({ replacementsMap: replaceme
     };
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
-exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
 const customFieldsSortScope = (name, options) => ({ replacementsMap, scopeValue: sort }) => {
     if (!sort || sort.length === 0) {
         return {};
     }
     const queryType = options?.useCustomFieldsEntries ? filter_helpers_1.SubQueryType.ENTRIES : filter_helpers_1.SubQueryType.VALUES;
-    const randomStr = (0, helpers_1.generateRandomString)();
     const includes = Object.entries(sort).map(([key]) => {
         const replacementKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+        const alias = `cf_sort_${key}`; // Explicit unique alias per field
         return ([
-            sequelize_typescript_1.Sequelize.literal((0, filter_helpers_1.getSortCustomFieldsSubQuery)(queryType, name, replacementKey)),
-            randomStr,
+            sequelize_typescript_1.Sequelize.literal(`(${(0, filter_helpers_1.getSortCustomFieldsSubQuery)(queryType, name, replacementKey)})`),
+            alias,
         ]);
     });
-    const orders = Object.entries(sort).map(([, sortObject]) => {
+    const orders = Object.entries(sort).map(([key, sortObject]) => {
         const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
-        return sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
+        const alias = `cf_sort_${key}`;
+        return [sequelize_typescript_1.Sequelize.literal(`"${alias}"`), direction || 'ASC'];
     });
     return {
         attributes: {

package/dist/scopes/helpers/filter.helpers.js

@@ -117,17 +117,15 @@ const getSortCustomFieldsSubQuery = (queryType, modelType, replacementKey) => {
             `;
         case SubQueryType.ENTRIES:
             return `(
-        SELECT
-            customFields.value
-        FROM
-            custom_field_entries AS ${exports.CE_TABLE_ALIAS},
-            jsonb_each_text(custom_fields) AS customFields
-        WHERE
-          customFields.key = :${replacementKey}${exports.AND_DELIMITER}
-          ${exports.CE_TABLE_ALIAS}.model_type = '${modelType}'${exports.AND_DELIMITER}
-          ${exports.CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
-        )
-      `;
+    SELECT customFields.value::numeric -- <-- Add numeric casting if sorting numeric values
+    FROM custom_field_entries AS ${exports.CE_TABLE_ALIAS},
+         jsonb_each_text(custom_fields) AS customFields
+    WHERE
+      customFields.key = :${replacementKey}${exports.AND_DELIMITER}
+      ${exports.CE_TABLE_ALIAS}.model_type = '${modelType}'${exports.AND_DELIMITER}
+      ${exports.CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
+    LIMIT 1
+  )`;
         default:
             throw new Error('Invalid query type');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.13.2-beta.7",
+  "version": "0.13.3-beta-c0a9f0d7.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/hooks/hooks.ts

@@ -258,10 +258,7 @@ const formatDates = (fieldDefinitions: CustomFieldDefinition[], instance: any) =
           throw new InvalidValueError(value, name, validationError);
         }
         // eslint-disable-next-line no-param-reassign
-        const typeofjoi = typeof joiValue;
-        logger.info('sadot - formatting date', { name, value, joiValue, type: typeof joiValue });
         instance.customFields[name] = joiValue.toISOString();
-        new Date().toString
       }
     }
   });
@@ -278,72 +275,72 @@ export const beforeCreate = (
   instance,
   options,
 ): Promise<void> => {
-    logger.debug('sadot - before create hook');
-    const { fields } = options;
-    const modelType = instance.constructor.name;
+  logger.debug('sadot - before create hook');
+  const { fields } = options;
+  const modelType = instance.constructor.name;
 
-    const identifiers = applyScopeToInstance(instance, scopeAttributes);
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-    // Step 1: Handle custom fields default values and required fields
+  // Step 1: Handle custom fields default values and required fields
 
-    const fieldDefinitions = await getFieldDefinitions({
-      modelType, modelOptions, identifiers, options,
-    });
+  const fieldDefinitions = await getFieldDefinitions({
+    modelType, modelOptions, identifiers, options,
+  });
 
-    // Apply default values
-    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) => (instance.customFields?.[def.name] === undefined))
-        .forEach(({ name, defaultValue }) => {
-          // eslint-disable-next-line no-param-reassign
-          instance.customFields[name] = defaultValue;
-        });
-    }
+  // Apply default values
+  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) => (instance.customFields?.[def.name] === undefined))
+      .forEach(({ name, defaultValue }) => {
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields[name] = defaultValue;
+      });
+  }
 
-    // Check for required fields
-    const requiredFieldsNames = Array.from(
-      new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)),
-    );
-    const { customFields } = instance;
-    const fieldsNames = Object.keys(customFields ?? {});
-    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
-    if (missingFields?.length) {
-      throw new MissingRequiredCustomFieldError(missingFields);
-    }
+  // Check for required fields
+  const requiredFieldsNames = Array.from(
+    new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)),
+  );
+  const { customFields } = instance;
+  const fieldsNames = Object.keys(customFields ?? {});
+  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+  if (missingFields?.length) {
+    throw new MissingRequiredCustomFieldError(missingFields);
+  }
 
-    // Step 2: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, true);
+  // Step 2: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, true);
 
-    // format date and datetime fields
-    formatDates(fieldDefinitions, instance);
+  // format date and datetime fields
+  formatDates(fieldDefinitions, instance);
 
-    // Step 3: Save custom field values if they exist
-    const customFieldsIdx = fields.indexOf('customFields');
-    if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
-      // No custom fields to update
-      return;
-    }
+  // Step 3: Save custom field values if they exist
+  const customFieldsIdx = fields.indexOf('customFields');
+  if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+    // No custom fields to update
+    return;
+  }
 
-    // Save custom field values
-    await updateInstanceValues({
-      modelId: instance.id,
-      modelType,
-      identifiers,
-      customFields,
-      options: {
-        useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-        transaction: options.transaction,
-        modelOptions,
-      },
-    });
+  // Save custom field values
+  await updateInstanceValues({
+    modelId: instance.id,
+    modelType,
+    identifiers,
+    customFields,
+    options: {
+      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+      transaction: options.transaction,
+      modelOptions,
+    },
+  });
 
-    // Remove customFields from fields array after handling
-    // eslint-disable-next-line no-param-reassign
-    fields.splice(customFieldsIdx, 1);
-  };
+  // Remove customFields from fields array after handling
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
+};
 
 /**
  * Hook to handle validation and custom fields during update
@@ -356,48 +353,48 @@ export const beforeUpdate = (
   instance,
   options,
 ): Promise<void> => {
-    logger.debug('sadot - before update hook');
-    const { fields } = options;
-    const modelType = instance.constructor.name;
-    const identifiers = applyScopeToInstance(instance, scopeAttributes);
+  logger.debug('sadot - before update hook');
+  const { fields } = options;
+  const modelType = instance.constructor.name;
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-    const fieldDefinitions = await getFieldDefinitions({
-      modelType, modelOptions, identifiers, options,
-    });
+  const fieldDefinitions = await getFieldDefinitions({
+    modelType, modelOptions, identifiers, options,
+  });
 
-    // Step 1: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, false);
+  // Step 1: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, false);
 
-    // format date and datetime fields
-    formatDates(fieldDefinitions, instance);
+  // format date and datetime fields
+  formatDates(fieldDefinitions, instance);
 
-    // Step 2: Update custom field values if they exist
-    const customFieldsIdx = fields.indexOf('customFields');
-    if (customFieldsIdx > -1) {
-      const { customFields } = instance;
+  // Step 2: Update custom field values if they exist
+  const customFieldsIdx = fields.indexOf('customFields');
+  if (customFieldsIdx > -1) {
+    const { customFields } = instance;
 
-      if (!Object.keys(customFields).length) {
-        return;
-      }
+    if (!Object.keys(customFields).length) {
+      return;
+    }
 
-      // Save custom field values
-      await updateInstanceValues({
-        modelId: instance.id,
-        modelType,
-        identifiers,
-        customFields,
-        options: {
-          useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-          transaction: options.transaction,
-          modelOptions,
-        },
-      });
+    // Save custom field values
+    await updateInstanceValues({
+      modelId: instance.id,
+      modelType,
+      identifiers,
+      customFields,
+      options: {
+        useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+        transaction: options.transaction,
+        modelOptions,
+      },
+    });
 
-      // Remove customFields from fields array after handling
-      // eslint-disable-next-line no-param-reassign
-      fields.splice(customFieldsIdx, 1);
-    }
-  };
+    // Remove customFields from fields array after handling
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+  }
+};
 
 /**
  * Hook to enable individual hooks for bulk create operations

package/src/index.ts

@@ -37,10 +37,7 @@ const useCustomFields = async (
   }
   // The order is important
   addHooks(models, getModel, { useCustomFieldsEntries });
-  await initTables(sequelize, options.getUser, { useCustomFieldsEntries }).catch((e) => {
-    logger.error('sadot - error while initializing custom fields tables', e);
-    throw e;
-  });
+  await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
   addScopes(models, getModel, { useCustomFieldsEntries });
   applyCustomAssociation(models);
 

package/src/models/index.ts

@@ -32,7 +32,7 @@ const initTables = async (
     schemaPrefix = SADOT_MIGRATION_PREFIX,
     schemaVersion = SCHEMA_VERSION,
     useCustomFieldsEntries = false,
-  }: InitTablesOptions,
+  }: InitTablesOptions = {},
 ): Promise<void> => {
   const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
   logger.info('custom-fields: initialize custom-fields tables');

package/src/scopes/filter.ts

@@ -64,8 +64,6 @@ export const customFieldsFilterScope = (
   };
 };
 
-export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-
 export const customFieldsSortScope = (
   name: string,
   options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
@@ -75,21 +73,24 @@ export const customFieldsSortScope = (
   }
 
   const queryType = options?.useCustomFieldsEntries ? SubQueryType.ENTRIES : SubQueryType.VALUES;
-  const randomStr = generateRandomString();
+
   const includes = Object.entries(sort).map(([key]) => {
     const replacementKey = Object.keys(replacementsMap).find(
       (randomString) => replacementsMap[randomString] === key,
     );
+    const alias = `cf_sort_${key}`; // Explicit unique alias per field
     return ([
-      Sequelize.literal(getSortCustomFieldsSubQuery(queryType, name, replacementKey)),
-      randomStr,
+      Sequelize.literal(`(${getSortCustomFieldsSubQuery(queryType, name, replacementKey)})`),
+      alias,
     ]);
   });
 
-  const orders = Object.entries(sort).map(([, sortObject]) => {
+  const orders = Object.entries(sort).map(([key, sortObject]) => {
     const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
-    return Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
+    const alias = `cf_sort_${key}`;
+    return [Sequelize.literal(`"${alias}"`), direction || 'ASC'];
   });
+
   return {
     attributes: {
       include: includes,

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

@@ -134,17 +134,15 @@ export const getSortCustomFieldsSubQuery = (queryType: SubQueryType, modelType:
             `;
     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"
-        )
-      `;
+    SELECT customFields.value::numeric -- <-- Add numeric casting if sorting numeric values
+    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"
+    LIMIT 1
+  )`;
     default:
       throw new Error('Invalid query type');
   }