@autofleet/sadot 1.1.3 → 1.1.5-beta

package/src/models/tests/AssociatedTestModel.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  ForeignKey,
+  BelongsTo,
+} from 'sequelize-typescript';
+import TestModel from './TestModel';
+
+@Table({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+class AssociatedTestModel extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @ForeignKey(() => TestModel)
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    testModelId!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    fleetId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    businessModelId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    demandSourceId: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+  })
+    anotherAttribute?: boolean;
+
+  @BelongsTo(() => TestModel)
+    testModel: TestModel;
+}
+
+export default AssociatedTestModel;

package/src/models/tests/TestModel.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  HasMany,
+} from 'sequelize-typescript';
+import AssociatedTestModel from './AssociatedTestModel';
+
+@Table({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+class TestModel extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    fleetId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    businessModelId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    demandSourceId: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+  })
+    coolAttribute?: boolean;
+
+  @HasMany(() => AssociatedTestModel)
+    associatedModels: AssociatedTestModel[];
+
+  @Column({
+    type: DataType.VIRTUAL,
+  })
+    customFields?: any;
+}
+
+export default TestModel;

package/src/models/tests/contextAwareModels/ContextAwareTestModel.ts

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  HasMany,
+  BelongsTo,
+  ForeignKey,
+} from 'sequelize-typescript';
+import AssociatedTestModel from '../AssociatedTestModel';
+import ContextTestModel from './ContextTestModel';
+
+@Table({ createdAt: false, updatedAt: false })
+class ContextAwareTestModel extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @ForeignKey(() => ContextTestModel)
+  @Column({ type: DataType.UUID })
+    contextId: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+  })
+    coolAttribute?: boolean;
+
+  @Column({
+    type: DataType.VIRTUAL,
+  })
+    customFields?: any;
+
+  @BelongsTo(() => ContextTestModel)
+    context: ContextTestModel;
+}
+
+export default ContextAwareTestModel;

package/src/models/tests/contextAwareModels/ContextTestModel.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+} from 'sequelize-typescript';
+
+// eslint-disable-next-line no-shadow
+ enum EEntityTypes {
+  BUSINESS_MODEL = 'businessModel',
+  CONTEXT = 'context',
+  DEMAND_SOURCE = 'demandSource',
+  FLEET = 'fleet',
+}
+
+@Table({ createdAt: false, updatedAt: false })
+class ContextTestModel extends Model {
+  @PrimaryKey
+  @Column({
+    defaultValue: DataType.UUIDV4,
+    type: DataType.UUID,
+  })
+    id: string;
+
+  @Column({
+    type: DataType.UUID,
+  })
+    entityId: string;
+
+  @Column({
+    type: DataType.ENUM(...Object.values(EEntityTypes)),
+  })
+    entityType: EEntityTypes;
+}
+
+export default ContextTestModel;

package/src/repository/definition.ts

