@autofleet/sadot 1.1.2 → 1.1.3-beta

package/src/scopes/filter.ts

@@ -0,0 +1,100 @@
+/* eslint-disable import/prefer-default-export */
+import { Op } from 'sequelize';
+import { Sequelize } from 'sequelize-typescript';
+import { customFields } from '@autofleet/common-types';
+import { generateRandomString } from '../utils/helpers';
+import type { CustomFieldOptions } from '../types';
+import {
+  formatConditionsForEntries,
+  formatConditionsForValues,
+  getFilterCustomFieldsSubQuery,
+  getSortCustomFieldsSubQuery,
+  SubQueryType,
+  type ConditionValue,
+  type CustomFieldFilterOptions,
+} from './helpers/filter.helpers';
+
+const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
+
+type customFieldsFilterScopeParams = {
+    replacementsMap: Record<string, string>;
+    scopeValue: Record<string, ConditionValue>;
+}
+
+/**
+ * A Sequelize scope for filtering models by custom fields.
+ * This scope builds a WHERE clause to be applied on the main query.
+ *
+ * @param name - The model type name used to join custom_field_definitions.
+ * @returns A function that takes conditions and returns the Sequelize options object.
+ */
+export const customFieldsFilterScope = (
+  name: string,
+  options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
+) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams): CustomFieldFilterOptions => {
+  if (!conditions || Object.keys(conditions).length === 0) {
+    return {};
+  }
+
+  const queryType = options?.useCustomFieldsEntries ? SubQueryType.ENTRIES : SubQueryType.VALUES;
+  const reverseReplacementsMap = new Map(Object.entries(replacements).map(([key, value]) => [value, key]));
+  // Build the WHERE clause for custom field filtering
+  const conditionsStrings = Object.entries(conditions).map(([key, condition]) => {
+    switch (queryType) {
+      case SubQueryType.ENTRIES:
+        return formatConditionsForEntries(key, condition, reverseReplacementsMap);
+      case SubQueryType.VALUES:
+        return formatConditionsForValues(key, condition, reverseReplacementsMap);
+      default:
+        return false;
+    }
+  }).filter(Boolean);
+  if (conditionsStrings.length === 0) {
+    return {};
+  }
+  const subQuery = getFilterCustomFieldsSubQuery(queryType, name, conditionsStrings);
+
+  return {
+    where: {
+      id: {
+        [Op.in]: Sequelize.literal(`(${subQuery})`),
+      },
+    },
+    replacements,
+  };
+};
+
+export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
+
+export const customFieldsSortScope = (
+  name: string,
+  options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
+) => ({ replacementsMap, scopeValue: sort }) => {
+  if (!sort || sort.length === 0) {
+    return {};
+  }
+
+  const queryType = options?.useCustomFieldsEntries ? SubQueryType.ENTRIES : SubQueryType.VALUES;
+  const randomStr = generateRandomString();
+  const includes = Object.entries(sort).map(([key]) => {
+    const replacementKey = Object.keys(replacementsMap).find(
+      (randomString) => replacementsMap[randomString] === key,
+    );
+    return ([
+      Sequelize.literal(getSortCustomFieldsSubQuery(queryType, name, replacementKey)),
+      randomStr,
+    ]);
+  });
+
+  const orders = Object.entries(sort).map(([, sortObject]) => {
+    const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
+    return Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
+  });
+  return {
+    attributes: {
+      include: includes,
+    },
+    order: orders,
+    replacements: replacementsMap,
+  };
+};

package/src/scopes/helpers/filter.helpers.ts

