@autofleet/sadot 0.0.1-beta

package/dist/src/models/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTestModels = exports.initTables = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
+/* eslint-disable no-param-reassign */
+const sequelize_1 = require("sequelize");
+const logger_1 = __importDefault(require("../utils/logger"));
+const CustomFieldDefinition_1 = __importDefault(require("./CustomFieldDefinition"));
+exports.CustomFieldDefinition = CustomFieldDefinition_1.default;
+const CustomFieldValue_1 = __importDefault(require("./CustomFieldValue"));
+exports.CustomFieldValue = CustomFieldValue_1.default;
+const TestModel_1 = __importDefault(require("./tests/TestModel"));
+exports.TestModel = TestModel_1.default;
+const AssociatedTestModel_1 = __importDefault(require("./tests/AssociatedTestModel"));
+exports.AssociatedTestModel = AssociatedTestModel_1.default;
+const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default];
+const testModels = [TestModel_1.default, AssociatedTestModel_1.default];
+const SADOT_MIGRATION_PREFIX = 'sadot-migration';
+const SCHEMA_VERSION = 1;
+const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
+const initTables = async (sequelize, getUser) => {
+    logger_1.default.info('custom-fields: initialize custom-fields tables');
+    // Detect models and import them to the orm
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    if (!sequelize.addModels) {
+        throw new Error('sequelize instance must have addModels function');
+    }
+    sequelize.addModels(productionModels);
+    CustomFieldDefinition_1.default.addScope('userScope', () => {
+        const user = getUser();
+        if (user?.permissions) {
+            return {
+                where: {
+                    entityId: [
+                        ...Object.keys(user.permissions.fleets),
+                        ...Object.keys(user.permissions.businessModels),
+                        ...Object.keys(user.permissions.demandSources),
+                    ],
+                },
+            };
+        }
+        return {};
+    });
+    logger_1.default.info('custom-fields: models added');
+    const SequelizeMeta = sequelize.define('SequelizeMeta', {
+        name: {
+            type: sequelize_1.DataTypes.STRING,
+            allowNull: false,
+            unique: true,
+            primaryKey: true,
+            autoIncrement: false,
+        },
+    }, {
+        tableName: 'SequelizeMeta',
+        timestamps: false,
+        schema: 'public',
+    });
+    const migrations = await SequelizeMeta.findAll({ raw: true });
+    const currentSadotSchemaVersion = migrations
+        .reverse().find((m) => m.name.includes(SADOT_MIGRATION_PREFIX));
+    if (!currentSadotSchemaVersion
+        || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+        await CustomFieldDefinition_1.default.sync({ alter: true });
+        await CustomFieldValue_1.default.sync({ alter: true });
+        await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        logger_1.default.info('custom-fields: models synced');
+    }
+};
+exports.initTables = initTables;
+const initTestModels = async (sequelize) => {
+    logger_1.default.info('custom-fields: initialize custom-fields test models');
+    // Detect models and import them to the orm
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    if (!sequelize.addModels) {
+        throw new Error('sequelize instance must have addModels function');
+    }
+    sequelize.addModels(testModels);
+    await sequelize.dropSchema('custom-fields', { logging: false });
+    await sequelize.createSchema('custom-fields', { logging: false });
+    logger_1.default.info('custom-fields: test models added');
+    await TestModel_1.default.sync({ alter: true });
+    await AssociatedTestModel_1.default.sync({ alter: true });
+    logger_1.default.info('custom-fields: test models synced');
+};
+exports.initTestModels = initTestModels;

package/dist/src/models/tests/AssociatedTestModel.d.ts

@@ -0,0 +1,12 @@
+import { Model } from 'sequelize-typescript';
+import TestModel from './TestModel';
+declare class AssociatedTestModel extends Model {
+    id: string;
+    testModelId: string;
+    fleetId: string;
+    businessModelId: string;
+    demandSourceId: string;
+    anotherAttribute?: boolean;
+    testModel: TestModel;
+}
+export default AssociatedTestModel;

