@autofleet/sadot 1.6.18-beta.2 → 1.6.18-beta.21

package/dist/models/FieldPolicy.d.cts

@@ -0,0 +1,25 @@
+import { Model } from "sequelize-typescript";
+
+//#region src/models/FieldPolicy.d.ts
+type EntityType = "vehicle" | "driver";
+type ModelMode = "full" | "partial";
+type ModelInclusion = {
+  name: string;
+  mode: "full";
+} | {
+  name: string;
+  mode: "partial";
+  fields: string[];
+};
+declare class FieldPolicy extends Model {
+  id: string;
+  contextId: string;
+  entityType: EntityType | null;
+  name: string;
+  /** Base-level field names to include */
+  fields: string[];
+  /** Model inclusions; full = all fields, partial = only listed fields */
+  models: ModelInclusion[];
+}
+//#endregion
+export { EntityType, FieldPolicy, ModelInclusion, ModelMode };

package/dist/models/FieldPolicy.d.ts

@@ -0,0 +1,25 @@
+import { Model } from "sequelize-typescript";
+
+//#region src/models/FieldPolicy.d.ts
+type EntityType = "vehicle" | "driver";
+type ModelMode = "full" | "partial";
+type ModelInclusion = {
+  name: string;
+  mode: "full";
+} | {
+  name: string;
+  mode: "partial";
+  fields: string[];
+};
+declare class FieldPolicy extends Model {
+  id: string;
+  contextId: string;
+  entityType: EntityType | null;
+  name: string;
+  /** Base-level field names to include */
+  fields: string[];
+  /** Model inclusions; full = all fields, partial = only listed fields */
+  models: ModelInclusion[];
+}
+//#endregion
+export { EntityType, FieldPolicy, ModelInclusion, ModelMode };

package/dist/models/FieldPolicy.js

@@ -0,0 +1,53 @@
+import { __decorateMetadata } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import { Column, DataType, Default, Model, PrimaryKey, Table } from "sequelize-typescript";
+import { randomUUID } from "node:crypto";
+
+//#region src/models/FieldPolicy.ts
+let FieldPolicy = class FieldPolicy$1 extends Model {};
+__decorate([
+	PrimaryKey,
+	Default(() => randomUUID()),
+	Column({
+		type: DataType.UUID,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], FieldPolicy.prototype, "id", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], FieldPolicy.prototype, "contextId", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: true
+}), __decorateMetadata("design:type", Object)], FieldPolicy.prototype, "entityType", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], FieldPolicy.prototype, "name", void 0);
+__decorate([Column({
+	type: DataType.JSONB,
+	allowNull: false,
+	defaultValue: []
+}), __decorateMetadata("design:type", Array)], FieldPolicy.prototype, "fields", void 0);
+__decorate([Column({
+	type: DataType.JSONB,
+	allowNull: false,
+	defaultValue: []
+}), __decorateMetadata("design:type", Array)], FieldPolicy.prototype, "models", void 0);
+FieldPolicy = __decorate([Table({
+	tableName: "field_policies",
+	modelName: "FieldPolicy",
+	timestamps: true,
+	underscored: true,
+	indexes: [{
+		name: "unique_context_policy",
+		fields: ["context_id", "name"],
+		unique: true
+	}]
+})], FieldPolicy);
+var FieldPolicy_default = FieldPolicy;
+
+//#endregion
+export { FieldPolicy_default as default };

package/dist/models/index.cjs