@@ -0,0 +1,227 @@
+import type { WhereOptions } from 'sequelize';
+
+/**
+ * Type representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+export type ConditionWithOperator = {
+  operator: string;
+  value: string;
+};
+export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+
+export type CustomFieldSort = {
+  field: string;
+  direction: 'ASC' | 'DESC';
+}
+
+export type CustomFieldFilterOptions = {
+  where?: WhereOptions;
+  replacements?: Record<string, string>;
+}
+
+export enum SubQueryType {
+  VALUES = 'values',
+  ENTRIES = 'entries',
+}
+
+export const isConditionStringArray = (input: any): input is string[] => Array.isArray(input) && typeof input[0] === 'string';
+export const isBooleanString = (input: string): boolean => ['true', 'false'].includes(input.toString());
+export const isDate = (input: any): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+
+export const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
+export const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
+export const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
+export const castValueToJsonbNumeric = (value: string) => castValueToJsonb(value, 'numeric');
+export const castIfNeeded = (columnName: string, conditionValue: string): string => {
+  if (isDate(conditionValue)) {
+    return castValueToJsonb(columnName, 'timestamp');
+  }
+  return columnName;
+};
+
+export const AND_DELIMITER = ' AND ';
+export const OR_DELIMITER = ' OR ';
+export const CD_TABLE_ALIAS = 'cd';
+export const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+export const CV_TABLE_ALIAS = 'cv';
+export const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
+export const CE_TABLE_ALIAS = 'ce';
+
+const getSingleConditionWithOperator = (value: any, operator: string, replacementKey: string, reverseReplacementsMap: Map<string, string>) => {
+  let type = 'text';
+  if (isDate(value)) {
+    type = 'date';
+  } else if (!Number.isNaN(Number(value))) {
+    type = 'numeric';
+  } else if (isBooleanString(value)) {
+    type = 'boolean';
+  }
+  const replacedValue = reverseReplacementsMap.get(value);
+
+  return `(jsonb_extract_path_text(${CE_TABLE_ALIAS}.custom_fields, :${replacementKey})::${type}) ${operator} :${replacedValue}`;
+};
+
+const getFormattedValue = (value: string) => {
+  let formattedValue: string | number | boolean = value;
+  if (isBooleanString(value)) {
+    formattedValue = value === 'true';
+  } else if (!Number.isNaN(Number(value))) {
+    formattedValue = Number(value);
+  }
+
+  return formattedValue;
+};
+
+const getJSONSubQuery = (value: string, key: string) => {
+  const formattedValue = getFormattedValue(value);
+  const jsonQuery = JSON.stringify({ [key]: formattedValue });
+  let jsonQueryWithStringBoolean;
+  if (isBooleanString(value)) {
+    jsonQueryWithStringBoolean = `${CE_TABLE_ALIAS}.custom_fields @> '${JSON.stringify({ [key]: value })}'`;
+  }
+  return `
+    (
+      ${jsonQueryWithStringBoolean ? `${jsonQueryWithStringBoolean} OR` : ''}
+      ${CE_TABLE_ALIAS}.custom_fields @> '${jsonQuery}'
+    )
+  `;
+};
+
+export const getFilterCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, conditionsStrings: Array<string | boolean>): string => {
+  switch (queryType) {
+    case SubQueryType.VALUES:
+      return `
+        SELECT ${CV_TABLE_ALIAS}.model_id
+        FROM custom_field_values AS ${CV_TABLE_ALIAS}
+        INNER JOIN custom_field_definitions AS ${CD_TABLE_ALIAS} ON ${CV_TABLE_ALIAS}.custom_field_definition_id = ${CD_TABLE_ALIAS}.id
+        ${AND_DELIMITER}${CD_TABLE_ALIAS}.model_type = '${modelType}'
+        WHERE ${conditionsStrings.join(OR_DELIMITER)}
+        ${AND_DELIMITER}${CV_TABLE_ALIAS}.deleted_at IS NULL${AND_DELIMITER}${CD_TABLE_ALIAS}.deleted_at IS NULL
+        GROUP BY ${CV_TABLE_ALIAS}.model_id
+        HAVING COUNT(DISTINCT ${CV_TABLE_ALIAS}.custom_field_definition_id) = ${conditionsStrings.length}
+      `.replace(/\n/g, '');
+    case SubQueryType.ENTRIES:
+      return `
+        SELECT ce.model_id
+        FROM custom_field_entries ce
+        JOIN custom_field_definitions cfd
+        ON ce.model_type = cfd.model_type
+        AND ce.entity_id = cfd.entity_id
+        WHERE
+          cfd.deleted_at IS NULL AND
+          ${conditionsStrings.join(AND_DELIMITER)}
+      `;
+    default:
+      throw new Error('Invalid query type');
+  }
+};
+
+export const getSortCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, replacementKey: string): string => {
+  switch (queryType) {
+    case SubQueryType.VALUES:
+      return `(
+              SELECT value
+              FROM (SELECT cv.model_id, cv.value
+                    FROM custom_field_values AS cv INNER JOIN custom_field_definitions AS cd
+                      ON cv.custom_field_definition_id = cd.id
+                      ${AND_DELIMITER}cd.model_type = '${modelType}'
+                      WHERE cv.model_id = "${modelType}"."id"
+                            ${AND_DELIMITER}cd.name = :${replacementKey}
+                            ) AS CustomFieldAggregation
+              )
+            `;
+    case SubQueryType.ENTRIES:
+      return `(
+        SELECT
+            customFields.value
+        FROM
+            custom_field_entries AS ${CE_TABLE_ALIAS},
+            jsonb_each_text(custom_fields) AS customFields
+        WHERE
+          customFields.key = :${replacementKey}${AND_DELIMITER}
+          ${CE_TABLE_ALIAS}.model_type = '${modelType}'${AND_DELIMITER}
+          ${CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
+        )
+      `;
+    default:
+      throw new Error('Invalid query type');
+  }
+};
+
+export const formatConditionsForValues = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
+  const replacementKey = reverseReplacementsMap.get(key);
+  if (!replacementKey) {
+    return false;
+  }
+
+  const columnCondition = `(${CD_NAME_COLUMN} = :${replacementKey})`;
+  if (Array.isArray(condition)) {
+    if (condition.length === 0) {
+      // if empty array, the condition is ignored
+      return false;
+    }
+
+    if (isConditionStringArray(condition)) {
+      const values = condition.flatMap((v) => {
+        const valRandom = reverseReplacementsMap.get(v);
+        if (isBooleanString(v)) {
+          return [castValueToJsonbText(`:${valRandom}`), castValueToJsonbBoolean(`:${valRandom}`)];
+        }
+        if (!Number.isNaN(Number(v))) {
+          return castValueToJsonbNumeric(`:${valRandom}`);
+        }
+        return castValueToJsonbText(`:${valRandom}`);
+      }).join(',');
+      return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${values}))`;
+    }
+    return condition.map((c) => {
+      const valRep = reverseReplacementsMap.get(c.value);
+      const valueAsJsonb = castValueToJsonbText(`:${valRep}`);
+
+      return `(${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
+    }).join(AND_DELIMITER);
+  }
+  if (typeof condition === 'string' || typeof condition === 'number') {
+    const conditionRep = reverseReplacementsMap.get(condition);
+    const valueAsJsonb = !Number.isNaN(Number(condition)) ? castValueToJsonbNumeric(`:${conditionRep}`) : castValueToJsonbText(`:${conditionRep}`);
+    const valueAsJsonbBoolean = isBooleanString(condition) ? `${OR_DELIMITER}${CV_VALUE_COLUMN} = ${castValueToJsonbBoolean(`:${conditionRep}`)}` : '';
+    return `(${columnCondition}${AND_DELIMITER}(${castIfNeeded(CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
+  }
+  if (condition?.operator) {
+    const valueRep = reverseReplacementsMap.get(condition.value);
+    const valueAsJsonb = castValueToJsonbText(`:${valueRep}`);
+    return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
+  }
+  return false;
+};
+
+export const formatConditionsForEntries = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
+  const replacementKey = reverseReplacementsMap.get(key);
+  if (!replacementKey) {
+    return false;
+  }
+
+  if (Array.isArray(condition)) {
+    if (condition.length === 0) {
+      // if empty array, the condition is ignored
+      return false;
+    }
+
+    if (isConditionStringArray(condition)) {
+      const values = condition.map((value) => getJSONSubQuery(value, key)).join(`${OR_DELIMITER}\n`);
+      return `( ${values})`;
+    }
+    return condition.map((c) => getSingleConditionWithOperator(c.value, c.operator, replacementKey, reverseReplacementsMap)).join(AND_DELIMITER);
+  }
+
+  if (typeof condition === 'string' || typeof condition === 'number') {
+    return getJSONSubQuery(condition, key);
+  }
+
+  if (condition?.operator) {
+    return getSingleConditionWithOperator(condition.value, condition.operator, replacementKey, reverseReplacementsMap);
+  }
+  return false;
+};

package/src/scopes/index.ts

@@ -0,0 +1,6 @@
+/* eslint-disable import/prefer-default-export */
+import { customFieldsFilterScope } from './filter';
+
+export {
+  customFieldsFilterScope,
+};