@@ -0,0 +1,175 @@
+import {
+  Op,
+  type Includeable, type Transaction, type FindOptions, type WhereOptions,
+} from 'sequelize';
+import { CustomFieldDefinition, type CustomFieldEntries } from '../models';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+import type { ModelOptions } from '../types';
+import { MissingDefinitionError } from '../errors';
+
+export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
+  CustomFieldDefinition.create(data);
+
+interface SadotFindOptions {
+  withDisabled?: boolean;
+  transaction?: Transaction;
+  include?: Includeable | Includeable[];
+}
+
+type SadotGetDefinitionsByEntityIdsOptions = FindOptions & { modelOptions?: ModelOptions } & Pick<SadotFindOptions, 'withDisabled'>;
+
+export const findAll = (
+  where: WhereOptions,
+  options: SadotFindOptions = { withDisabled: false },
+): Promise<CustomFieldDefinition[]> => {
+  const queryModel = options.withDisabled
+    ? CustomFieldDefinition.unscoped()
+    : CustomFieldDefinition;
+
+  return queryModel.scope('userScope').findAll({
+    where,
+    transaction: options.transaction,
+    raw: true,
+    include: options.include,
+  });
+};
+
+export const findByIds = (
+  ids: string[],
+  options: SadotFindOptions = { withDisabled: false },
+): Promise<CustomFieldDefinition[]> => findAll({ id: { [Op.in]: ids } }, options);
+
+export const findById = (
+  id: string,
+  options: Pick<SadotFindOptions, 'withDisabled'> = { withDisabled: false },
+): Promise<CustomFieldDefinition | null> => {
+  const { withDisabled } = options;
+  if (withDisabled) {
+    return CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+  }
+  return CustomFieldDefinition.scope('userScope').findByPk(id);
+};
+
+export const findByEntityIds = async (
+  modelType: string,
+  entityIds: string[],
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
+): Promise<CustomFieldDefinition[]> => {
+  const { include, useEntityIdFromInclude } = options.modelOptions;
+  const where: WhereOptions = {
+    modelType,
+    ...(!useEntityIdFromInclude && { entityId: { [Op.in]: entityIds } }),
+  };
+
+  return CustomFieldDefinition.findAll({
+    where,
+    transaction: options.transaction,
+    include: include?.(entityIds),
+    raw: true,
+  });
+};
+
+export const findByWhere = (where): Promise<CustomFieldDefinition | null> =>
+  CustomFieldDefinition.scope('userScope').findOne({
+    where,
+  });
+
+export const findDefinitionsByModels = async (
+  modelTypes: string[],
+  options?,
+): Promise<CustomFieldDefinition[]> => {
+  const query: WhereOptions<CreateCustomFieldDefinition> = { modelType: { [Op.in]: modelTypes } };
+  return CustomFieldDefinition.findAll({
+    where: query,
+    transaction: options?.transaction,
+  });
+};
+
+export const update = async (
+  id: string,
+  data: UpdateCustomFieldDefinition,
+): Promise<CustomFieldDefinition> => {
+  const updatedDefinition = (await CustomFieldDefinition.scope('userScope').update(data, {
+    where: { id },
+    returning: true,
+    individualHooks: true,
+  }))[1][0];
+  return updatedDefinition;
+};
+
+export const disable = (id: string): Promise<[affectedCount: number]> =>
+  CustomFieldDefinition.update(
+    { disabled: true },
+    { where: { id } },
+  );
+
+export const destroy = (id: string): Promise<number> =>
+  CustomFieldDefinition.destroy({ where: { id } });
+
+/**
+ * Return the names of the required fields for a given model
+ */
+export const getRequiredFields = async (
+  modelType: string,
+  modelId: string | string[],
+  entityId: string | string[],
+  modelOptions: ModelOptions = {},
+): Promise<string[]> => {
+  const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+  const { include, useEntityIdFromInclude } = modelOptions;
+
+  const where: WhereOptions = {
+    modelType,
+    required: true,
+    ...(!useEntityIdFromInclude && { entityId: { [Op.in]: entityIds } }),
+  };
+
+  const requiredFields = await CustomFieldDefinition.findAll({
+    where,
+    include: include?.(entityIds),
+    logging: true,
+  });
+  const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+  return [...new Set(requiredFieldsNames)];
+};
+
+/**
+ * @returns A promise resolving with a dictionary of custom field definitions by name.
+ * @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
+ */
+export const getCustomFieldDefinitionsDictionary = async (
+  instances: CustomFieldEntries[],
+  options: SadotGetDefinitionsByEntityIdsOptions = { withDisabled: false, modelOptions: {} },
+): Promise<{ [definitionName: string]: CustomFieldDefinition }> => {
+  const { modelType } = instances[0]?.dataValues ?? {};
+  const customFields = new Set<string>();
+  const modelIds = [];
+  const entityIds = new Set<string>();
+  instances.forEach((instance) => {
+    const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+    modelIds.push(modelId);
+    entityIds.add(entityId);
+
+    Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+      customFields.add(fieldName);
+    });
+  });
+
+  const where: WhereOptions = {
+    modelType,
+    entityId: { [Op.in]: Array.from(entityIds) },
+    name: { [Op.in]: Array.from(customFields) },
+  };
+
+  const definitions = await findAll(where, { ...options });
+
+  const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
+  const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));
+
+  if (!definitions?.length || matchedDefinitions.length !== customFields.size) {
+    const unmatchedCustomFields = Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]);
+    throw new MissingDefinitionError(unmatchedCustomFields);
+  }
+
+  return matchedDefinitionsByName;
+};

package/src/repository/entries.ts