@@ -0,0 +1,163 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/logger/index.cjs');
+const require_CustomFieldValue = require('./CustomFieldValue.cjs');
+const require_CustomFieldDefinition = require('./CustomFieldDefinition.cjs');
+const require_AssociatedTestModel = require('./tests/AssociatedTestModel.cjs');
+const require_TestModel = require('./tests/TestModel.cjs');
+const require_ContextTestModel = require('./tests/contextAwareModels/ContextTestModel.cjs');
+const require_ContextAwareTestModel = require('./tests/contextAwareModels/ContextAwareTestModel.cjs');
+const require_CustomFieldEntries = require('./CustomFieldEntries.cjs');
+const require_CustomValidator = require('./CustomValidator.cjs');
+const require_CustomFieldModelTypeMap = require('./CustomFieldModelTypeMap.cjs');
+const require_index$1 = require('../migrations/index.cjs');
+let sequelize = require("sequelize");
+
+//#region src/models/index.ts
+const testModels = [
+	require_TestModel.default,
+	require_AssociatedTestModel.default,
+	require_ContextAwareTestModel.default,
+	require_ContextTestModel.default
+];
+const SADOT_MIGRATION_PREFIX = "sadot-migration";
+const SCHEMA_VERSION = "5f8e4a7c-9b2d-4e1f-8c3a-b6d9e2f7a4c1";
+/**
+* Legacy migration approach using sequelize.sync({ alter: true }).
+* TODO: Remove this function once all consumers have migrated to umzug.
+*/
+const legacySyncMigrations = async (sequelize$1, { schemaPrefix, schemaVersion, useCustomFieldsEntries, useModelTypeMapping }) => {
+	const SequelizeMeta = sequelize$1.define("SequelizeMeta", { name: {
+		type: sequelize.DataTypes.STRING,
+		allowNull: false,
+		unique: true,
+		primaryKey: true,
+		autoIncrement: false
+	} }, {
+		tableName: "SequelizeMeta",
+		timestamps: false,
+		schema: "public"
+	});
+	require_index.default.info("custom-fields: starting migrations");
+	const migrations = await SequelizeMeta.findAll({
+		where: { name: { [sequelize.Op.like]: `${schemaPrefix}%` } },
+		raw: true
+	});
+	const currentSadotSchemaVersion = migrations.at(-1);
+	const expectedSchemaVersionIndex = migrations.findIndex((m) => m.name === schemaVersion);
+	require_index.default.info("custom-fields: migrations", {
+		currentMigrations: migrations,
+		currentSadotSchemaVersion,
+		newSadotSchemaVersion: schemaVersion,
+		expectedSchemaVersionIndex
+	});
+	if (!currentSadotSchemaVersion || currentSadotSchemaVersion.name !== schemaVersion) {
+		require_index.default.info("custom-fields: syncing models");
+		try {
+			await require_CustomFieldDefinition.default.sync({ alter: true });
+			require_index.default.info("custom-fields: CustomFieldDefinition synced successfully");
+			await require_CustomFieldValue.default.sync({ alter: true });
+			require_index.default.info("custom-fields: CustomFieldValue synced successfully");
+			await require_CustomValidator.default.sync({ alter: true });
+			require_index.default.info("custom-fields: CustomValidator synced successfully");
+			if (useCustomFieldsEntries) {
+				await require_CustomFieldEntries.default.sync({ alter: true });
+				require_index.default.info("custom-fields: CustomFieldEntries synced successfully");
+			}
+			if (useModelTypeMapping) {
+				await require_CustomFieldModelTypeMap.default.sync({ alter: true });
+				require_index.default.info("custom-fields: CustomFieldModelTypeMap synced successfully");
+			}
+			if (expectedSchemaVersionIndex === -1) {
+				await SequelizeMeta.create({ name: schemaVersion });
+				require_index.default.info("custom-fields: SequelizeMeta entry created successfully");
+			}
+			require_index.default.info("custom-fields: models synced");
+			if (migrations.length && expectedSchemaVersionIndex !== -1 && expectedSchemaVersionIndex < migrations.length - 1) {
+				const migrationsToDelete = migrations.slice(expectedSchemaVersionIndex + 1);
+				require_index.default.info("custom-fields: deleting newer migrations during down migration", { count: migrationsToDelete.length });
+				await SequelizeMeta.destroy({ where: { name: { [sequelize.Op.in]: migrationsToDelete.map((m) => m.name) } } });
+				require_index.default.info("custom-fields: newer migrations deleted successfully");
+			}
+		} catch (error) {
+			require_index.default.error("custom-fields: failed to sync models", { error });
+			throw error;
+		}
+	}
+};
+const initTables = async (sequelize$1, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, useModelTypeMapping = false, runLegacyMigrations = false, isMatPathEnabled } = {}) => {
+	const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? "_withEntries" : ""}${useModelTypeMapping ? "_withTypeMapping" : ""}`;
+	require_index.default.info("custom-fields: initialize custom-fields tables");
+	if (!sequelize$1.addModels) throw new Error("sequelize instance must have addModels function");
+	const productionModels = [
+		require_CustomFieldDefinition.default,
+		require_CustomFieldValue.default,
+		require_CustomValidator.default,
+		...useCustomFieldsEntries ? [require_CustomFieldEntries.default] : [],
+		...useModelTypeMapping ? [require_CustomFieldModelTypeMap.default] : []
+	];
+	sequelize$1.addModels(productionModels);
+	if (useModelTypeMapping) {
+		require_CustomFieldDefinition.default.hasMany(require_CustomFieldModelTypeMap.default, {
+			foreignKey: "customFieldDefinitionId",
+			as: "modelTypeMappings"
+		});
+		require_CustomFieldModelTypeMap.default.belongsTo(require_CustomFieldDefinition.default, {
+			foreignKey: "customFieldDefinitionId",
+			as: "customFieldDefinition"
+		});
+	}
+	require_CustomFieldDefinition.default.addScope("userScope", () => {
+		if (isMatPathEnabled?.()) return {};
+		const user = getUser();
+		if (!user?.permissions) return {};
+		return { where: { entityId: [
+			...Object.keys(user.permissions.fleets),
+			...Object.keys(user.permissions.businessModels),
+			...Object.keys(user.permissions.demandSources)
+		] } };
+	});
+	require_CustomValidator.default.addScope("userScope", () => {
+		if (isMatPathEnabled?.()) return {};
+		const user = getUser();
+		if (!user?.permissions) return {};
+		return { where: { entityId: [
+			...Object.keys(user.permissions.fleets),
+			...Object.keys(user.permissions.businessModels),
+			...Object.keys(user.permissions.demandSources)
+		] } };
+	});
+	require_index.default.info("custom-fields: models added");
+	if (runLegacyMigrations) {
+		require_index.default.info("custom-fields: running legacy sync migrations");
+		await legacySyncMigrations(sequelize$1, {
+			schemaPrefix,
+			schemaVersion: CUSTOM_FIELDS_SCHEMA_VERSION,
+			useCustomFieldsEntries,
+			useModelTypeMapping
+		});
+		return;
+	}
+	require_index.default.info("custom-fields: starting umzug migrations");
+	await require_index$1.runSadotMigrations(sequelize$1, {
+		useCustomFieldsEntries,
+		useModelTypeMapping
+	});
+	require_index.default.info("custom-fields: umzug migrations complete");
+};
+const initTestModels = async (sequelize$1) => {
+	require_index.default.info("custom-fields: initialize custom-fields test models");
+	if (!sequelize$1.addModels) throw new Error("sequelize instance must have addModels function");
+	sequelize$1.addModels(testModels);
+	await sequelize$1.dropSchema("custom-fields", { logging: false });
+	await sequelize$1.createSchema("custom-fields", { logging: false });
+	require_index.default.info("custom-fields: test models added");
+	await require_TestModel.default.sync({ alter: true });
+	await require_AssociatedTestModel.default.sync({ alter: true });
+	await require_ContextTestModel.default.sync({ alter: true });
+	await require_ContextAwareTestModel.default.sync({ alter: true });
+	require_index.default.info("custom-fields: test models synced");
+};
+
+//#endregion
+exports.initTables = initTables;
+exports.initTestModels = initTestModels;

package/dist/models/index.d.ts

@@ -0,0 +1,11 @@
+import { CustomFieldValue } from "./CustomFieldValue.js";
+import { CustomFieldModelTypeMap } from "./CustomFieldModelTypeMap.js";
+import { CustomFieldDefinition } from "./CustomFieldDefinition.js";
+import { CustomValidator } from "./CustomValidator.js";
+import "../types/index.js";
+import "./tests/AssociatedTestModel.js";
+import "./tests/TestModel.js";
+import "./tests/contextAwareModels/ContextTestModel.js";
+import "./tests/contextAwareModels/ContextAwareTestModel.js";
+import { CustomFieldEntries } from "./CustomFieldEntries.js";
+import { Sequelize } from "sequelize-typescript";

package/dist/models/index.js

@@ -0,0 +1,161 @@
+import logger_default from "../utils/logger/index.js";
+import CustomFieldValue_default from "./CustomFieldValue.js";
+import CustomFieldDefinition_default from "./CustomFieldDefinition.js";
+import AssociatedTestModel_default from "./tests/AssociatedTestModel.js";
+import TestModel_default from "./tests/TestModel.js";
+import ContextTestModel_default from "./tests/contextAwareModels/ContextTestModel.js";
+import ContextAwareTestModel_default from "./tests/contextAwareModels/ContextAwareTestModel.js";
+import CustomFieldEntries_default from "./CustomFieldEntries.js";
+import CustomValidator_default from "./CustomValidator.js";
+import CustomFieldModelTypeMap_default from "./CustomFieldModelTypeMap.js";
+import { runSadotMigrations } from "../migrations/index.js";
+import { DataTypes, Op } from "sequelize";
+
+//#region src/models/index.ts
+const testModels = [
+	TestModel_default,
+	AssociatedTestModel_default,
+	ContextAwareTestModel_default,
+	ContextTestModel_default
+];
+const SADOT_MIGRATION_PREFIX = "sadot-migration";
+const SCHEMA_VERSION = "5f8e4a7c-9b2d-4e1f-8c3a-b6d9e2f7a4c1";
+/**
+* Legacy migration approach using sequelize.sync({ alter: true }).
+* TODO: Remove this function once all consumers have migrated to umzug.
+*/
+const legacySyncMigrations = async (sequelize, { schemaPrefix, schemaVersion, useCustomFieldsEntries, useModelTypeMapping }) => {
+	const SequelizeMeta = sequelize.define("SequelizeMeta", { name: {
+		type: DataTypes.STRING,
+		allowNull: false,
+		unique: true,
+		primaryKey: true,
+		autoIncrement: false
+	} }, {
+		tableName: "SequelizeMeta",
+		timestamps: false,
+		schema: "public"
+	});
+	logger_default.info("custom-fields: starting migrations");
+	const migrations = await SequelizeMeta.findAll({
+		where: { name: { [Op.like]: `${schemaPrefix}%` } },
+		raw: true
+	});
+	const currentSadotSchemaVersion = migrations.at(-1);
+	const expectedSchemaVersionIndex = migrations.findIndex((m) => m.name === schemaVersion);
+	logger_default.info("custom-fields: migrations", {
+		currentMigrations: migrations,
+		currentSadotSchemaVersion,
+		newSadotSchemaVersion: schemaVersion,
+		expectedSchemaVersionIndex
+	});
+	if (!currentSadotSchemaVersion || currentSadotSchemaVersion.name !== schemaVersion) {
+		logger_default.info("custom-fields: syncing models");
+		try {
+			await CustomFieldDefinition_default.sync({ alter: true });
+			logger_default.info("custom-fields: CustomFieldDefinition synced successfully");
+			await CustomFieldValue_default.sync({ alter: true });
+			logger_default.info("custom-fields: CustomFieldValue synced successfully");
+			await CustomValidator_default.sync({ alter: true });
+			logger_default.info("custom-fields: CustomValidator synced successfully");
+			if (useCustomFieldsEntries) {
+				await CustomFieldEntries_default.sync({ alter: true });
+				logger_default.info("custom-fields: CustomFieldEntries synced successfully");
+			}
+			if (useModelTypeMapping) {
+				await CustomFieldModelTypeMap_default.sync({ alter: true });
+				logger_default.info("custom-fields: CustomFieldModelTypeMap synced successfully");
+			}
+			if (expectedSchemaVersionIndex === -1) {
+				await SequelizeMeta.create({ name: schemaVersion });
+				logger_default.info("custom-fields: SequelizeMeta entry created successfully");
+			}
+			logger_default.info("custom-fields: models synced");
+			if (migrations.length && expectedSchemaVersionIndex !== -1 && expectedSchemaVersionIndex < migrations.length - 1) {
+				const migrationsToDelete = migrations.slice(expectedSchemaVersionIndex + 1);
+				logger_default.info("custom-fields: deleting newer migrations during down migration", { count: migrationsToDelete.length });
+				await SequelizeMeta.destroy({ where: { name: { [Op.in]: migrationsToDelete.map((m) => m.name) } } });
+				logger_default.info("custom-fields: newer migrations deleted successfully");
+			}
+		} catch (error) {
+			logger_default.error("custom-fields: failed to sync models", { error });
+			throw error;
+		}
+	}
+};
+const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, useModelTypeMapping = false, runLegacyMigrations = false, isMatPathEnabled } = {}) => {
+	const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? "_withEntries" : ""}${useModelTypeMapping ? "_withTypeMapping" : ""}`;
+	logger_default.info("custom-fields: initialize custom-fields tables");
+	if (!sequelize.addModels) throw new Error("sequelize instance must have addModels function");
+	const productionModels = [
+		CustomFieldDefinition_default,
+		CustomFieldValue_default,
+		CustomValidator_default,
+		...useCustomFieldsEntries ? [CustomFieldEntries_default] : [],
+		...useModelTypeMapping ? [CustomFieldModelTypeMap_default] : []
+	];
+	sequelize.addModels(productionModels);
+	if (useModelTypeMapping) {
+		CustomFieldDefinition_default.hasMany(CustomFieldModelTypeMap_default, {
+			foreignKey: "customFieldDefinitionId",
+			as: "modelTypeMappings"
+		});
+		CustomFieldModelTypeMap_default.belongsTo(CustomFieldDefinition_default, {
+			foreignKey: "customFieldDefinitionId",
+			as: "customFieldDefinition"
+		});
+	}
+	CustomFieldDefinition_default.addScope("userScope", () => {
+		if (isMatPathEnabled?.()) return {};
+		const user = getUser();
+		if (!user?.permissions) return {};
+		return { where: { entityId: [
+			...Object.keys(user.permissions.fleets),
+			...Object.keys(user.permissions.businessModels),
+			...Object.keys(user.permissions.demandSources)
+		] } };
+	});
+	CustomValidator_default.addScope("userScope", () => {
+		if (isMatPathEnabled?.()) return {};
+		const user = getUser();
+		if (!user?.permissions) return {};
+		return { where: { entityId: [
+			...Object.keys(user.permissions.fleets),
+			...Object.keys(user.permissions.businessModels),
+			...Object.keys(user.permissions.demandSources)
+		] } };
+	});
+	logger_default.info("custom-fields: models added");
+	if (runLegacyMigrations) {
+		logger_default.info("custom-fields: running legacy sync migrations");
+		await legacySyncMigrations(sequelize, {
+			schemaPrefix,
+			schemaVersion: CUSTOM_FIELDS_SCHEMA_VERSION,
+			useCustomFieldsEntries,
+			useModelTypeMapping
+		});
+		return;
+	}
+	logger_default.info("custom-fields: starting umzug migrations");
+	await runSadotMigrations(sequelize, {
+		useCustomFieldsEntries,
+		useModelTypeMapping
+	});
+	logger_default.info("custom-fields: umzug migrations complete");
+};
+const initTestModels = async (sequelize) => {
+	logger_default.info("custom-fields: initialize custom-fields test models");
+	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_default.info("custom-fields: test models added");
+	await TestModel_default.sync({ alter: true });
+	await AssociatedTestModel_default.sync({ alter: true });
+	await ContextTestModel_default.sync({ alter: true });
+	await ContextAwareTestModel_default.sync({ alter: true });
+	logger_default.info("custom-fields: test models synced");
+};
+
+//#endregion
+export { initTables, initTestModels };

