@autofleet/sadot 0.0.1-beta.9 → 0.0.2-beta

package/dist/src/utils/validations/type.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomFieldDefinitionType = void 0;
+const joi_1 = __importDefault(require("@hapi/joi"));
+/**
+ * Supported custom field types
+ */
+// eslint-disable-next-line no-shadow
+var CustomFieldDefinitionType;
+(function (CustomFieldDefinitionType) {
+    CustomFieldDefinitionType["NUMBER"] = "number";
+    CustomFieldDefinitionType["BOOLEAN"] = "boolean";
+    CustomFieldDefinitionType["DATE"] = "date";
+    CustomFieldDefinitionType["DATETIME"] = "datetime";
+    CustomFieldDefinitionType["TEXT"] = "text";
+    CustomFieldDefinitionType["IMAGE"] = "image";
+    CustomFieldDefinitionType["SELECT"] = "select";
+})(CustomFieldDefinitionType = exports.CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = {}));
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+const validateValueType = (value, valueType) => {
+    if (value === null) {
+        // Null is always allowed
+        return true;
+    }
+    switch (valueType) {
+        case CustomFieldDefinitionType.TEXT:
+            return typeof value === 'string';
+        case CustomFieldDefinitionType.NUMBER:
+            return typeof value === 'number';
+        case CustomFieldDefinitionType.BOOLEAN:
+            return typeof value === 'boolean';
+        case CustomFieldDefinitionType.DATE:
+        case CustomFieldDefinitionType.DATETIME:
+            return !joi_1.default.date().validate(value).error;
+        case CustomFieldDefinitionType.SELECT:
+            return true; // custom validation
+        case CustomFieldDefinitionType.IMAGE:
+            return !joi_1.default.array().min(1).unique().items(joi_1.default.string().uri())
+                .validate(value).error;
+        default:
+            return false;
+    }
+};
+exports.default = validateValueType;

package/dist/src/utils/validations/validators.d.ts

@@ -0,0 +1,12 @@
+export declare enum CustomValidations {
+    SELECT = "select",
+    RANGE = "between"
+}
+type Validator = (value: any, validation: any) => boolean;
+/**
+ * Validators for custom fields
+ */
+declare const validators: {
+    [key: string]: Validator;
+};
+export default validators;

package/dist/src/utils/validations/validators.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomValidations = void 0;
+// eslint-disable-next-line no-shadow
+var CustomValidations;
+(function (CustomValidations) {
+    CustomValidations["SELECT"] = "select";
+    CustomValidations["RANGE"] = "between";
+})(CustomValidations = exports.CustomValidations || (exports.CustomValidations = {}));
+/**
+ * Validate {@link CustomValidations.ENUM Enum}
+ */
+const validateEnum = (value, enumValues) => (Array.isArray(enumValues)
+    && enumValues.length > 0
+    && enumValues.includes(value));
+/**
+ * Validate {@link CustomValidations.RANGE Range}
+ */
+const validateRange = (value, range) => {
+    const [min, max] = range;
+    if (min === undefined || max === undefined) {
+        return false;
+    }
+    return value >= range.min && value <= range.max;
+};
+/**
+ * Validators for custom fields
+ */
+const validators = {
+    [CustomValidations.SELECT]: validateEnum,
+    [CustomValidations.RANGE]: validateRange,
+};
+exports.default = validators;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.0.1-beta.9",
+  "version": "0.0.2-beta",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -26,6 +26,8 @@
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/jest": "^27.0.9",
+    "@types/node": "^20.5.6",
+    "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "@typescript-eslint/parser": "^4.33.0",
     "eslint": "^7.13.0",

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

@@ -20,12 +20,12 @@ router.post('/', async (req: Request, res: Response) => {
   const modelType = toPascalCase(modelName);
   try {
     const validatedPayload: CreateCustomFieldDefinition = await
-    validateCustomFieldDefinitionCreation({
-      ...req.body,
+    validateCustomFieldDefinitionCreation(req.body);
+
+    const customFieldDefinition = await DefinitionRepo.create({
+      ...validatedPayload,
       modelType,
     });
-
-    const customFieldDefinition = await DefinitionRepo.create(validatedPayload);
     return res.status(201).json(customFieldDefinition);
   } catch (err) {
     logger.error('Failed to create custom field definition', err);
@@ -57,11 +57,18 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
  */
 router.get('/', async (req, res) => {
   const { modelName } = req.params as any;
+  const { entityIds } = req.query as any;
+
   const modelType = toPascalCase(modelName);
   try {
-    const customFieldDefinitions = await DefinitionRepo.findAll({
-      modelType,
-    }, { withDisabled: true });
+    const where: any = { modelType };
+    if (entityIds?.length > 0) {
+      where.entityId = entityIds;
+    }
+    const customFieldDefinitions = await DefinitionRepo.findAll(
+      { ...where },
+      { withDisabled: true },
+    );
     return res.json(customFieldDefinitions);
   } catch (err) {
     logger.error('Failed to fetch custom field definitions', err);
@@ -90,7 +97,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
 
     const updatedCustomFieldDefinition = await DefinitionRepo.update(
       customFieldDefinitionId,
-      validatedPayload,
+      { ...validatedPayload, modelType },
     );
 
     return res.status(200).json(updatedCustomFieldDefinition);

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

@@ -1,22 +1,19 @@
 import Joi from '@hapi/joi';
-import { CustomFieldDefinitionType } from '../../../models/CustomFieldDefinition';
+import { CustomFieldDefinitionType } from '../../../utils/validations/type';
+
+const ValidationSchema = Joi.when('fieldType', {
+  is: CustomFieldDefinitionType.SELECT,
+  then: Joi.array().items(Joi.string()).min(1).unique(),
+  otherwise: Joi.any(),
+});
 
 const CustomFieldDefinitionCreationSchema = Joi.object({
   name: Joi.string().required(),
   displayName: Joi.string().required(),
-  validation: Joi.object().required(),
-  fieldType: Joi.string().valid(
-    CustomFieldDefinitionType.BOOLEAN,
-    CustomFieldDefinitionType.NUMBER,
-    CustomFieldDefinitionType.DATE,
-    CustomFieldDefinitionType.DATETIME,
-    CustomFieldDefinitionType.TEXT,
-    CustomFieldDefinitionType.IMAGE,
-    CustomFieldDefinitionType.ENUM,
-  ).required(),
+  validation: ValidationSchema,
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
   entityId: Joi.string().guid().required(),
   entityType: Joi.string().required(),
-  modelType: Joi.string().required(),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
@@ -24,19 +21,8 @@ const CustomFieldDefinitionCreationSchema = Joi.object({
 
 const CustomFieldDefinitionUpdateSchema = Joi.object({
   displayName: Joi.string(),
-  validation: Joi.object(),
-  fieldType: Joi.string().valid(
-    CustomFieldDefinitionType.BOOLEAN,
-    CustomFieldDefinitionType.NUMBER,
-    CustomFieldDefinitionType.DATE,
-    CustomFieldDefinitionType.DATETIME,
-    CustomFieldDefinitionType.TEXT,
-    CustomFieldDefinitionType.IMAGE,
-    CustomFieldDefinitionType.ENUM,
-  ),
-  entityId: Joi.string().guid(),
-  entityType: Joi.string(),
-  modelType: Joi.string(),
+  validation: ValidationSchema,
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),

package/src/api/v1/index.ts

@@ -4,6 +4,6 @@ import definitionRouter from './definition';
 
 const router = Router({ mergeParams: true });
 
-router.use('/:modelName/custom-field-definitions', definitionRouter);
+router.use('/custom-field-definitions/:modelName', definitionRouter);
 
 export default router;

package/src/errors/index.ts

@@ -0,0 +1,42 @@
+/* eslint-disable max-classes-per-file */
+import { BadRequest } from '@autofleet/errors';
+
+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 InvalidValueError extends BadRequest {
+  constructor(value: any, fieldType: string) {
+    const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+    super([err], null, null);
+    this.message = 'INVALID_VALUE';
+  }
+}
+
+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

@@ -3,6 +3,21 @@ import logger from '../utils/logger';
 
 const events = new Events({ logger });
 
+const KEYS_TO_CONVERT = ['value'];
+
+const stringifyBools = (savedObject: any, keysToConvert: Array<string>) => {
+  if (Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
+    const objectToReturn = { ...savedObject };
+    keysToConvert.forEach((key) => {
+      if (typeof savedObject[key] === 'boolean') {
+        objectToReturn[key] = savedObject[key].toString();
+      }
+    });
+    return objectToReturn;
+  }
+  return savedObject;
+};
+
 const modelTableMapping = {
   CustomFieldDefinition: {
     tableName: 'dim_custom_field_definition',
@@ -17,10 +32,17 @@ const modelTableMapping = {
 export const sendDimEvent = (instance): void => {
   const mapping = modelTableMapping[instance.constructor.name];
   if (mapping) {
+    let objectToSend = instance.get();
+    try {
+      objectToSend = stringifyBools(instance.get(), KEYS_TO_CONVERT);
+    } catch (err) {
+      logger.error('Failed to convert booleans in dim event payload', err);
+    }
+
     events.sendObject(
       mapping.tableName,
       mapping.eventVersion,
-      instance.get(),
+      objectToSend,
     );
   }
 };

package/src/hooks/create.ts

@@ -1,5 +1,7 @@
+import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
+import { MissingRequiredCustomFieldError } from '../errors';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -17,6 +19,7 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
   instance,
   options,
 ): Promise<void> => {
+  logger.debug('sadot - before create hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
   const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
@@ -28,8 +31,9 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
   const { customFields } = instance;
   if (customFieldsIdx > -1 && customFields) {
     const fieldsNames = Object.keys(customFields);
-    if (requiredFieldsNames.some((name) => !fieldsNames.includes(name))) {
-      throw new Error('some fields are required');
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length > 0) {
+      throw new MissingRequiredCustomFieldError(missingFields);
     }
 
     await ValueRepo.updateValues(
@@ -42,6 +46,6 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
   } else if (requiredFieldsNames?.length > 0) {
-    throw new Error('some fields are required');
+    throw new MissingRequiredCustomFieldError(requiredFieldsNames);
   }
 };

package/src/hooks/enrich.ts

@@ -0,0 +1,125 @@
+/* eslint-disable no-param-reassign */
+import * as ValueRepo from '../repository/value';
+import * as DefinitionRepo from '../repository/definition';
+import CustomFieldValue from '../models/CustomFieldValue';
+import CustomFieldDefinition from '../models/CustomFieldDefinition';
+import { SerializedCustomFields } from '../types/definition';
+import logger from '../utils/logger';
+
+/**
+ * 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[]) => async (
+  instancesOrInstance: any | any[],
+  options,
+): 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 = instances.map((instance) =>
+    scopeAttributes
+      .map((attr) => instance[attr])).flat();
+
+  const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+  const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
+    ...map,
+    [identifier]: [],
+  }), {});
+  const customFieldDefinitions = await DefinitionRepo.findByEntityIds(
+    modelType,
+    uniqueIdentifiers,
+    { transaction: options.transaction },
+  );
+
+  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]);
+
+  const customFieldValues = await ValueRepo.findValuesByModelIds(
+    instancesIds,
+    { transaction: options.transaction },
+  );
+
+  // Group fields by modelId
+  const valuesGroupByInstance: {
+      [modelId: string]: CustomFieldValue[];
+    } = customFieldValues.reduce((acc, v) => {
+      const { modelId } = v;
+      if (!acc[modelId]) {
+        acc[modelId] = [];
+      }
+      acc[modelId].push(v);
+      return acc;
+    }, {});
+
+  // Attach custom fields to the instances
+  instances.forEach((instance) => {
+    const customFields = {};
+    const { id } = instance;
+    const instanceValues = valuesGroupByInstance[id];
+    if (instanceValues) {
+      const serializedCustomFields = serializeCustomFields(instanceValues, definitionsMap);
+      Object.assign(customFields, serializedCustomFields);
+    }
+
+    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;
+          }
+        });
+      }
+    });
+    if (customFields && Object.keys(customFields).length > 0) {
+      logger.info('sadot - enrichResults - customFields', customFields);
+      instance.customFields = customFields;
+    } else {
+      logger.info('sadot - enrichResults - no customFields');
+    }
+    options.attributesToRemove?.forEach?.((attribute) => {
+      delete instance.dataValues?.[attribute];
+      // if raw:
+      delete instance?.[attribute];
+    });
+  });
+};
+
+export default enrichResults;

package/src/hooks/find.ts

@@ -1,21 +1,6 @@
 /* eslint-disable no-param-reassign */
-import * as ValueRepo from '../repository/value';
-import * as DefinitionRepo from '../repository/definition';
-import CustomFieldValue from '../models/CustomFieldValue';
-import { SerializedCustomFields } from '../types/definition';
 import logger from '../utils/logger';
 
-/**
- * Serialize custom fields value into the format of {[name] -> [fieldData]}
- */
-const serializeCustomFields = (customFieldValues: CustomFieldValue[]): SerializedCustomFields => {
-  const customFields = customFieldValues.reduce((acc, cfv) => ({
-    ...acc,
-    [cfv.customFieldDefinition.name]: cfv.value,
-  }), {});
-  return customFields;
-};
-
 const doScopeAttributesMissing = (
   scopeAttributes: string[],
   queryAttributes: (string | string[])[],
@@ -28,99 +13,15 @@ const doScopeAttributesMissing = (
   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;
     }
   }
 };
-
-/**
- * A hook to attach the custom fields when fetching a model instances.
- */
-export const enrichResults = (scopeAttributes: string[]) => async (
-  instancesOrInstance: any | any[],
-  options,
-): Promise<void> => {
-  if (
-    options.originalAttributes?.length > 0
-    && !options.originalAttributes?.includes?.('customFields')
-  ) {
-    logger.info('No custom fields needed, returning', { options });
-    return;
-  }
-
-  const primaryKey = 'id';
-  let instances = Array.isArray(instancesOrInstance)
-    ? instancesOrInstance
-    : [instancesOrInstance];
-
-  instances = instances.filter((instance) => !!instance);
-
-  const identifiers = instances.map((instance) =>
-    scopeAttributes
-      .map((attr) => instance[attr])).flat();
-
-  const uniqueIdentifiers = [...new Set(identifiers)].filter((identifier) => !!identifier);
-  const identifierCustomFieldDefinitionsMapping = {};
-  await Promise.all(uniqueIdentifiers.map(async (identifier) => {
-    const customFieldDefinitions = await DefinitionRepo.findByEntityId(
-      identifier,
-      options.transaction,
-    );
-    identifierCustomFieldDefinitionsMapping[identifier] = customFieldDefinitions;
-  }));
-
-  // Get the values per instates ids:
-  const instancesIds = instances.map((i) => i[primaryKey]);
-
-  const customFieldValues = await ValueRepo.findValuesByModelIds(
-    instancesIds,
-    { transaction: options.transaction },
-  );
-
-  // Group fields by modelId
-  const valuesGroupByInstance: {
-    [modelId: string]: CustomFieldValue[];
-  } = customFieldValues.reduce((acc, v) => {
-    const { modelId } = v;
-    if (!acc[modelId]) {
-      acc[modelId] = [];
-    }
-    acc[modelId].push(v);
-    return acc;
-  }, {});
-
-  // Attach custom fields to the instances
-  instances.forEach((instance) => {
-    const customFields = {};
-    const { id } = instance;
-    const instanceValues = valuesGroupByInstance[id];
-    if (instanceValues) {
-      const serializedCustomFields = serializeCustomFields(instanceValues);
-      Object.assign(customFields, serializedCustomFields);
-    }
-
-    scopeAttributes.forEach((attribute) => {
-      const identifier = instance[attribute];
-      const customFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
-      if (customFieldDefinitions?.length > 0) {
-        customFieldDefinitions.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];
-    });
-  });
-};

package/src/hooks/index.ts

@@ -1,4 +1,5 @@
-import { enrichResults, beforeFind } from './find';
+import enrichResults from './enrich';
+import { beforeFind } from './find';
 import { beforeBulkUpdate, beforeUpdate } from './update';
 import { beforeBulkCreate, beforeCreate } from './create';
 import workaround from './workaround';

package/src/hooks/update.ts

@@ -1,5 +1,5 @@
+import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
-import * as DefinitionRepo from '../repository/definition';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -18,25 +18,14 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
   instance,
   options,
 ): Promise<void> => {
+  logger.debug('sadot - before update hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
   const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
 
-  // get all model's required definitions
-  const requiredNullFieldsNames = await DefinitionRepo.getRequiredFields(
-    modelType,
-    instance.id,
-    identifiers,
-    true,
-  );
-
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
     const { customFields } = instance;
-    const fieldsNames = Object.keys(customFields);
-    if (requiredNullFieldsNames.some((name) => !fieldsNames.includes(name))) {
-      throw new Error('some fields are required');
-    }
     await ValueRepo.updateValues(
       modelType,
       instance.id,
@@ -46,7 +35,5 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
     );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
-  } else if (requiredNullFieldsNames?.length > 0) {
-    throw new Error('some fields are required');
   }
 };