package/src/tests/api/test-api.ts

@@ -0,0 +1,40 @@
+import express from 'express';
+import { Router } from '@autofleet/node-common';
+import logger from '../../utils/logger';
+import { TestModel } from '../../models';
+
+const app = express();
+app.use(express.json());
+const api = Router({ logger });
+
+api.get('/v1/test-models', async (req, res) => {
+  const testModels = await TestModel.findAll();
+  return res.json(testModels);
+});
+
+api.get('/v1/test-models/:testModelId', async (req, res) => {
+  const { params: { testModelId } } = req;
+  const testModel = await TestModel.findByPk(testModelId);
+  return res.json(testModel);
+});
+
+api.post('/v1/test-models', async (req, res) => {
+  const { body } = req;
+  const testModel = await TestModel.create(body);
+  return res.json(testModel);
+});
+
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
+  const { body, params: { testModelId } } = req;
+  const testModel = await TestModel.update(body, {
+    where: {
+      id: testModelId,
+    },
+    returning: true,
+  });
+  return res.json(testModel[1][0]);
+});
+
+app.use('/api', api);
+
+export default app;

package/src/tests/functional/searching/index.ts

@@ -0,0 +1,39 @@
+import { generateCustomFieldSearchQueryPayload } from '../../../index';
+import * as DefinitionRepo from '../../../repository/definition';
+import { createDefinition } from '../../mocks/definition.mock';
+import { createTestModels } from '../../mocks/testModel';
+import { TestModel } from '../../../models';
+
+interface CustomFieldsSearchTestFlowInput {
+  fieldType: string;
+  fieldValue: string | number;
+  searchTerm: string;
+  expectedNumberOfQueryResults: number;
+}
+
+const customFieldsSearchTestFlow = async ({
+  fieldType,
+  fieldValue,
+  searchTerm,
+  expectedNumberOfQueryResults,
+}: CustomFieldsSearchTestFlowInput): Promise<void> => {
+  const definition = createDefinition({ fieldType, name: 'coolDefinition' });
+  await DefinitionRepo.create({ ...definition });
+  const [testModel1] = await createTestModels(definition.entityId, 2);
+  await testModel1.update({ customFields: { [definition.name]: fieldValue } });
+  const models = await TestModel.findAndCountAll(
+    {
+      ...generateCustomFieldSearchQueryPayload(
+        searchTerm,
+        TestModel,
+        definition.entityId,
+      ),
+    },
+  );
+  expect(models.count).toBe(expectedNumberOfQueryResults);
+  if (expectedNumberOfQueryResults > 0) {
+    expect(models.rows[0].dataValues.id).toBe(testModel1.id);
+  }
+};
+
+export default customFieldsSearchTestFlow;

