@autofleet/sadot 1.1.2-beta → 1.1.2

package/src/scopes/filter.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-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 };
-};