package/dist/models/tests/AssociatedTestModel.cjs

@@ -0,0 +1,51 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_decorateMetadata = require('../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs');
+const require_TestModel = require('./TestModel.cjs');
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/models/tests/AssociatedTestModel.ts
+var _ref;
+let AssociatedTestModel = class AssociatedTestModel$1 extends sequelize_typescript.Model {};
+require_decorate.__decorate([
+	sequelize_typescript.PrimaryKey,
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.UUID,
+		defaultValue: sequelize_typescript.DataType.UUIDV4,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], AssociatedTestModel.prototype, "id", void 0);
+require_decorate.__decorate([
+	(0, sequelize_typescript.ForeignKey)(() => require_TestModel.default),
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.UUID,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], AssociatedTestModel.prototype, "testModelId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "fleetId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "businessModelId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "demandSourceId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.BOOLEAN }), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], AssociatedTestModel.prototype, "anotherAttribute", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.BelongsTo)(() => require_TestModel.default), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref = typeof require_TestModel.default !== "undefined" && require_TestModel.default) === "function" ? _ref : Object)], AssociatedTestModel.prototype, "testModel", void 0);
+AssociatedTestModel = require_decorate.__decorate([(0, sequelize_typescript.Table)({
+	schema: "custom-fields",
+	tableName: "associated_test_models",
+	createdAt: false,
+	updatedAt: false,
+	modelName: "AssociatedTestModel"
+})], AssociatedTestModel);
+var AssociatedTestModel_default = AssociatedTestModel;
+
+//#endregion
+exports.default = AssociatedTestModel_default;

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

