@autofleet/sadot 1.2.0 → 1.2.1-beta

package/dist/tests/functional/searching/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../index");
+const DefinitionRepo = __importStar(require("../../../repository/definition"));
+const definition_mock_1 = require("../../mocks/definition.mock");
+const testModel_1 = require("../../mocks/testModel");
+const models_1 = require("../../../models");
+const customFieldsSearchTestFlow = async ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }) => {
+    const definition = (0, definition_mock_1.createDefinition)({ fieldType, name: 'coolDefinition' });
+    await DefinitionRepo.create({ ...definition });
+    const [testModel1] = await (0, testModel_1.createTestModels)(definition.entityId, 2);
+    await testModel1.update({ customFields: { [definition.name]: fieldValue } });
+    const models = await models_1.TestModel.findAndCountAll({
+        ...(0, index_1.generateCustomFieldSearchQueryPayload)(searchTerm, models_1.TestModel, definition.entityId),
+    });
+    expect(models.count).toBe(expectedNumberOfQueryResults);
+    if (expectedNumberOfQueryResults > 0) {
+        expect(models.rows[0].dataValues.id).toBe(testModel1.id);
+    }
+};
+exports.default = customFieldsSearchTestFlow;

package/dist/tests/helpers/commonHooks.d.ts

@@ -0,0 +1,6 @@
+import type { Application } from 'express';
+import type { Models } from '../../types';
+export declare function commonTestHooks(app?: Application | null, models?: Models[], options?: {
+    useCustomFieldsEntries: boolean;
+    useValidators?: boolean;
+}): void;

package/dist/tests/helpers/commonHooks.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonTestHooks = void 0;
+const __1 = __importDefault(require("../.."));
+const _1 = require(".");
+const database_config_1 = __importDefault(require("./database-config"));
+const db_1 = __importStar(require("../../utils/db"));
+function commonTestHooks(app = null, models = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }], options = {
+    useCustomFieldsEntries: false,
+    useValidators: false,
+}) {
+    let sequelize;
+    beforeAll(async () => {
+        sequelize = (0, db_1.default)(database_config_1.default);
+        await (0, db_1.createSequelizeMeta)(sequelize);
+        await (0, __1.default)(app, _1.getModel, {
+            models,
+            databaseConfig: database_config_1.default,
+            getUser: () => undefined,
+            sequelize,
+            useCustomFieldsEntries: options.useCustomFieldsEntries,
+            useValidators: options.useValidators,
+        });
+    });
+    afterEach(async () => {
+        jest.clearAllMocks();
+        await (0, _1.cleanup)({
+            useCustomFieldsEntries: options.useCustomFieldsEntries,
+            useValidators: options.useValidators,
+        });
+    });
+    afterAll(async () => {
+        await sequelize.close();
+    });
+}
+exports.commonTestHooks = commonTestHooks;

package/dist/tests/helpers/database-config.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    test: {
+        username: string;
+        password: string;
+        database: string;
+        host: string;
+        port: string | number;
+        dialect: string;
+        define: {
+            underscored: boolean;
+            underscoredAll: boolean;
+        };
+        logging: boolean;
+    };
+};
+export default _default;

package/dist/tests/helpers/database-config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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/dist/tests/helpers/index.d.ts

