@autofleet/sadot 1.1.7-beta → 1.1.7

package/src/models/tests/AssociatedTestModel.ts

@@ -1,57 +0,0 @@
-/* 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

@@ -1,54 +0,0 @@
-/* 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

@@ -1,43 +0,0 @@
-/* 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

@@ -1,38 +0,0 @@
-/* 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

@@ -1,175 +0,0 @@
-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

@@ -1,88 +0,0 @@
-/* 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

@@ -1,14 +0,0 @@
-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

@@ -1,119 +0,0 @@
-import type { FindOptions, IncludeOptions, Transactionable } from 'sequelize';
-import logger from '../utils/logger';
-import { CustomValidator } from '../models';
-import type { ModelOptions } from '../types';
-
-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: FindOptions & {
-    modelOptions?: ModelOptions,
-     withDisabled?: boolean
-    } = {},
-): Promise<CustomValidator[]> => {
-  logger.debug('custom-validator - find all validators');
-
-  const {
-    transaction, withDisabled, include, attributes, raw,
-  } = 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,
-      include,
-      attributes,
-      raw,
-    });
-  } 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,
-      include,
-      attributes,
-      raw,
-    });
-  }
-
-  return validators;
-};
-
-export const findAllByModelType = async (
-  modelType: string,
-  entityId: string,
-  options: FindOptions & {
-    modelOptions?: ModelOptions,
-    withDisabled?: boolean
-  } = {},
-): Promise<CustomValidator[]> => {
-  logger.debug('custom-validator - find all validators by model type');
-  return findAll(
-    {
-      modelType,
-      ...(!options?.modelOptions?.useEntityIdFromInclude && { entityId }),
-    },
-    {
-      ...options,
-      include: options?.modelOptions?.include?.(entityId),
-    },
-  );
-};
-
-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);
-};