@@ -0,0 +1,2 @@
+import "./TestModel.js";
+import { Model } from "sequelize-typescript";

package/dist/models/tests/AssociatedTestModel.js

@@ -0,0 +1,50 @@
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import TestModel_default from "./TestModel.js";
+import { BelongsTo, Column, DataType, ForeignKey, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/tests/AssociatedTestModel.ts
+var _ref;
+let AssociatedTestModel = class AssociatedTestModel$1 extends Model {};
+__decorate([
+	PrimaryKey,
+	Column({
+		type: DataType.UUID,
+		defaultValue: DataType.UUIDV4,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], AssociatedTestModel.prototype, "id", void 0);
+__decorate([
+	ForeignKey(() => TestModel_default),
+	Column({
+		type: DataType.UUID,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], AssociatedTestModel.prototype, "testModelId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "fleetId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: true
+}), __decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "businessModelId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: true
+}), __decorateMetadata("design:type", String)], AssociatedTestModel.prototype, "demandSourceId", void 0);
+__decorate([Column({ type: DataType.BOOLEAN }), __decorateMetadata("design:type", Boolean)], AssociatedTestModel.prototype, "anotherAttribute", void 0);
+__decorate([BelongsTo(() => TestModel_default), __decorateMetadata("design:type", typeof (_ref = typeof TestModel_default !== "undefined" && TestModel_default) === "function" ? _ref : Object)], AssociatedTestModel.prototype, "testModel", void 0);
+AssociatedTestModel = __decorate([Table({
+	schema: "custom-fields",
+	tableName: "associated_test_models",
+	createdAt: false,
+	updatedAt: false,
+	modelName: "AssociatedTestModel"
+})], AssociatedTestModel);
+var AssociatedTestModel_default = AssociatedTestModel;
+
+//#endregion
+export { AssociatedTestModel_default as default };