@@ -0,0 +1,88 @@
+/* eslint-disable no-param-reassign */
+import type {
+  FindOptions,
+  Includeable,
+  Transaction,
+  WhereOptions,
+} from 'sequelize';
+import { CustomFieldEntries } from '../models';
+import type { ModelOptions } from '../types';
+import logger from '../utils/logger';
+import { MissingDefinitionError } from '../errors';
+import * as DefinitionRepo from './definition';
+import { formatFunctions } from './utils/formatValues';
+
+type CustomFieldEntriesModelOptions = ModelOptions & { include?: Includeable, transaction?: Transaction };
+
+export const findEntriesByModelId = async (modelId: string, options: CustomFieldEntriesModelOptions = {}) => {
+  const { transaction } = options;
+  return CustomFieldEntries.findOne({
+    where: { modelId },
+    transaction,
+  });
+};
+
+export const findEntriesByModelIds = async (modelIds: string[], options: CustomFieldEntriesModelOptions = {}) => {
+  const { transaction } = options;
+  return CustomFieldEntries.findAll({
+    where: { modelId: modelIds },
+    transaction,
+  });
+};
+
+export const updateEntries = async (
+  modelId: string,
+  modelType: string,
+  customFields: Record<string, any>,
+  identifiers: string[],
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
+) => {
+  const customFieldsNames = Object.keys(customFields);
+  logger.debug(`custom-fields: updating entries for ${modelType} ${modelId}`, {
+    customFieldsNames,
+    optionsKeys: options ? Object.keys(options) : null,
+    customFields,
+    identifiers,
+  });
+  const { modelOptions, transaction } = options;
+
+  const where: WhereOptions = {
+    modelType,
+    name: customFieldsNames,
+    ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
+  };
+
+  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) ?? [];
+
+  const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+  if (fieldDefinitions.length !== customFieldsNames.length) {
+    logger.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names: customFieldsNames, fieldDefinitions });
+    const missingDefinitions = customFieldsNames.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+    throw new MissingDefinitionError(missingDefinitions);
+  }
+
+  const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+  const valuesWithDisabledDefinitions = customFieldsNames.filter((name) => disabledNames.includes(name));
+  if (valuesWithDisabledDefinitions?.length > 0) {
+    logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+  }
+
+  const definitionsByName = Object.fromEntries(fieldDefinitions.map((definition) => [definition.name, definition]));
+  // If we need to format the value before we save it
+  Object.entries(customFields)
+    .filter(([definitionName]) => formatFunctions[definitionsByName[definitionName].fieldType])
+    .forEach(([definitionName, value]) => {
+      const { fieldType } = definitionsByName[definitionName];
+      customFields[definitionName] = formatFunctions[fieldType](value);
+    });
+
+  return CustomFieldEntries.upsert(
+    {
+      modelId,
+      entityId: fieldDefinitions[0].entityId,
+      modelType,
+      customFields,
+    },
+    options,
+  );
+};

package/src/repository/utils/formatValues.ts

@@ -0,0 +1,14 @@
+import { CustomFieldDefinitionType } from '../../utils/constants';
+
+export const formatFunctions = {
+  [CustomFieldDefinitionType.DATE]: (value) => {
+    if (value) {
+      const date = new Date(value);
+      if (date.toString() === 'Invalid Date') {
+        throw new Error(`Invalid date value: ${value}`);
+      }
+      return date.toISOString();
+    }
+    return null;
+  },
+};

package/src/repository/validator.ts