package/src/tests/helpers/commonHooks.ts

@@ -0,0 +1,43 @@
+import type { Application } from 'express';
+import type { Sequelize } from 'sequelize-typescript';
+import useCustomFields from '../..';
+import { cleanup, getModel } from '.';
+import databaseConfig from './database-config';
+import initDB, { createSequelizeMeta } from '../../utils/db';
+import type { Models } from '../../types';
+
+export function commonTestHooks(
+  app: Application | null = null,
+  models: Models[] = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }],
+  options: { useCustomFieldsEntries: boolean, useValidators?: boolean } = {
+    useCustomFieldsEntries: false,
+    useValidators: false,
+  },
+) {
+  let sequelize: Sequelize;
+
+  beforeAll(async () => {
+    sequelize = initDB(databaseConfig);
+    await createSequelizeMeta(sequelize);
+    await useCustomFields(app, getModel, {
+      models,
+      databaseConfig,
+      getUser: () => undefined,
+      sequelize,
+      useCustomFieldsEntries: options.useCustomFieldsEntries,
+      useValidators: options.useValidators,
+    });
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+    await cleanup({
+      useCustomFieldsEntries: options.useCustomFieldsEntries,
+      useValidators: options.useValidators,
+    });
+  });
+
+  afterAll(async () => {
+    await sequelize.close();
+  });
+}