package/dist/models/tests/TestModel.cjs

@@ -0,0 +1,43 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_decorateMetadata = require('../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs');
+const require_AssociatedTestModel = require('./AssociatedTestModel.cjs');
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/models/tests/TestModel.ts
+let TestModel = class TestModel$1 extends sequelize_typescript.Model {};
+require_decorate.__decorate([
+	sequelize_typescript.PrimaryKey,
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.UUID,
+		defaultValue: sequelize_typescript.DataType.UUIDV4,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], TestModel.prototype, "id", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], TestModel.prototype, "fleetId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], TestModel.prototype, "businessModelId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], TestModel.prototype, "demandSourceId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.BOOLEAN }), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], TestModel.prototype, "coolAttribute", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.HasMany)(() => require_AssociatedTestModel.default), require_decorateMetadata.__decorateMetadata("design:type", Array)], TestModel.prototype, "associatedModels", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.VIRTUAL }), require_decorateMetadata.__decorateMetadata("design:type", Object)], TestModel.prototype, "customFields", void 0);
+TestModel = require_decorate.__decorate([(0, sequelize_typescript.Table)({
+	schema: "custom-fields",
+	tableName: "test_models",
+	createdAt: false,
+	updatedAt: false,
+	modelName: "TestModel"
+})], TestModel);
+var TestModel_default = TestModel;
+
+//#endregion
+exports.default = TestModel_default;

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

