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

package/dist/scopes/filter.d.cts

@@ -0,0 +1,22 @@
+import { CustomFieldOptions } from "../types/index.cjs";
+import { ConditionValue } from "./helpers/filter.helpers.cjs";
+import { customFields } from "@autofleet/common-types";
+import { Literal } from "sequelize/types/utils";
+
+//#region src/scopes/filter.d.ts
+
+declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, "useCustomFieldsEntries">) => ({
+  replacementsMap,
+  scopeValue: sort
+}: {
+  replacementsMap: Record<string, string>;
+  scopeValue: Record<string, ConditionValue>;
+}) => {
+  attributes: {
+    include: (string | Literal)[][];
+  };
+  order: Literal[];
+  replacements: Record<string, string>;
+} | Record<string, never>;
+//#endregion
+export { customFieldsSortScope };

package/dist/scopes/filter.d.ts

@@ -0,0 +1,22 @@
+import { CustomFieldOptions } from "../types/index.js";
+import { ConditionValue } from "./helpers/filter.helpers.js";
+import { customFields } from "@autofleet/common-types";
+import { Literal } from "sequelize/types/utils";
+
+//#region src/scopes/filter.d.ts
+
+declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, "useCustomFieldsEntries">) => ({
+  replacementsMap,
+  scopeValue: sort
+}: {
+  replacementsMap: Record<string, string>;
+  scopeValue: Record<string, ConditionValue>;
+}) => {
+  attributes: {
+    include: (string | Literal)[][];
+  };
+  order: Literal[];
+  replacements: Record<string, string>;
+} | Record<string, never>;
+//#endregion
+export { customFieldsSortScope };

package/dist/scopes/filter.js

@@ -0,0 +1,54 @@
+import { generateRandomString } from "../utils/helpers/index.js";
+import { SubQueryType, formatConditionsForEntries, formatConditionsForValues, getFilterCustomFieldsSubQuery, getSortCustomFieldsSubQuery } from "./helpers/filter.helpers.js";
+import { Op } from "sequelize";
+import { Sequelize } from "sequelize-typescript";
+import { customFields } from "@autofleet/common-types";
+
+//#region src/scopes/filter.ts
+/**
+* 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.
+*/
+const customFieldsFilterScope = (name, options) => ({ replacementsMap: replacements, scopeValue: conditions }) => {
+	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]));
+	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
+	};
+};
+const scopeName = customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+const customFieldsSortScope = (name, options) => ({ 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
+	};
+};
+
+//#endregion
+export { customFieldsFilterScope, customFieldsSortScope };

package/dist/scopes/helpers/filter.helpers.cjs