package/dist/src/models/tests/AssociatedTestModel.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const TestModel_1 = __importDefault(require("./TestModel"));
+let AssociatedTestModel = class AssociatedTestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.ForeignKey)(() => TestModel_1.default),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "testModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "fleetId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "businessModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "demandSourceId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+    }),
+    __metadata("design:type", Boolean)
+], AssociatedTestModel.prototype, "anotherAttribute", void 0);
+__decorate([
+    (0, sequelize_typescript_1.BelongsTo)(() => TestModel_1.default),
+    __metadata("design:type", TestModel_1.default)
+], AssociatedTestModel.prototype, "testModel", void 0);
+AssociatedTestModel = __decorate([
+    (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+], AssociatedTestModel);
+exports.default = AssociatedTestModel;

package/dist/src/models/tests/TestModel.d.ts

@@ -0,0 +1,11 @@
+import { Model } from 'sequelize-typescript';
+import AssociatedTestModel from './AssociatedTestModel';
+declare class TestModel extends Model {
+    id: string;
+    fleetId: string;
+    businessModelId: string;
+    demandSourceId: string;
+    coolAttribute?: boolean;
+    associatedModels: AssociatedTestModel[];
+}
+export default TestModel;

package/dist/src/models/tests/TestModel.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const AssociatedTestModel_1 = __importDefault(require("./AssociatedTestModel"));
+let TestModel = class TestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "fleetId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "businessModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "demandSourceId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+    }),
+    __metadata("design:type", Boolean)
+], TestModel.prototype, "coolAttribute", void 0);
+__decorate([
+    (0, sequelize_typescript_1.HasMany)(() => AssociatedTestModel_1.default),
+    __metadata("design:type", Array)
+], TestModel.prototype, "associatedModels", void 0);
+TestModel = __decorate([
+    (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+], TestModel);
+exports.default = TestModel;

package/dist/src/repository/definition.d.ts

@@ -0,0 +1,17 @@
+import { CustomFieldDefinition } from '../models';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const findAll: (where: any, options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findById: (id: string, options?: any) => Promise<CustomFieldDefinition | null>;
+export declare const findByEntityId: (entityId: string, options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByWhere: (where: any) => Promise<CustomFieldDefinition | null>;
+export declare const findDefinitionsByModels: (modelTypes: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const update: (id: string, data: UpdateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const disable: (id: string) => Promise<any>;
+export declare const destroy: (id: string) => Promise<any>;
+/**
+ * Return the names of the required fields for a given model
+ */
+export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[]) => Promise<string[]>;

package/dist/src/repository/definition.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequiredFields = exports.destroy = exports.disable = exports.update = exports.findDefinitionsByModels = exports.findByWhere = exports.findByEntityIds = exports.findByEntityId = exports.findById = exports.findByIds = exports.findAll = exports.create = void 0;
+const sequelize_1 = require("sequelize");
+const models_1 = require("../models");
+const create = (data) => models_1.CustomFieldDefinition.create(data);
+exports.create = create;
+const findAll = (where, options = { withDisabled: false }) => {
+    const queryModel = options.withDisabled
+        ? models_1.CustomFieldDefinition.unscoped()
+        : models_1.CustomFieldDefinition;
+    return queryModel.scope('userScope').findAll({
+        where,
+        transaction: options.transaction,
+        raw: true,
+    });
+};
+exports.findAll = findAll;
+const findByIds = (ids, options = { withDisabled: false }) => (0, exports.findAll)({ id: { [sequelize_1.Op.in]: ids } }, options);
+exports.findByIds = findByIds;
+const findById = (id, options = { withDisabled: false }) => {
+    const { withDisabled } = options;
+    if (withDisabled) {
+        return models_1.CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+    }
+    return models_1.CustomFieldDefinition.scope('userScope').findByPk(id);
+};
+exports.findById = findById;
+const findByEntityId = async (entityId, options = {}) => models_1.CustomFieldDefinition.findAll({
+    where: { entityId },
+    transaction: options.transaction,
+});
+exports.findByEntityId = findByEntityId;
+const findByEntityIds = async (modelType, entityIds, options = {}) => models_1.CustomFieldDefinition.findAll({
+    where: {
+        modelType,
+        entityId: entityIds,
+    },
+    transaction: options.transaction,
+    raw: true,
+});
+exports.findByEntityIds = findByEntityIds;
+const findByWhere = (where) => models_1.CustomFieldDefinition.scope('userScope').findOne({
+    where,
+});
+exports.findByWhere = findByWhere;
+const findDefinitionsByModels = async (modelTypes, options) => {
+    const query = { modelType: { [sequelize_1.Op.in]: modelTypes } };
+    return models_1.CustomFieldDefinition.findAll({
+        where: query,
+        transaction: options?.transaction,
+    });
+};
+exports.findDefinitionsByModels = findDefinitionsByModels;
+const update = async (id, data) => {
+    const updatedDefinition = (await models_1.CustomFieldDefinition.scope('userScope').update(data, {
+        where: { id },
+        returning: true,
+        individualHooks: true,
+    }))[1][0];
+    return updatedDefinition;
+};
+exports.update = update;
+const disable = (id) => models_1.CustomFieldDefinition.update({ disabled: true }, { where: { id } });
+exports.disable = disable;
+const destroy = (id) => models_1.CustomFieldDefinition.destroy({ where: { id } });
+exports.destroy = destroy;
+/**
+ * Return the names of the required fields for a given model
+ */
+const getRequiredFields = async (modelType, modelId, entityId) => {
+    const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+    const requiredFields = await models_1.CustomFieldDefinition.findAll({
+        where: { required: true, modelType, entityId: { [sequelize_1.Op.in]: entityIds } },
+        logging: true,
+    });
+    const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+    return [...new Set(requiredFieldsNames)];
+};
+exports.getRequiredFields = getRequiredFields;

package/dist/src/repository/value.d.ts

@@ -0,0 +1,24 @@
+import { CustomFieldValue } from '../models';
+import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+export declare const findByModelIdAndDefinition: (modelId: string, customFieldDefinitionId: string) => Promise<CustomFieldValue[]>;
+export declare const create: (data: CreateCustomFieldValue, withAssociations?: boolean) => Promise<CustomFieldValue>;
+export declare const findAllValues: () => Promise<CustomFieldValue[]>;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+export declare const findValuesByModelId: (modelId: string) => Promise<CustomFieldValue[]>;
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+export declare const findValuesByModelIds: (modelIds: string[], options?: any) => Promise<CustomFieldValue[]>;
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: any) => Promise<CustomFieldValue[]>;
+export declare const deleteValue: (id: string, options?: any) => Promise<any>;

package/dist/src/repository/value.js

@@ -0,0 +1,107 @@
+"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.deleteValue = exports.updateValues = exports.findValuesByModelIds = exports.findValuesByModelId = exports.findAllValues = exports.create = exports.findByModelIdAndDefinition = void 0;
+/* eslint-disable max-len */
+const models_1 = require("../models");
+const DefinitionRepo = __importStar(require("./definition"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const errors_1 = require("../errors");
+const findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
+exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
+const create = async (data, withAssociations = false) => {
+    const created = await models_1.CustomFieldValue.create(data);
+    if (withAssociations) {
+        const createdWithAssociations = await (0, exports.findByModelIdAndDefinition)(created.modelId, created.customFieldDefinitionId);
+        return createdWithAssociations?.[0];
+    }
+    return created;
+};
+exports.create = create;
+const findAllValues = async () => models_1.CustomFieldValue.findAll({ include: [models_1.CustomFieldDefinition] });
+exports.findAllValues = findAllValues;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+const findValuesByModelId = async (modelId) => models_1.CustomFieldValue.findAll({ where: { modelId }, include: [models_1.CustomFieldDefinition] });
+exports.findValuesByModelId = findValuesByModelId;
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+const findValuesByModelIds = async (modelIds, options) => {
+    const { transaction } = options;
+    return models_1.CustomFieldValue.findAll({
+        where: { modelId: modelIds },
+        transaction,
+        raw: true,
+        nest: true,
+    });
+};
+exports.findValuesByModelIds = findValuesByModelIds;
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
+    logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, { valuesToUpdate });
+    const names = Object.keys(valuesToUpdate);
+    const fieldDefinitions = await DefinitionRepo.findAll({ modelType, name: names, entityId: identifiers }, { withDisabled: true, transaction: options.transaction }) || [];
+    const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+    if (fieldDefinitions.length !== names.length) {
+        const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+        throw new errors_1.MissingDefinitionError(missingDefinitions);
+    }
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+    const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+    if (valuesWithDisabledDefinitions?.length > 0) {
+        logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+    }
+    const values = names.map((name) => ({
+        modelId,
+        value: valuesToUpdate[name],
+        updatedAt: new Date(),
+        customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
+    }));
+    return Promise.all(values.map(async (value) => {
+        const [cfv] = await models_1.CustomFieldValue.upsert(value, {
+            transaction: options.transaction,
+        });
+        return cfv;
+    }));
+};
+exports.updateValues = updateValues;
+const deleteValue = (id, options = {}) => models_1.CustomFieldValue.update({ deletedAt: new Date() }, {
+    where: { id },
+    transaction: options.transaction,
+});
+exports.deleteValue = deleteValue;

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

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export default app;

package/dist/src/tests/api/test-api.js

@@ -0,0 +1,56 @@
+"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 express_1 = __importStar(require("express"));
+const models_1 = require("../../models");
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+const api = (0, express_1.Router)();
+api.get('/v1/test-models', async (req, res) => {
+    const testModels = await models_1.TestModel.findAll();
+    return res.json(testModels);
+});
+api.get('/v1/test-models/:testModelId', async (req, res) => {
+    const { params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.findByPk(testModelId);
+    return res.json(testModel);
+});
+api.post('/v1/test-models', async (req, res) => {
+    const { body } = req;
+    const testModel = await models_1.TestModel.create(body);
+    return res.json(testModel);
+});
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
+    const { body, params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.update(body, {
+        where: {
+            id: testModelId,
+        },
+        returning: true,
+    });
+    return res.json(testModel[1][0]);
+});
+app.use('/api', api);
+exports.default = app;

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

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

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

@@ -0,0 +1,16 @@
+"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 || 'sadot_package_test',
+        host: process.env.DB_HOST || '127.0.0.1',
+        dialect: process.env.DB_TYPE || 'postgres',
+        define: {
+            underscored: true,
+            underscoredAll: true,
+        },
+        logging: false,
+    },
+};

package/dist/src/tests/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanup: () => Promise<void>;
+export declare const getModel: (name: string) => any;

package/dist/src/tests/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = exports.cleanup = void 0;
+const models_1 = require("../../models");
+// eslint-disable-next-line import/prefer-default-export
+const cleanup = async () => {
+    if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
+        await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
+        await models_1.TestModel.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;

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

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