package/src/tests/helpers/database-config.ts

@@ -0,0 +1,15 @@
+export default {
+  test: {
+    username: process.env.DB_USERNAME || '',
+    password: process.env.DB_PASSWORD || null,
+    database: process.env.DB_NAME || 'postgres',
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: process.env.DB_PORT || 5432,
+    dialect: process.env.DB_TYPE || 'postgres',
+    define: {
+      underscored: true,
+      underscoredAll: true,
+    },
+    logging: false,
+  },
+};

package/src/tests/helpers/index.ts

@@ -0,0 +1,35 @@
+import { generateFilterReplacements } from '@autofleet/sheilta';
+import {
+  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, CustomFieldEntries, CustomValidator, TestModel,
+} from '../../models';
+import type { CustomFieldOptions } from '../../types';
+
+// eslint-disable-next-line import/prefer-default-export
+export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries' | 'useValidators'>): Promise<void> => {
+  if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
+    await CustomFieldDefinition.unscoped().destroy({ where: {} });
+    await TestModel.destroy({ where: {} });
+    await ContextAwareTestModel.destroy({ where: {} });
+    await ContextTestModel.destroy({ where: {} });
+
+    if (options?.useCustomFieldsEntries) {
+      await CustomFieldEntries.unscoped().destroy({ where: {} });
+    }
+
+    // Clean up validators if they were used
+    if (options?.useValidators) {
+      await CustomValidator.unscoped().destroy({ where: {} });
+    }
+  }
+};
+
+export const getModel = (name: string) => {
+  // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+  const models = require('../../models');
+  return models[name];
+};
+
+export const getReplacementMapWithScopeValue = (conditions: Record<string, any>) => ({
+  replacementsMap: generateFilterReplacements(Object.fromEntries(Object.entries(conditions).map(([key, value]) => [`customFields.${key}`, value]))),
+  scopeValue: conditions,
+});

package/src/tests/mocks/definition.mock.ts

@@ -0,0 +1,84 @@
+import { randomUUID } from 'node:crypto';
+import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+
+export const contextAwareFieldDefinition = {
+  name: 'cool field',
+  modelType: 'ContextAwareTestModel',
+  fieldType: 'number',
+  entityType: 'fleetId',
+};
+
+export const coolFieldDefinition: CreateCustomFieldDefinition = {
+  name: 'cool field',
+  modelType: 'TestModel',
+  fieldType: 'number',
+  entityId: randomUUID(),
+  entityType: 'fleetId',
+};
+
+export const coolFieldDefinition2 = {
+  ...coolFieldDefinition,
+  name: 'cool field2',
+};
+
+export const coolFieldDefinition3 = {
+  ...coolFieldDefinition,
+  name: 'cool field3',
+};
+
+export const booleanField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'shapeless',
+  modelType,
+  fieldType: 'boolean',
+  entityId: randomUUID(),
+  entityType: 'fleetId',
+});
+
+export const selectField = (modelType: string, options): CreateCustomFieldDefinition => ({
+  name: 'choices',
+  modelType,
+  fieldType: 'select',
+  validation: options,
+  entityId: randomUUID(),
+  entityType: 'fleetId',
+});
+
+export const statusField = (modelType: string, options): CreateCustomFieldDefinition => ({
+  name: 'lifecycle',
+  modelType,
+  fieldType: 'status',
+  validation: options,
+  entityId: randomUUID(),
+  entityType: 'fleetId',
+});
+
+export const fileField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'file',
+  modelType,
+  fieldType: 'file',
+  entityId: randomUUID(),
+  entityType: 'fleetId',
+});
+
+// eslint-disable-next-line max-len
+export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
+  name: defaults?.name || `def_${randomUUID()}`,
+  modelType: defaults?.modelType || 'TestModel',
+  fieldType: defaults?.fieldType || 'boolean',
+  entityId: defaults?.entityId || randomUUID(),
+  entityType: defaults?.entityType || 'fleetId',
+  ...(defaults?.validation && { validation: defaults.validation }),
+  ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
+});
+
+export const createDefinitions = (
+  defaults: Partial<CustomFieldDefinitionDTO>,
+  length = 1,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+): CreateCustomFieldDefinition[] => (Array(length).fill({}).map((_) => ({
+  name: defaults?.name || `def_${randomUUID()}`,
+  modelType: defaults?.modelType || 'TestModel',
+  fieldType: defaults?.fieldType || 'boolean',
+  entityId: defaults?.entityId || randomUUID(),
+  entityType: defaults?.entityType || 'fleetId',
+})));