@@ -0,0 +1,7 @@
+import type { CustomFieldOptions } from '../../types';
+export declare const cleanup: (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries' | 'useValidators'>) => Promise<void>;
+export declare const getModel: (name: string) => any;
+export declare const getReplacementMapWithScopeValue: (conditions: Record<string, any>) => {
+    replacementsMap: Record<string, string>;
+    scopeValue: Record<string, any>;
+};

package/dist/tests/helpers/index.js

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

package/dist/tests/mocks/definition.mock.d.ts

@@ -0,0 +1,48 @@
+import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+export declare const contextAwareFieldDefinition: {
+    name: string;
+    modelType: string;
+    fieldType: string;
+    entityType: string;
+};
+export declare const coolFieldDefinition: CreateCustomFieldDefinition;
+export declare const coolFieldDefinition2: {
+    name: string;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    defaultValue?: any;
+    blockEditingFromUI?: boolean;
+    displayName?: string;
+    fieldType: string;
+    validation?: any;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const coolFieldDefinition3: {
+    name: string;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    defaultValue?: any;
+    blockEditingFromUI?: boolean;
+    displayName?: string;
+    fieldType: string;
+    validation?: any;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const selectField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const statusField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const fileField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const createDefinition: (defaults: Partial<CustomFieldDefinitionDTO>) => CreateCustomFieldDefinition;
+export declare const createDefinitions: (defaults: Partial<CustomFieldDefinitionDTO>, length?: number) => CreateCustomFieldDefinition[];

package/dist/tests/mocks/definition.mock.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefinitions = exports.createDefinition = exports.fileField = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+const node_crypto_1 = require("node:crypto");
+exports.contextAwareFieldDefinition = {
+    name: 'cool field',
+    modelType: 'ContextAwareTestModel',
+    fieldType: 'number',
+    entityType: 'fleetId',
+};
+exports.coolFieldDefinition = {
+    name: 'cool field',
+    modelType: 'TestModel',
+    fieldType: 'number',
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+};
+exports.coolFieldDefinition2 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field2',
+};
+exports.coolFieldDefinition3 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field3',
+};
+const booleanField = (modelType) => ({
+    name: 'shapeless',
+    modelType,
+    fieldType: 'boolean',
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.booleanField = booleanField;
+const selectField = (modelType, options) => ({
+    name: 'choices',
+    modelType,
+    fieldType: 'select',
+    validation: options,
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.selectField = selectField;
+const statusField = (modelType, options) => ({
+    name: 'lifecycle',
+    modelType,
+    fieldType: 'status',
+    validation: options,
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.statusField = statusField;
+const fileField = (modelType) => ({
+    name: 'file',
+    modelType,
+    fieldType: 'file',
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.fileField = fileField;
+// eslint-disable-next-line max-len
+const createDefinition = (defaults) => ({
+    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
+    entityType: defaults?.entityType || 'fleetId',
+    ...(defaults?.validation && { validation: defaults.validation }),
+    ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
+});
+exports.createDefinition = createDefinition;
+const createDefinitions = (defaults, length = 1) => (Array(length).fill({}).map((_) => ({
+    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
+    entityType: defaults?.entityType || 'fleetId',
+})));
+exports.createDefinitions = createDefinitions;

package/dist/tests/mocks/events.mock.d.ts

@@ -0,0 +1,4 @@
+export declare const mockEvent: (events: any, eventName: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldDefinitionEvent: (events: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldValueEvent: (events: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldEntriesEvent: (events: any, numberOfEvents: any) => any[];

package/dist/tests/mocks/events.mock.js

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

package/dist/tests/mocks/testModel.d.ts

@@ -0,0 +1,12 @@
+import { TestModel } from '../../models';
+export declare const createTestModel: (payload?: {}) => Promise<TestModel>;
+export declare const createTestModels: (fleetId: any, total: number) => Promise<TestModel[]>;
+export declare const upsertTestModel: (payload: any) => Promise<[TestModel, boolean]>;
+export declare const destroyTestModels: () => Promise<number>;
+export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel | null>;
+export declare const getSomeTestModels: (options?: {
+    limit: number;
+}) => Promise<TestModel[]>;
+export declare const updateTestModel: (payload: any, query: any) => Promise<[affectedCount: number, affectedRows: TestModel[]]>;
+export declare const createTestModelWithAssociation: () => Promise<TestModel>;
+export declare const getTestModelWithAssociation: (limit?: number) => Promise<TestModel[]>;

package/dist/tests/mocks/testModel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestModelWithAssociation = exports.createTestModelWithAssociation = exports.updateTestModel = exports.getSomeTestModels = exports.getTestModel = exports.destroyTestModels = exports.upsertTestModel = exports.createTestModels = exports.createTestModel = void 0;
+const models_1 = require("../../models");
+const createTestModel = (payload = {}) => models_1.TestModel.create(payload);
+exports.createTestModel = createTestModel;
+const createTestModels = (fleetId, total) => {
+    const models = [];
+    for (let i = 0; i < total; i += 1) {
+        models.push((0, exports.createTestModel)({ fleetId }));
+    }
+    return Promise.all(models);
+};
+exports.createTestModels = createTestModels;
+const upsertTestModel = (payload) => models_1.TestModel.upsert(payload);
+exports.upsertTestModel = upsertTestModel;
+const destroyTestModels = () => models_1.TestModel.destroy({ truncate: true });
+exports.destroyTestModels = destroyTestModels;
+const getTestModel = (id, options = {}) => models_1.TestModel.findByPk(id, options);
+exports.getTestModel = getTestModel;
+const getSomeTestModels = (options = { limit: 1 }) => models_1.TestModel.findAll(options);
+exports.getSomeTestModels = getSomeTestModels;
+const updateTestModel = (payload, query) => models_1.TestModel.update(payload, query);
+exports.updateTestModel = updateTestModel;
+// Associations
+const createTestModelWithAssociation = async () => {
+    const model = await models_1.TestModel.create({});
+    await models_1.AssociatedTestModel.create({ testModelId: model.id });
+    return model;
+};
+exports.createTestModelWithAssociation = createTestModelWithAssociation;
+const getTestModelWithAssociation = (limit = 1) => models_1.TestModel.findAll({
+    limit, include: [models_1.AssociatedTestModel],
+});
+exports.getTestModelWithAssociation = getTestModelWithAssociation;

package/dist/types/definition/index.d.ts

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

package/dist/types/definition/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/entries/index.d.ts

@@ -0,0 +1,25 @@
+import type { ValidationError } from 'joi';
+export interface CustomFieldEntriesDTO {
+    modelId: string;
+    entityId: string;
+    modelType: string;
+    /**
+     * A collection of custom fields where each key is the name of a CustomFieldDefinition and
+     * each value is the value of that custom field for this specific `modelId`.
+     *
+     * Example:
+     * {
+     *   "vehicleColor": "Red",
+     *   "vehicleType": "premium",
+     *   "isActive": true
+     * }
+     */
+    customFields: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface EntriesValidationError {
+    value: any;
+    fieldDefinitionName: string;
+    joiValidationError: ValidationError;
+}

package/dist/types/entries/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,49 +1,47 @@
-import "../models/CustomFieldDefinition.js";
-import "../models/CustomValidator.js";
-import { IncludeOptions } from "sequelize";
-import { getUser } from "@autofleet/zehut";
-import { ModelCtor, Sequelize } from "sequelize-typescript";
-
-//#region src/types/index.d.ts
-type ModelFetcher = (name: string) => any;
-interface ModelOptions {
-  /**
-  * Include options for the model
-  */
-  include?: (entityIds: string | string[]) => IncludeOptions[];
-  /**
-  * Custom association for the model
-  * @param model - The model to associate with
-  */
-  customAssociation?: (model: ModelCtor) => void;
-  /**
-  * Whether to use the entity id  from the instance per scope attribute
-  */
-  useEntityIdFromInclude?: boolean;
-  /**
-  * Which attributes to include in the model
-  */
-  attributes?: string[];
+import type { IncludeOptions, Transaction } from 'sequelize';
+import type { ModelCtor, Sequelize } from 'sequelize-typescript';
+import type { getUser as GetUserType } from '@autofleet/zehut';
+import type CustomFieldDefinition from '../models/CustomFieldDefinition';
+import type CustomValidator from '../models/CustomValidator';
+export type ModelFetcher = (name: string) => any;
+export interface TransactionOptions extends Record<string, any> {
+    transaction?: Transaction & {
+        definitionCache?: Map<string, CustomFieldDefinition[]>;
+        validationsCache?: Map<string, CustomValidator[]>;
+    };
 }
-interface Models {
-  name: string;
-  scopeAttributes: any[];
-  modelOptions?: ModelOptions;
-  hasTypeId?: boolean;
-  creationWebhookHandler?: (instance: any) => any;
-  updateWebhookHandler?: (instance: any) => any;
-  deletionWebhookHandler?: (instance: any) => any;
-}
-interface CustomFieldOptions {
-  models: Models[];
-  hasTypeId?: boolean;
-  databaseConfig: any;
-  getUser: typeof getUser;
-  sequelize?: Sequelize;
-  useCustomFieldsEntries?: boolean;
-  useValidators?: boolean;
-  useModelTypeMapping?: boolean;
-}
-//#endregion
-export { CustomFieldOptions, ModelFetcher, Models };
-//# sourceMappingURL=index.d.ts.map
+export type ModelOptions = {
+    /**
+     * Include options for the model
+     */
+    include?: (entityIds: string[] | string) => IncludeOptions[];
+    /**
+      * Custom association for the model
+      * @param model - The model to associate with
+     */
+    customAssociation?: (model: ModelCtor) => void;
+    /**
+     * Whether to use the entity id  from the instance per scope attribute
+     */
+    useEntityIdFromInclude?: boolean;
+    /**
+     * Which attributes to include in the model
+     */
+    attributes?: string[];
+};
+export type Models = {
+    name: string;
+    scopeAttributes: any[];
+    modelOptions?: ModelOptions;
+    creationWebhookHandler?: (instance: any) => any;
+    updateWebhookHandler?: (instance: any) => any;
+    deletionWebhookHandler?: (instance: any) => any;
+};
+export type CustomFieldOptions = {
+    models: Models[];
+    databaseConfig: any;
+    getUser: typeof GetUserType;
+    sequelize?: Sequelize;
+    useCustomFieldsEntries?: boolean;
+    useValidators?: boolean;
+};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/value/index.d.ts

@@ -0,0 +1,15 @@
+export interface CustomFieldValueDTO {
+    id?: string;
+    modelId: string;
+    customFieldDefinitionId: string;
+    value: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+}
+export type ValuesToUpdate = {
+    [name: string]: any;
+};
+export type CreateCustomFieldValue = Omit<CustomFieldValueDTO, 'id'>;
+export type UpdateCustomFieldValue = ValuesToUpdate;
+export type BulkUpdateCustomFieldValue = Partial<CustomFieldValueDTO>[];

package/dist/types/value/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/constants/index.d.ts

@@ -1,22 +1,19 @@
-import { customFields } from "@autofleet/common-types";
-
-//#region src/utils/constants/index.d.ts
-declare const supportedEntities: readonly ["businessModelId", "fleetId", "demandSourceId"];
+declare const CUSTOM_FIELDS_FILTER_SCOPE: "filterByCustomFields";
+export declare const supportedEntities: string[];
 /**
-* Supported custom field types
-*/
-declare enum CustomFieldDefinitionType {
-  NUMBER = "number",
-  BOOLEAN = "boolean",
-  DATE = "date",
-  DATETIME = "datetime",
-  TEXT = "text",
-  IMAGE = "image",
-  SELECT = "select",
-  STATUS = "status",
-  FILE = "file",
+ * Supported custom field types
+ */
+export declare enum CustomFieldDefinitionType {
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    DATETIME = "datetime",
+    TEXT = "text",
+    IMAGE = "image",
+    SELECT = "select",
+    STATUS = "status",
+    FILE = "file"
 }
-declare const CUSTOM_FIELDS_FILTER_SCOPE: typeof customFields.CUSTOM_FIELDS_FILTER_SCOPE;
-//#endregion
-export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities };
-//# sourceMappingURL=index.d.ts.map
+export { 
+/** @deprecated Use the value from `@autofleet/common-types` instead */
+CUSTOM_FIELDS_FILTER_SCOPE, };

package/dist/utils/constants/index.js

@@ -1,2 +1,22 @@
-import{customFields as e}from"@autofleet/common-types";const t=[`businessModelId`,`fleetId`,`demandSourceId`];let n=function(e){return e.NUMBER=`number`,e.BOOLEAN=`boolean`,e.DATE=`date`,e.DATETIME=`datetime`,e.TEXT=`text`,e.IMAGE=`image`,e.SELECT=`select`,e.STATUS=`status`,e.FILE=`file`,e}({});const r=e.CUSTOM_FIELDS_FILTER_SCOPE;export{r as CUSTOM_FIELDS_FILTER_SCOPE,n as CustomFieldDefinitionType,t as supportedEntities};
-//# sourceMappingURL=index.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.CustomFieldDefinitionType = exports.supportedEntities = void 0;
+const common_types_1 = require("@autofleet/common-types");
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+exports.CUSTOM_FIELDS_FILTER_SCOPE = CUSTOM_FIELDS_FILTER_SCOPE;
+exports.supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];
+/**
+ * Supported custom field types
+ */
+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["STATUS"] = "status";
+    CustomFieldDefinitionType["FILE"] = "file";
+})(CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = CustomFieldDefinitionType = {}));

package/dist/utils/db/index.d.ts

@@ -0,0 +1,4 @@
+import { Sequelize } from 'sequelize-typescript';
+declare const _default: (databaseConfig: any) => Sequelize;
+export default _default;
+export declare const createSequelizeMeta: (sequelize: Sequelize) => Promise<object[]>;