@autofleet/sadot 1.0.3 → 1.0.6

package/src/api/v1/validator/index.ts

@@ -1,141 +0,0 @@
-import { ResourceNotFoundError } from '@autofleet/errors';
-import { Router } from '@autofleet/node-common';
-import { StatusCodes } from 'http-status-codes';
-import handleError from '../errors';
-import * as ValidatorRepo from '../../../repository/validator';
-import validations from './validations';
-import logger from '../../../utils/logger';
-import { validateValidatorSchema } from '../../../utils/validations/schema/validator-schema';
-import type { CustomValidator } from '../../../models';
-
-const router = Router({ logger });
-const ENTITY = 'CustomValidator';
-
-/**
- * Create
- */
-router.post<{ modelName: string }>('/', async (req, res) => {
-  const { modelName } = req.params;
-  try {
-    // Validate the request body
-    const validatedPayload = await validations.create.validateAsync(req.body);
-
-    // Validate that the schema is a valid AJV schema
-    validateValidatorSchema(validatedPayload.schema);
-
-    const validator = await ValidatorRepo.create({
-      ...validatedPayload,
-      modelType: modelName,
-    });
-
-    return res.status(StatusCodes.CREATED).json(validator);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
-  }
-});
-
-/**
- * Get all
- */
-router.get<
-  { modelName: string },
-  { validators: CustomValidator[] },
-  never,
-  { entityId?: string; entityType?: string }
->('/', async (req, res) => {
-  try {
-    const { modelName } = req.params;
-    const { entityId, entityType } = req.query;
-
-    const where = {
-      modelType: modelName,
-      ...(entityId && { entityId }),
-      ...(entityType && { entityType }),
-    };
-
-    const validators = await ValidatorRepo.findAll(where);
-
-    return res.status(StatusCodes.OK).json({ validators });
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
-  }
-});
-
-/**
- * Get by id
- */
-router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId, modelName } = req.params;
-    // Include disabled validators when fetching by ID
-    const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
-
-    if (!validators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    return res.status(StatusCodes.OK).json(validators[0]);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
-  }
-});
-
-/**
- * Update
- */
-router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId } = req.params;
-
-    // Validate the request body
-    const validatedPayload = await validations.update.validateAsync(req.body);
-
-    // If schema is included in the update, validate that it's a valid AJV schema
-    if (validatedPayload.schema) {
-      validateValidatorSchema(validatedPayload.schema);
-    }
-
-    // First verify the validator exists, including disabled ones
-    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
-    if (!existingValidators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
-
-    if (!count) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    return res.status(StatusCodes.OK).json(validators[0]);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
-  }
-});
-
-/**
- * Delete (disable)
- */
-router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId } = req.params;
-
-    // First verify the validator exists, including disabled ones
-    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
-    if (!existingValidators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    const [count] = await ValidatorRepo.disable(validatorId);
-
-    if (!count) {
-      throw new ResourceNotFoundError('Validator failed to be disabled');
-    }
-
-    return res.status(StatusCodes.NO_CONTENT).send();
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in delete ${ENTITY} request` });
-  }
-});
-
-export default router;

package/src/api/v1/validator/validations.ts

@@ -1,38 +0,0 @@
-import Joi from 'joi';
-
-const jsonSchemaValidation = Joi.object().unknown(true);
-
-const schemaObject = Joi.object({
-  type: Joi.string().valid('object'),
-  properties: Joi.object({
-    before: jsonSchemaValidation,
-    after: jsonSchemaValidation,
-  }).required(),
-  required: Joi.array().items(Joi.string()),
-  allOf: Joi.array().items(Joi.object()),
-  anyOf: Joi.array().items(Joi.object()),
-  oneOf: Joi.array().items(Joi.object()),
-  additionalProperties: Joi.alternatives().try(Joi.boolean(), Joi.object()),
-  $id: Joi.string(),
-  $schema: Joi.string(),
-  if: Joi.object(),
-  then: Joi.object(),
-  else: Joi.object(),
-});
-
-const validationSchemas = {
-  create: Joi.object({
-    entityId: Joi.string().uuid().required(),
-    entityType: Joi.string().required(),
-    schema: schemaObject.required(),
-  }),
-
-  update: Joi.object({
-    entityId: Joi.string().uuid(),
-    entityType: Joi.string(),
-    schema: schemaObject,
-    disabled: Joi.boolean(),
-  }).min(1),
-};
-
-export default validationSchemas;

package/src/errors/index.ts

@@ -1,70 +0,0 @@
-/* eslint-disable max-classes-per-file */
-import { BadRequest } from '@autofleet/errors';
-import type { ValidationError } from 'joi';
-import type { EntriesValidationError } from '../types/entries';
-
-export class MissingRequiredCustomFieldError extends BadRequest {
-  constructor(missingFields: string[]) {
-    const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
-    super([err], null, missingFields);
-    this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
-  }
-}
-
-export class UnsupportedCustomFieldTypeError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Type "${fieldType}" is not supported`);
-    super([err], null, null);
-    this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
-  }
-}
-
-export class UnsupportedCustomValidationError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Validation for "${fieldType}" is not supported`);
-    super([err], null, null);
-    this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
-  }
-}
-
-export class InvalidFieldTypeError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Invalid field type ${fieldType}`);
-    super([err], null, null);
-    this.message = 'INVALID_FIELD_TYPE';
-  }
-}
-
-export class InvalidValueError extends BadRequest {
-  constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError) {
-    const formattedErrorMessage = joiValidationError.message
-      .replace(/"/g, '')
-      .replace('value', `'${fieldDefinitionName}'`);
-
-    const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
-
-    const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
-
-    const err = new Error(invalidValueMessage);
-    super([err], null, null);
-    this.message = invalidValueMessage;
-  }
-}
-
-export class InvalidEntriesError extends BadRequest {
-  constructor(modelId: string, validationErrors: EntriesValidationError[]) {
-    const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
-    super(errors, null, null);
-    this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (
-      `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`
-    )).join('\n')}`;
-  }
-}
-
-export class MissingDefinitionError extends BadRequest {
-  constructor(fieldNames: string[]) {
-    const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
-    super([err], null, null);
-    this.message = 'MISSING_DEFINITION';
-  }
-}

package/src/events/index.ts

@@ -1,63 +0,0 @@
-import Events from '@autofleet/events';
-import { getUser } from '@autofleet/zehut';
-import logger from '../utils/logger';
-import type {
-  CustomFieldDefinition,
-  CustomFieldEntries,
-  CustomFieldValue,
-  CustomValidator,
-} from '../models';
-
-const events = new Events({
-  logger,
-  getUserId: (payload) => payload?.user_id ?? getUser()?.id ?? null,
-});
-
-const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
-
-const stringifyBooleans = (savedObject: any, keysToConvert: string[]) => {
-  const savedObjectKeySet = new Set(Object.keys(savedObject));
-  if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
-    return savedObject;
-  }
-  return {
-    ...savedObject,
-    ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
-  };
-};
-
-const modelTableMapping = {
-  CustomFieldDefinition: {
-    tableName: 'dim_custom_field_definition',
-    eventVersion: '1',
-  },
-  CustomFieldValue: {
-    tableName: 'dim_custom_field_value',
-    eventVersion: '1',
-  },
-  CustomFieldEntries: {
-    tableName: 'dim_custom_field_entries',
-    eventVersion: '1',
-  },
-};
-
-export const sendDimEvent = (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator): void => {
-  const mapping = modelTableMapping[instance.constructor.name];
-  if (!mapping) {
-    return;
-  }
-  let objectToSend = instance.get();
-  try {
-    objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
-  } catch (err) {
-    logger.error('Failed to convert booleans in dim event payload', err);
-  }
-
-  events.sendObject(
-    mapping.tableName,
-    mapping.eventVersion,
-    objectToSend,
-  ).catch(() => {});
-};
-
-export default events;

package/src/hooks/create.ts

@@ -1,81 +0,0 @@
-import type { WhereOptions } from 'sequelize';
-import logger from '../utils/logger';
-import * as DefinitionRepo from '../repository/definition';
-import { MissingRequiredCustomFieldError } from '../errors';
-import type { CustomFieldOptions, ModelOptions } from '../types';
-import applyScopeToInstance from '../utils/scopeAttributes';
-import updateInstanceValues from './utils/updateInstanceValues';
-
-/**
- * A hook to create the custom fields when updating a model (more then one instance).
- */
-export const beforeBulkCreate = (options): void => {
-  // This will activate the beforeCreate hook on each updating instance.
-  // eslint-disable-next-line no-param-reassign
-  options.individualHooks = true;
-};
-/**
- * A hook to create the custom fields when updating a model instance.
- * TODO - cleanup if update fail
- */
-export const beforeCreate = (
-  scopeAttributes: string[],
-  modelOptions: ModelOptions = {},
-  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
-) => async (
-  instance,
-  options,
-): 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);
-
-  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 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;
-    });
-  }
-
-  const { customFields } = instance;
-  const fieldsNames = Object.keys(customFields ?? {});
-  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
-  if (missingFields?.length) {
-    throw new MissingRequiredCustomFieldError(missingFields);
-  }
-
-  const customFieldsIdx = fields.indexOf('customFields');
-  if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
-    // After checking for required fields and fields with default values, and we have no custom fields.
-    return;
-  }
-
-  await updateInstanceValues({
-    modelId: instance.id,
-    modelType,
-    identifiers,
-    customFields,
-    options: {
-      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-      transaction: options.transaction,
-      modelOptions,
-    },
-  });
-
-  // eslint-disable-next-line no-param-reassign
-  fields.splice(customFieldsIdx, 1);
-};

package/src/hooks/enrich.ts

@@ -1,255 +0,0 @@
-/* eslint-disable no-param-reassign */
-import * as ValueRepo from '../repository/value';
-import * as DefinitionRepo from '../repository/definition';
-import * as EntriesRepo from '../repository/entries';
-import type CustomFieldValue from '../models/CustomFieldValue';
-import type CustomFieldDefinition from '../models/CustomFieldDefinition';
-import type { SerializedCustomFields } from '../types/definition';
-import type { CustomFieldOptions, ModelOptions, TransactionOptions } from '../types';
-import applyScopeToInstance from '../utils/scopeAttributes';
-
-// Include all required fields for proper functioning
-const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = [
-  'id',
-  'name',
-  'entityId',
-  'fieldType',
-  'displayName',
-  'validation',
-  'entityType',
-  'modelType',
-  'required',
-  'disabled',
-  'defaultValue',
-];
-
-type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
-
-type CustomFieldEntries = Record<string, any>;
-
-interface GetValuesGroupByInstanceResponse {
-  [modelId: string]: CustomFieldValue[];
-}
-
-interface GetCustomFieldEntriesByInstanceIdResponse {
-  [modelId: string]: CustomFieldEntries;
-}
-
-export const getCustomFieldEntriesByInstanceId = async ({
-  instancesIds,
-  options,
-  sadotOptions,
-}: {
-  instancesIds: string[],
-  options?: TransactionOptions,
-  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
-}): Promise<GetCustomFieldEntriesByInstanceIdResponse> => {
-  if (!sadotOptions.useCustomFieldsEntries) {
-    return {};
-  }
-
-  const customFieldEntries = await EntriesRepo.findEntriesByModelIds(
-    instancesIds,
-    options ?? {},
-  );
-
-  const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
-    const { modelId, customFields } = instanceEntries?.dataValues ?? {};
-    if (!modelId) {
-      return undefined;
-    }
-    return [modelId, customFields];
-  }).filter(Boolean));
-
-  instancesIds.forEach((instanceId) => {
-    customFieldEntriesByInstanceId[instanceId] ??= {};
-  });
-
-  return customFieldEntriesByInstanceId;
-};
-
-export const getValuesGroupByInstance = async ({
-  instancesIds,
-  options,
-  sadotOptions,
-}: {
-  instancesIds: string[],
-  options?: TransactionOptions,
-  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
-}): Promise<GetValuesGroupByInstanceResponse> => {
-  if (sadotOptions.useCustomFieldsEntries) {
-    return {};
-  }
-
-  const customFieldValues = await ValueRepo.findValuesByModelIds(
-    instancesIds,
-    options ?? {},
-  );
-
-  // Group fields by modelId
-  return customFieldValues.reduce((acc, v) => {
-    const { modelId } = v;
-    acc[modelId] ??= [];
-    acc[modelId].push(v);
-    return acc;
-  }, {});
-};
-
-/**
- * Serialize custom fields value into the format of {[name] -> [fieldData]}
- */
-const serializeCustomFields = (
-  customFieldValues: CustomFieldValue[],
-  customFieldDefinitionsHash: Record<string, CustomFieldDefinition>,
-): SerializedCustomFields => {
-  const customFields = customFieldValues.reduce((acc, cfv) => ({
-    ...acc,
-    ...(
-      customFieldDefinitionsHash[cfv.customFieldDefinitionId]
-      && { [customFieldDefinitionsHash[cfv.customFieldDefinitionId].name]: cfv.value }
-    ),
-  }), {});
-  return customFields;
-};
-/**
- * A hook to attach the custom fields when fetching a model instances.
- */
-const enrichResults = (
-  modelType: string,
-  scopeAttributes: string[],
-  hookType?: SupportedHookTypes,
-  modelOptions: ModelOptions = {},
-  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
-) => async (
-  instancesOrInstance: any | any[],
-  options: TransactionOptions,
-): Promise<void> => {
-  if (
-    options.originalAttributes?.length > 0
-      && !options.originalAttributes?.includes?.('customFields')
-  ) {
-    return;
-  }
-
-  const primaryKey = 'id';
-  let instances = Array.isArray(instancesOrInstance)
-    ? instancesOrInstance
-    : [instancesOrInstance];
-
-  instances = instances.filter(Boolean);
-
-  const identifiers = applyScopeToInstance(instances, scopeAttributes);
-
-  const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
-
-  const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
-    ...map,
-    [identifier]: [],
-  }), {});
-
-  // Cache for definitions by model type and transaction to avoid redundant DB queries
-  let customFieldDefinitionsPromise;
-  let cacheKey;
-
-  if (options.transaction) {
-    // Initialize definition cache Map if not already present directly on the transaction object
-    options.transaction.definitionCache ||= new Map();
-    cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(',')}`;
-    customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
-  }
-
-  if (!customFieldDefinitionsPromise) {
-    // Fetch from database (either first time in this transaction or no transaction)
-    customFieldDefinitionsPromise = DefinitionRepo.findByEntityIds(
-      modelType,
-      uniqueIdentifiers,
-      { transaction: options.transaction, modelOptions, attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL },
-    );
-
-    options.transaction?.definitionCache?.set(cacheKey, customFieldDefinitionsPromise);
-  }
-  const customFieldDefinitions = await customFieldDefinitionsPromise;
-
-  if (customFieldDefinitions.length === 0) {
-    // if no custom fields, we can return
-    instances.forEach((instance) => {
-      instance.customFields = {};
-    });
-    return;
-  }
-
-  if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
-    // if we pass useEntityIdFromInclude,
-    //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
-    modelOptions.include(identifiers).forEach(({ model }) => {
-      customFieldDefinitions.forEach((cfd) => {
-        const entityId = cfd[`${model.name}.entityId`];
-        identifierCustomFieldDefinitionsMapping[entityId] = [];
-      });
-    });
-  }
-
-  const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
-    ...map,
-    [definition.id]: definition,
-  }), {});
-
-  customFieldDefinitions.forEach((cfd) => {
-    identifierCustomFieldDefinitionsMapping[cfd.entityId].push(cfd);
-  });
-
-  // Get the values per instates ids:
-  const instancesIds = instances.map((i) => i[primaryKey]);
-
-  // Group fields by modelId
-  const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([
-    getValuesGroupByInstance({
-      instancesIds,
-      options,
-      sadotOptions,
-    }),
-    getCustomFieldEntriesByInstanceId({
-      instancesIds,
-      options,
-      sadotOptions,
-    }),
-  ]);
-
-  // Attach custom fields to the instances
-  instances.forEach((instance) => {
-    const { id } = instance;
-
-    const instanceValues = valuesGroupByInstance[id];
-    const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
-
-    const customFields = sadotOptions.useCustomFieldsEntries
-      ? customFieldEntriesByInstanceId[id]
-      : serializedCustomFieldsValues;
-
-    scopeAttributes.forEach((attribute) => {
-      const identifier = instance[attribute];
-
-      const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
-      if (entityCustomFieldDefinitions?.length > 0) {
-        entityCustomFieldDefinitions.forEach((customFieldDefinition) => {
-          if (customFields[customFieldDefinition.name] === undefined) {
-            customFields[customFieldDefinition.name] = null;
-          }
-        });
-      }
-    });
-    instance.customFields = customFields;
-    options.attributesToRemove?.forEach?.((attribute) => {
-      delete instance.dataValues?.[attribute];
-      // if raw:
-      delete instance?.[attribute];
-    });
-    // sequelize will think customFields changed also in 'find', so we need to mark it as unchanged
-    if (hookType === 'afterFind') {
-      // changed() could be undefined, i.e in raw: true
-      instance?.changed?.('customFields', false);
-    }
-  });
-};
-
-export default enrichResults;

package/src/hooks/find.ts

@@ -1,27 +0,0 @@
-/* eslint-disable no-param-reassign */
-import logger from '../utils/logger';
-
-const doScopeAttributesMissing = (
-  scopeAttributes: string[],
-  queryAttributes: (string | string[])[],
-): string[] => {
-  const attributes = scopeAttributes
-    .filter((attribute) => !queryAttributes.includes(attribute));
-  if (!queryAttributes.includes?.('id')) {
-    attributes.push('id');
-  }
-  return attributes;
-};
-
-// eslint-disable-next-line import/prefer-default-export
-export const beforeFind = (scopeAttributes: string[]) => (options): void => {
-  const { attributes: queryAttributes } = options;
-  if (queryAttributes?.includes?.('customFields')) {
-    const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
-    logger.debug('sadot - before find hook');
-    if (missingScopeAttributes?.length > 0) {
-      queryAttributes.push(...missingScopeAttributes);
-      options.attributesToRemove = missingScopeAttributes;
-    }
-  }
-};