package/src/tests/mocks/events.mock.ts

@@ -0,0 +1,21 @@
+/* eslint-disable no-param-reassign */
+
+export const mockEvent = (events: any, eventName, numberOfEvents) => {
+  events.sendObject = jest.fn().mockResolvedValue(true);
+  return [
+    events.sendObject,
+    (): void => {
+      const matchingEvents = events.sendObject.mock.calls.filter((call) => call[0] === eventName);
+      expect(matchingEvents.length).toEqual(numberOfEvents);
+    },
+  ];
+};
+
+export const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) =>
+  mockEvent(events, 'dim_custom_field_definition', numberOfEvents);
+
+export const mockDimCustomFieldValueEvent = (events, numberOfEvents) =>
+  mockEvent(events, 'dim_custom_field_value', numberOfEvents);
+
+export const mockDimCustomFieldEntriesEvent = (events, numberOfEvents) =>
+  mockEvent(events, 'dim_custom_field_entries', numberOfEvents);

package/src/tests/mocks/testModel.ts

@@ -0,0 +1,37 @@
+import { TestModel, AssociatedTestModel } from '../../models';
+
+export const createTestModel = (payload = {}) => TestModel.create(payload);
+
+export const createTestModels = (fleetId, total: number) => {
+  const models: Promise<TestModel>[] = [];
+  for (let i = 0; i < total; i += 1) {
+    models.push(createTestModel({ fleetId }));
+  }
+  return Promise.all<TestModel>(models);
+};
+
+export const upsertTestModel = (payload) => TestModel.upsert(payload);
+
+export const destroyTestModels = () => TestModel.destroy({ truncate: true });
+
+export const getTestModel = (
+  id: string,
+  options = {},
+): Promise<TestModel | null> => TestModel.findByPk(id, options);
+
+export const getSomeTestModels = (
+  options = { limit: 1 },
+): Promise<TestModel[]> => TestModel.findAll(options);
+
+export const updateTestModel = (payload, query) => TestModel.update(payload, query);
+
+// Associations
+export const createTestModelWithAssociation = async () => {
+  const model = await TestModel.create({});
+  await AssociatedTestModel.create({ testModelId: model.id });
+  return model;
+};
+
+export const getTestModelWithAssociation = (limit = 1) => TestModel.findAll({
+  limit, include: [AssociatedTestModel],
+});

package/src/types/definition/index.ts

@@ -0,0 +1,24 @@
+export interface CustomFieldDefinitionDTO {
+    id: string;
+    name: string;
+    displayName?: string;
+    validation?: any;
+    defaultValue?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+    required?: boolean;
+    description?: string;
+    disabled?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    blockEditingFromUI?: boolean;
+  }
+export type CreateCustomFieldDefinition = Omit<CustomFieldDefinitionDTO, 'id'>;
+export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;
+
+export type SerializedCustomFields = {
+  [name: string]: CustomFieldDefinitionDTO & { value: any };
+};