@@ -0,0 +1,152 @@
+
+//#region src/scopes/helpers/filter.helpers.ts
+let SubQueryType = /* @__PURE__ */ function(SubQueryType$1) {
+	SubQueryType$1["VALUES"] = "values";
+	SubQueryType$1["ENTRIES"] = "entries";
+	return SubQueryType$1;
+}({});
+const isConditionStringArray = (input) => Array.isArray(input) && typeof input[0] === "string";
+const isBooleanString = (input) => ["true", "false"].includes(input.toString());
+const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value) => castValueToJsonb(value, "text");
+const castValueToJsonbBoolean = (value) => castValueToJsonb(value, "boolean");
+const castValueToJsonbNumeric = (value) => castValueToJsonb(value, "numeric");
+const castIfNeeded = (columnName, conditionValue) => {
+	if (isDate(conditionValue)) return castValueToJsonb(columnName, "timestamp");
+	return columnName;
+};
+const AND_DELIMITER = " AND ";
+const OR_DELIMITER = " OR ";
+const CD_TABLE_ALIAS = "cd";
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = "cv";
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
+const CE_TABLE_ALIAS = "ce";
+const getSingleConditionWithOperator = (value, operator, replacementKey, reverseReplacementsMap) => {
+	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) => {
+	let formattedValue = value;
+	if (isBooleanString(value)) formattedValue = value === "true";
+	else if (!Number.isNaN(Number(value))) formattedValue = Number(value);
+	return formattedValue;
+};
+const getJSONSubQuery = (value, key) => {
+	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}'
+    )
+  `;
+};
+const getFilterCustomFieldsSubQuery = (queryType, modelType, conditionsStrings) => {
+	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");
+	}
+};
+const getSortCustomFieldsSubQuery = (queryType, modelType, replacementKey) => {
+	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");
+	}
+};
+const formatConditionsForValues = (key, condition, reverseReplacementsMap) => {
+	const replacementKey = reverseReplacementsMap.get(key);
+	if (!replacementKey) return false;
+	const columnCondition = `(${CD_NAME_COLUMN} = :${replacementKey})`;
+	if (Array.isArray(condition)) {
+		if (condition.length === 0) return false;
+		if (isConditionStringArray(condition)) return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${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 condition.map((c) => {
+			const valueAsJsonb = castValueToJsonbText(`:${reverseReplacementsMap.get(c.value)}`);
+			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 valueAsJsonb = castValueToJsonbText(`:${reverseReplacementsMap.get(condition.value)}`);
+		return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
+	}
+	return false;
+};
+const formatConditionsForEntries = (key, condition, reverseReplacementsMap) => {
+	const replacementKey = reverseReplacementsMap.get(key);
+	if (!replacementKey) return false;
+	if (Array.isArray(condition)) {
+		if (condition.length === 0) return false;
+		if (isConditionStringArray(condition)) return `( ${condition.map((value) => getJSONSubQuery(value, key)).join(`${OR_DELIMITER}\n`)})`;
+		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;
+};
+
+//#endregion
+exports.SubQueryType = SubQueryType;
+exports.formatConditionsForEntries = formatConditionsForEntries;
+exports.formatConditionsForValues = formatConditionsForValues;
+exports.getFilterCustomFieldsSubQuery = getFilterCustomFieldsSubQuery;
+exports.getSortCustomFieldsSubQuery = getSortCustomFieldsSubQuery;

package/dist/scopes/helpers/filter.helpers.d.cts

@@ -0,0 +1,16 @@
+import { WhereOptions } from "sequelize";
+
+//#region src/scopes/helpers/filter.helpers.d.ts
+
+/**
+* Type representing possible condition values.
+* Currently supporting strings and arrays of strings.
+* More types to be added (TBA).
+*/
+interface ConditionWithOperator {
+  operator: string;
+  value: string;
+}
+type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+//#endregion
+export { ConditionValue };

package/dist/scopes/helpers/filter.helpers.d.ts

@@ -0,0 +1,16 @@
+import { WhereOptions } from "sequelize";
+
+//#region src/scopes/helpers/filter.helpers.d.ts
+
+/**
+* Type representing possible condition values.
+* Currently supporting strings and arrays of strings.
+* More types to be added (TBA).
+*/
+interface ConditionWithOperator {
+  operator: string;
+  value: string;
+}
+type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+//#endregion
+export { ConditionValue };

package/dist/scopes/helpers/filter.helpers.js

@@ -0,0 +1,147 @@
+//#region src/scopes/helpers/filter.helpers.ts
+let SubQueryType = /* @__PURE__ */ function(SubQueryType$1) {
+	SubQueryType$1["VALUES"] = "values";
+	SubQueryType$1["ENTRIES"] = "entries";
+	return SubQueryType$1;
+}({});
+const isConditionStringArray = (input) => Array.isArray(input) && typeof input[0] === "string";
+const isBooleanString = (input) => ["true", "false"].includes(input.toString());
+const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value) => castValueToJsonb(value, "text");
+const castValueToJsonbBoolean = (value) => castValueToJsonb(value, "boolean");
+const castValueToJsonbNumeric = (value) => castValueToJsonb(value, "numeric");
+const castIfNeeded = (columnName, conditionValue) => {
+	if (isDate(conditionValue)) return castValueToJsonb(columnName, "timestamp");
+	return columnName;
+};
+const AND_DELIMITER = " AND ";
+const OR_DELIMITER = " OR ";
+const CD_TABLE_ALIAS = "cd";
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = "cv";
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
+const CE_TABLE_ALIAS = "ce";
+const getSingleConditionWithOperator = (value, operator, replacementKey, reverseReplacementsMap) => {
+	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) => {
+	let formattedValue = value;
+	if (isBooleanString(value)) formattedValue = value === "true";
+	else if (!Number.isNaN(Number(value))) formattedValue = Number(value);
+	return formattedValue;
+};
+const getJSONSubQuery = (value, key) => {
+	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}'
+    )
+  `;
+};
+const getFilterCustomFieldsSubQuery = (queryType, modelType, conditionsStrings) => {
+	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");
+	}
+};
+const getSortCustomFieldsSubQuery = (queryType, modelType, replacementKey) => {
+	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");
+	}
+};
+const formatConditionsForValues = (key, condition, reverseReplacementsMap) => {
+	const replacementKey = reverseReplacementsMap.get(key);
+	if (!replacementKey) return false;
+	const columnCondition = `(${CD_NAME_COLUMN} = :${replacementKey})`;
+	if (Array.isArray(condition)) {
+		if (condition.length === 0) return false;
+		if (isConditionStringArray(condition)) return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${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 condition.map((c) => {
+			const valueAsJsonb = castValueToJsonbText(`:${reverseReplacementsMap.get(c.value)}`);
+			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 valueAsJsonb = castValueToJsonbText(`:${reverseReplacementsMap.get(condition.value)}`);
+		return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
+	}
+	return false;
+};
+const formatConditionsForEntries = (key, condition, reverseReplacementsMap) => {
+	const replacementKey = reverseReplacementsMap.get(key);
+	if (!replacementKey) return false;
+	if (Array.isArray(condition)) {
+		if (condition.length === 0) return false;
+		if (isConditionStringArray(condition)) return `( ${condition.map((value) => getJSONSubQuery(value, key)).join(`${OR_DELIMITER}\n`)})`;
+		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;
+};
+
+//#endregion
+export { SubQueryType, formatConditionsForEntries, formatConditionsForValues, getFilterCustomFieldsSubQuery, getSortCustomFieldsSubQuery };

package/dist/scopes/index.cjs

@@ -0,0 +1 @@
+const require_filter = require('./filter.cjs');

package/dist/scopes/index.js

@@ -0,0 +1,3 @@
+import { customFieldsFilterScope } from "./filter.js";
+
+export {  };

package/dist/types/index.d.cts

@@ -0,0 +1,75 @@
+import { CustomFieldDefinition } from "../models/CustomFieldDefinition.cjs";
+import { ModelCtor, Sequelize } from "sequelize-typescript";
+import { IncludeOptions } from "sequelize";
+
+//#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[];
+}
+interface Models {
+  name: string;
+  scopeAttributes: any[];
+  modelOptions?: ModelOptions;
+  hasTypeId?: boolean;
+  /**
+  * Optional async callback to determine which custom fields are required for an instance.
+  * Allows consumer applications to override CustomFieldDefinition.required based on custom logic.
+  * @param instance - The model instance being created/updated
+  * @param fieldDefinitions - Array of CustomFieldDefinition records
+  * @param options - Sequelize options including transaction
+  * @returns Array of field names that should be validated as required
+  */
+  getRequiredCustomFields?: (instance: any, fieldDefinitions: CustomFieldDefinition[], options: any) => Promise<string[]> | string[];
+  creationWebhookHandler?: (instance: any) => any;
+  updateWebhookHandler?: (instance: any) => any;
+  deletionWebhookHandler?: (instance: any) => any;
+}
+interface CustomFieldOptions {
+  models: Models[];
+  hasTypeId?: boolean;
+  databaseConfig: any;
+  getUser: typeof GetUserType;
+  sequelize?: Sequelize;
+  useCustomFieldsEntries?: boolean;
+  useValidators?: boolean;
+  useModelTypeMapping?: boolean;
+  /**
+  * When true, use the legacy `sync({ alter: true })` migration approach
+  * instead of umzug-managed migrations via the `sadot_migrations` table.
+  * Defaults to false (umzug is used by default).
+  */
+  runLegacyMigrations?: boolean;
+  getRequiredCustomFields?: (instance: any, fieldDefinitions: CustomFieldDefinition[], options: any) => Promise<string[]> | string[];
+  /**
+  * Optional predicate that returns true when materialized-path RLS is active for the current
+  * request. When it returns true, sadot's `userScope` on CFD/CV becomes a no-op so RLS is the
+  * sole filter (consumer typically decorates CFD/CV with their mat-path manager so RLS applies).
+  * Pass `matPathManager.isScopingRequest` if using `@autofleet/mat-path-mvp`.
+  */
+  isMatPathEnabled?: () => boolean;
+  /**
+  * Optional hook for the effective field-policy route. When provided, sadot mounts
+  * GET /field-policies/:entityType/effective and delegates scoped queries through this callback.
+  * Typically: (table, cb) => { matPathManager.setScopingMode({ [table]: SCOPING_MODE.ANCESTORS }); return matPathManager.withPaths(cb); }
+  */
+  withMatPath?: (tableName: string, callback: (transaction: any) => Promise<any>) => Promise<any>;
+}
+//#endregion
+export { CustomFieldOptions, ModelFetcher, Models };

package/dist/types/index.d.ts

@@ -0,0 +1,76 @@
+import { CustomFieldDefinition } from "../models/CustomFieldDefinition.js";
+import "../models/CustomValidator.js";
+import { IncludeOptions } from "sequelize";
+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[];
+}
+interface Models {
+  name: string;
+  scopeAttributes: any[];
+  modelOptions?: ModelOptions;
+  hasTypeId?: boolean;
+  /**
+  * Optional async callback to determine which custom fields are required for an instance.
+  * Allows consumer applications to override CustomFieldDefinition.required based on custom logic.
+  * @param instance - The model instance being created/updated
+  * @param fieldDefinitions - Array of CustomFieldDefinition records
+  * @param options - Sequelize options including transaction
+  * @returns Array of field names that should be validated as required
+  */
+  getRequiredCustomFields?: (instance: any, fieldDefinitions: CustomFieldDefinition[], options: any) => Promise<string[]> | string[];
+  creationWebhookHandler?: (instance: any) => any;
+  updateWebhookHandler?: (instance: any) => any;
+  deletionWebhookHandler?: (instance: any) => any;
+}
+interface CustomFieldOptions {
+  models: Models[];
+  hasTypeId?: boolean;
+  databaseConfig: any;
+  getUser: typeof GetUserType;
+  sequelize?: Sequelize;
+  useCustomFieldsEntries?: boolean;
+  useValidators?: boolean;
+  useModelTypeMapping?: boolean;
+  /**
+  * When true, use the legacy `sync({ alter: true })` migration approach
+  * instead of umzug-managed migrations via the `sadot_migrations` table.
+  * Defaults to false (umzug is used by default).
+  */
+  runLegacyMigrations?: boolean;
+  getRequiredCustomFields?: (instance: any, fieldDefinitions: CustomFieldDefinition[], options: any) => Promise<string[]> | string[];
+  /**
+  * Optional predicate that returns true when materialized-path RLS is active for the current
+  * request. When it returns true, sadot's `userScope` on CFD/CV becomes a no-op so RLS is the
+  * sole filter (consumer typically decorates CFD/CV with their mat-path manager so RLS applies).
+  * Pass `matPathManager.isScopingRequest` if using `@autofleet/mat-path-mvp`.
+  */
+  isMatPathEnabled?: () => boolean;
+  /**
+  * Optional hook for the effective field-policy route. When provided, sadot mounts
+  * GET /field-policies/:entityType/effective and delegates scoped queries through this callback.
+  * Typically: (table, cb) => { matPathManager.setScopingMode({ [table]: SCOPING_MODE.ANCESTORS }); return matPathManager.withPaths(cb); }
+  */
+  withMatPath?: (tableName: string, callback: (transaction: any) => Promise<any>) => Promise<any>;
+}
+//#endregion
+export { CustomFieldOptions, ModelFetcher, Models };

package/dist/utils/constants/index.cjs

@@ -0,0 +1,32 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let _autofleet_common_types = require("@autofleet/common-types");
+
+//#region src/utils/constants/index.ts
+const supportedEntities = [
+	"businessModelId",
+	"fleetId",
+	"demandSourceId"
+];
+/**
+* Supported custom field types
+*/
+let CustomFieldDefinitionType = /* @__PURE__ */ function(CustomFieldDefinitionType$1) {
+	CustomFieldDefinitionType$1["NUMBER"] = "number";
+	CustomFieldDefinitionType$1["BOOLEAN"] = "boolean";
+	CustomFieldDefinitionType$1["DATE"] = "date";
+	CustomFieldDefinitionType$1["DATETIME"] = "datetime";
+	CustomFieldDefinitionType$1["TEXT"] = "text";
+	CustomFieldDefinitionType$1["IMAGE"] = "image";
+	CustomFieldDefinitionType$1["SELECT"] = "select";
+	CustomFieldDefinitionType$1["STATUS"] = "status";
+	CustomFieldDefinitionType$1["FILE"] = "file";
+	CustomFieldDefinitionType$1["MULTI_SELECT_STATUS"] = "multi-select-status";
+	CustomFieldDefinitionType$1["MULTI_SELECT_DROPDOWN"] = "multi-select-dropdown";
+	return CustomFieldDefinitionType$1;
+}({});
+const CUSTOM_FIELDS_FILTER_SCOPE = _autofleet_common_types.customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+
+//#endregion
+exports.CUSTOM_FIELDS_FILTER_SCOPE = CUSTOM_FIELDS_FILTER_SCOPE;
+exports.CustomFieldDefinitionType = CustomFieldDefinitionType;
+exports.supportedEntities = supportedEntities;

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

@@ -0,0 +1,23 @@
+import { customFields } from "@autofleet/common-types";
+
+//#region src/utils/constants/index.d.ts
+declare const supportedEntities: readonly ["businessModelId", "fleetId", "demandSourceId"];
+/**
+* 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",
+  MULTI_SELECT_STATUS = "multi-select-status",
+  MULTI_SELECT_DROPDOWN = "multi-select-dropdown",
+}
+declare const CUSTOM_FIELDS_FILTER_SCOPE: typeof customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities };