@autofleet/sadot 1.2.0 → 1.2.1-beta

package/src/hooks/create.ts

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

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

@@ -0,0 +1,27 @@
+/* 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;
+    }
+  }
+};