@@ -0,0 +1,104 @@
+import type { IncludeOptions, Transactionable } from 'sequelize';
+import logger from '../utils/logger';
+import { CustomValidator } from '../models';
+
+export interface FindValidatorOptions extends Transactionable {
+  withDisabled?: boolean;
+  attributes?: string[];
+  raw?: boolean;
+  include?: IncludeOptions[];
+}
+
+// Make sure this interface is compatible with the Sequelize model
+export interface ValidatorAttributes {
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  schema: CustomValidator['schema'];
+  disabled?: boolean;
+  [key: string]: unknown; // Add index signature for Sequelize compatibility
+}
+
+export const create = async (
+  validatorAttributes: ValidatorAttributes,
+  options: Transactionable = {},
+): Promise<CustomValidator> => {
+  logger.debug('custom-validator - create validator');
+
+  // Use unknown type to bypass TypeScript errors while maintaining compatibility
+  const validator = await CustomValidator.create(validatorAttributes as Record<string, unknown>, options);
+
+  return validator;
+};
+
+export const findAll = async (
+  where = {},
+  options: FindValidatorOptions = { withDisabled: false },
+): Promise<CustomValidator[]> => {
+  logger.debug('custom-validator - find all validators');
+
+  const { transaction, withDisabled } = options;
+
+  let validators;
+  if (withDisabled) {
+    // If withDisabled is true, use unscoped to ignore the default scope that filters disabled items
+    // Apply the userScope separately to maintain permission filtering
+    validators = await CustomValidator.unscoped().scope('userScope').findAll({
+      where,
+      transaction,
+    });
+  } else {
+    // Use defaultScope and userScope to filter both disabled and by permissions
+    // The defaultScope keeps only non-disabled validators
+    validators = await CustomValidator.scope(['defaultScope', 'userScope']).findAll({
+      where,
+      transaction,
+    });
+  }
+
+  return validators;
+};
+
+export const findAllByModelType = async (
+  modelType: string,
+  entityId: string,
+  options: FindValidatorOptions = { withDisabled: false },
+): Promise<CustomValidator[]> => {
+  logger.debug('custom-validator - find all validators by model type');
+
+  return findAll(
+    {
+      modelType,
+      ...(!options.include && {
+        entityId,
+      }),
+    },
+    options,
+  );
+};
+
+export const update = async (
+  id: string,
+  updates: Partial<ValidatorAttributes>,
+  options?: Transactionable,
+): Promise<[number, CustomValidator[]]> => {
+  logger.debug('custom-validator - update validator');
+
+  return CustomValidator.update(
+    updates,
+    {
+      where: { id },
+      returning: true,
+      ...options,
+    },
+  );
+};
+
+export const disable = async (
+  id: string,
+  options?: Transactionable,
+): Promise<[number, CustomValidator[]]> => {
+  logger.debug('custom-validator - disable validator');
+
+  return update(id, { disabled: true }, options);
+};

package/src/repository/value.ts

@@ -0,0 +1,116 @@
+import type { FindOptions, WhereOptions } from 'sequelize';
+import { CustomFieldValue, CustomFieldDefinition } from '../models';
+import * as DefinitionRepo from './definition';
+import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import logger from '../utils/logger';
+import { MissingDefinitionError } from '../errors';
+import type { ModelOptions } from '../types';
+import { formatFunctions } from './utils/formatValues';
+
+export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
+  CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
+
+export const create = async (data: CreateCustomFieldValue, withAssociations = false) => {
+  const created = await CustomFieldValue.create(data);
+  if (withAssociations) {
+    const createdWithAssociations = await findByModelIdAndDefinition(created.modelId, created.customFieldDefinitionId);
+    return createdWithAssociations?.[0];
+  }
+  return created;
+};
+
+export const findAllValues = async () => CustomFieldValue.findAll({ include: [CustomFieldDefinition] });
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+export const findValuesByModelId = async (modelId: string) => CustomFieldValue.findAll({ where: { modelId }, include: [CustomFieldDefinition] });
+
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+export const findValuesByModelIds = async (modelIds: string[], options?): Promise<CustomFieldValue[]> => {
+  const { transaction } = options;
+  return CustomFieldValue.findAll({
+    where: { modelId: modelIds },
+    transaction,
+    raw: true,
+    nest: true,
+  });
+};
+
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+export const updateValues = async (
+  modelType: string,
+  modelId: string,
+  identifiers: string[],
+  valuesToUpdate: ValuesToUpdate,
+  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,
+  });
+  const { modelOptions, transaction } = options;
+
+  const where: WhereOptions = {
+    modelType,
+    name: names,
+    ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: 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) {
+    logger.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+    const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+    throw new MissingDefinitionError(missingDefinitions);
+  }
+
+  const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+  const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+  if (valuesWithDisabledDefinitions?.length > 0) {
+    logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+  }
+
+  const values: CreateCustomFieldValue[] = names.map((name) => {
+    const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
+    const formatFunction = formatFunctions[fieldDefinition.fieldType];
+    const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
+    return {
+      modelId,
+      updatedAt: new Date(),
+      customFieldDefinitionId: fieldDefinition.id,
+      value: value !== undefined ? value : fieldDefinition.defaultValue,
+    };
+  });
+
+  return Promise.all(values.map(async (value) => {
+    const [cfv] = await CustomFieldValue.upsert(value, {
+      transaction: options.transaction,
+    });
+    return cfv;
+  }));
+};
+
+export const deleteValue = (
+  id: string,
+  options: any = {},
+): Promise<any> => CustomFieldValue.update(
+  { deletedAt: new Date() },
+  {
+    where: { id },
+    transaction: options.transaction,
+  },
+);