@@ -0,0 +1,2 @@
+import "./AssociatedTestModel.js";
+import { Model } from "sequelize-typescript";

package/dist/models/tests/TestModel.js

@@ -0,0 +1,42 @@
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import AssociatedTestModel_default from "./AssociatedTestModel.js";
+import { Column, DataType, HasMany, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/tests/TestModel.ts
+let TestModel = class TestModel$1 extends Model {};
+__decorate([
+	PrimaryKey,
+	Column({
+		type: DataType.UUID,
+		defaultValue: DataType.UUIDV4,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], TestModel.prototype, "id", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], TestModel.prototype, "fleetId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: true
+}), __decorateMetadata("design:type", String)], TestModel.prototype, "businessModelId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: true
+}), __decorateMetadata("design:type", String)], TestModel.prototype, "demandSourceId", void 0);
+__decorate([Column({ type: DataType.BOOLEAN }), __decorateMetadata("design:type", Boolean)], TestModel.prototype, "coolAttribute", void 0);
+__decorate([HasMany(() => AssociatedTestModel_default), __decorateMetadata("design:type", Array)], TestModel.prototype, "associatedModels", void 0);
+__decorate([Column({ type: DataType.VIRTUAL }), __decorateMetadata("design:type", Object)], TestModel.prototype, "customFields", void 0);
+TestModel = __decorate([Table({
+	schema: "custom-fields",
+	tableName: "test_models",
+	createdAt: false,
+	updatedAt: false,
+	modelName: "TestModel"
+})], TestModel);
+var TestModel_default = TestModel;
+
+//#endregion
+export { TestModel_default as default };