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

package/dist/errors/index.js

@@ -0,0 +1,55 @@
+import { BadRequest } from "@autofleet/errors";
+
+//#region src/errors/index.ts
+var MissingRequiredCustomFieldError = class extends BadRequest {
+	constructor(missingFields) {
+		const err = /* @__PURE__ */ new Error(`The following custom fields are required: ${missingFields.join(",")}`);
+		super([err], void 0, missingFields);
+		this.message = "MISSING_REQUIRED_CUSTOM_FIELDS";
+	}
+};
+var UnsupportedCustomFieldTypeError = class extends BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Type "${fieldType}" is not supported`);
+		super([err], void 0, null);
+		this.message = "UNSUPPORTED_CUSTOM_FIELD_TYPE";
+	}
+};
+var UnsupportedCustomValidationError = class extends BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Validation for "${fieldType}" is not supported`);
+		super([err], void 0, null);
+		this.message = "UNSUPPORTED_CUSTOM_VALIDATION_TYPE";
+	}
+};
+var InvalidFieldTypeError = class extends BadRequest {
+	constructor(fieldType) {
+		const err = /* @__PURE__ */ new Error(`Invalid field type ${fieldType}`);
+		super([err], void 0, null);
+		this.message = "INVALID_FIELD_TYPE";
+	}
+};
+var InvalidValueError = class extends BadRequest {
+	constructor(value, fieldDefinitionName, joiValidationError) {
+		const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${joiValidationError.message.replace(/"/g, "").replace("value", `'${fieldDefinitionName}'`)}. received: '${typeof value === "object" ? JSON.stringify(value) : value}'`;
+		super([new Error(invalidValueMessage)], void 0, null);
+		this.message = invalidValueMessage;
+	}
+};
+var InvalidEntriesError = class extends BadRequest {
+	constructor(modelId, validationErrors) {
+		const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+		super(errors, void 0, null);
+		this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`).join("\n")}`;
+	}
+};
+var MissingDefinitionError = class extends BadRequest {
+	constructor(fieldNames) {
+		const err = /* @__PURE__ */ new Error(`Missing custom field definition for field ${fieldNames.join(",")}`);
+		super([err], void 0, null);
+		this.message = "MISSING_DEFINITION";
+	}
+};
+
+//#endregion
+export { InvalidEntriesError, InvalidFieldTypeError, InvalidValueError, MissingDefinitionError, MissingRequiredCustomFieldError, UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError };

package/dist/events/index.cjs

@@ -0,0 +1,52 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/logger/index.cjs');
+let _autofleet_zehut = require("@autofleet/zehut");
+let _autofleet_events = require("@autofleet/events");
+_autofleet_events = require_rolldown_runtime.__toESM(_autofleet_events);
+
+//#region src/events/index.ts
+const events = new _autofleet_events.default({
+	logger: require_index.default,
+	getUserId: (payload) => payload?.user_id ?? (0, _autofleet_zehut.getUser)()?.id ?? null
+});
+const KEYS_TO_CONVERT = [
+	"value",
+	"defaultValue",
+	"blockEditingFromUI"
+];
+const stringifyBooleans = (savedObject, keysToConvert) => {
+	const savedObjectKeySet = new Set(Object.keys(savedObject));
+	if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) return savedObject;
+	return {
+		...savedObject,
+		...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === "boolean" ? savedObject[key].toString() : savedObject[key]]))
+	};
+};
+const modelTableMapping = {
+	CustomFieldDefinition: {
+		tableName: "dim_custom_field_definition",
+		eventVersion: "1"
+	},
+	CustomFieldValue: {
+		tableName: "dim_custom_field_value",
+		eventVersion: "1"
+	},
+	CustomFieldEntries: {
+		tableName: "dim_custom_field_entries",
+		eventVersion: "1"
+	}
+};
+const sendDimEvent = (instance) => {
+	const mapping = modelTableMapping[instance.constructor.name];
+	if (!mapping) return;
+	let objectToSend = instance.get();
+	try {
+		objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
+	} catch (err) {
+		require_index.default.error("Failed to convert booleans in dim event payload", err);
+	}
+	events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend).catch(() => null);
+};
+
+//#endregion
+exports.sendDimEvent = sendDimEvent;

package/dist/events/index.js

@@ -0,0 +1,50 @@
+import logger_default from "../utils/logger/index.js";
+import { getUser } from "@autofleet/zehut";
+import Events from "@autofleet/events";
+
+//#region src/events/index.ts
+const events = new Events({
+	logger: logger_default,
+	getUserId: (payload) => payload?.user_id ?? getUser()?.id ?? null
+});
+const KEYS_TO_CONVERT = [
+	"value",
+	"defaultValue",
+	"blockEditingFromUI"
+];
+const stringifyBooleans = (savedObject, keysToConvert) => {
+	const savedObjectKeySet = new Set(Object.keys(savedObject));
+	if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) return savedObject;
+	return {
+		...savedObject,
+		...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === "boolean" ? savedObject[key].toString() : savedObject[key]]))
+	};
+};
+const modelTableMapping = {
+	CustomFieldDefinition: {
+		tableName: "dim_custom_field_definition",
+		eventVersion: "1"
+	},
+	CustomFieldValue: {
+		tableName: "dim_custom_field_value",
+		eventVersion: "1"
+	},
+	CustomFieldEntries: {
+		tableName: "dim_custom_field_entries",
+		eventVersion: "1"
+	}
+};
+const sendDimEvent = (instance) => {
+	const mapping = modelTableMapping[instance.constructor.name];
+	if (!mapping) return;
+	let objectToSend = instance.get();
+	try {
+		objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
+	} catch (err) {
+		logger_default.error("Failed to convert booleans in dim event payload", err);
+	}
+	events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend).catch(() => null);
+};
+
+//#endregion
+export { sendDimEvent };

package/dist/hooks/enrich.cjs

@@ -0,0 +1,175 @@
+const require_definition = require('../repository/definition.cjs');
+const require_value = require('../repository/value.cjs');
+const require_entries = require('../repository/entries.cjs');
+const require_scopeAttributes = require('../utils/scopeAttributes.cjs');
+
+//#region src/hooks/enrich.ts
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = [
+	"id",
+	"name",
+	"entityId",
+	"fieldType",
+	"displayName",
+	"validation",
+	"entityType",
+	"modelType",
+	"required",
+	"disabled",
+	"defaultValue"
+];
+const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions }) => {
+	if (!sadotOptions.useCustomFieldsEntries) return {};
+	const customFieldEntries = await require_entries.findEntriesByModelIds(instancesIds, options ?? {});
+	const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+		const { modelId, customFields } = instanceEntries?.dataValues ?? {};
+		if (!modelId) return;
+		return [modelId, customFields];
+	}).filter((v) => v !== void 0));
+	instancesIds.forEach((instanceId) => {
+		customFieldEntriesByInstanceId[instanceId] ??= {};
+	});
+	return customFieldEntriesByInstanceId;
+};
+const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions }) => {
+	if (sadotOptions.useCustomFieldsEntries) return {};
+	return (await require_value.findValuesByModelIds(instancesIds, options ?? {})).reduce((acc, v) => {
+		const { modelId } = v;
+		acc[modelId] ??= [];
+		acc[modelId].push(v);
+		return acc;
+	}, {});
+};
+/**
+* Serialize custom fields value into the format of {[name] -> [fieldData]}
+*/
+const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) => {
+	return customFieldValues.reduce((acc, cfv) => ({
+		...acc,
+		...customFieldDefinitionsHash[cfv.customFieldDefinitionId] && { [customFieldDefinitionsHash[cfv.customFieldDefinitionId].name]: cfv.value }
+	}), {});
+};
+/**
+* A hook to attach the custom fields when fetching a model instances.
+*/
+const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = {
+	useCustomFieldsEntries: false,
+	hasTypeId: false
+}) => async (instancesOrInstance, options) => {
+	if (options.originalAttributes?.length > 0 && !options.originalAttributes?.includes?.("customFields")) return;
+	const primaryKey = "id";
+	let instances = Array.isArray(instancesOrInstance) ? instancesOrInstance : [instancesOrInstance];
+	instances = instances.filter(Boolean);
+	const identifiers = require_scopeAttributes.default(instances, scopeAttributes);
+	const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+	const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
+		...map,
+		[identifier]: []
+	}), {});
+	let customFieldDefinitionsPromise;
+	let cacheKey;
+	if (options.transaction) {
+		options.transaction.definitionCache ??= /* @__PURE__ */ new Map();
+		cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(",")}`;
+		customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+	}
+	let modelTypeDefinitionsMap;
+	if (!customFieldDefinitionsPromise) {
+		const shouldApplyTypeFiltering = sadotOptions.hasTypeId && instances.length > 0 && instances[0].typeId;
+		const fetchDefinitions = async (transaction = options.transaction) => {
+			if (shouldApplyTypeFiltering) {
+				const uniqueTypeIds = [...new Set(instances.map((instance) => instance.typeId).filter(Boolean))];
+				modelTypeDefinitionsMap = /* @__PURE__ */ new Map();
+				uniqueTypeIds.forEach((typeId) => modelTypeDefinitionsMap.set(typeId, /* @__PURE__ */ new Set()));
+				const allDefinitions = (await Promise.all(uniqueTypeIds.map(async (typeId) => {
+					const defs = await require_definition.findByModelTypeId(typeId, {
+						withDisabled: false,
+						entityIds: uniqueIdentifiers,
+						modelType,
+						modelOptions,
+						transaction
+					});
+					defs.forEach((def) => modelTypeDefinitionsMap.get(typeId).add(def.id));
+					return defs;
+				}))).flat();
+				const uniqueDefinitionsMap = /* @__PURE__ */ new Map();
+				allDefinitions.forEach((def) => {
+					uniqueDefinitionsMap.set(def.id, def);
+				});
+				return Array.from(uniqueDefinitionsMap.values());
+			}
+			return require_definition.findByEntityIds(modelType, uniqueIdentifiers, {
+				transaction,
+				modelOptions,
+				attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL
+			});
+		};
+		customFieldDefinitionsPromise = fetchDefinitions();
+		if (!shouldApplyTypeFiltering) options.transaction?.definitionCache?.set(cacheKey, customFieldDefinitionsPromise);
+	}
+	const customFieldDefinitions = await customFieldDefinitionsPromise;
+	if (customFieldDefinitions.length === 0) {
+		instances.forEach((instance) => {
+			instance.customFields = {};
+		});
+		return;
+	}
+	if (modelOptions?.include && modelOptions.useEntityIdFromInclude) modelOptions.include(identifiers).forEach(({ model }) => {
+		customFieldDefinitions.forEach((cfd) => {
+			const entityId = cfd[model.name]?.entityId || cfd[`${model.name}.entityId`];
+			if (entityId && !identifierCustomFieldDefinitionsMapping[entityId]) identifierCustomFieldDefinitionsMapping[entityId] = [];
+		});
+	});
+	const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
+		...map,
+		[definition.id]: definition
+	}), {});
+	customFieldDefinitions.forEach((cfd) => {
+		let entityIdToUse = cfd.entityId;
+		if (modelOptions?.useEntityIdFromInclude && modelOptions.include) {
+			const contextIncludes = modelOptions.include(identifiers);
+			for (const { model } of contextIncludes) {
+				const joinedEntityId = cfd[model.name]?.entityId || cfd[`${model.name}.entityId`];
+				if (joinedEntityId) {
+					entityIdToUse = joinedEntityId;
+					break;
+				}
+			}
+		}
+		if (identifierCustomFieldDefinitionsMapping[entityIdToUse]) identifierCustomFieldDefinitionsMapping[entityIdToUse].push(cfd);
+	});
+	const instancesIds = instances.map((i) => i[primaryKey]);
+	const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([getValuesGroupByInstance({
+		instancesIds,
+		options,
+		sadotOptions
+	}), getCustomFieldEntriesByInstanceId({
+		instancesIds,
+		options,
+		sadotOptions
+	})]);
+	instances.forEach((instance) => {
+		const { id } = instance;
+		const instanceValues = valuesGroupByInstance[id];
+		const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+		const customFields = sadotOptions.useCustomFieldsEntries ? customFieldEntriesByInstanceId[id] : serializedCustomFieldsValues;
+		scopeAttributes.forEach((attribute) => {
+			const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[instance[attribute]];
+			if (entityCustomFieldDefinitions && entityCustomFieldDefinitions.length > 0) entityCustomFieldDefinitions.forEach((customFieldDefinition) => {
+				if (modelTypeDefinitionsMap) {
+					if (!modelTypeDefinitionsMap.get(instance.typeId)?.has(customFieldDefinition.id)) return;
+				}
+				if (customFields[customFieldDefinition.name] === void 0) customFields[customFieldDefinition.name] = null;
+			});
+		});
+		instance.customFields = customFields;
+		options.attributesToRemove?.forEach?.((attribute) => {
+			delete instance.dataValues?.[attribute];
+			delete instance?.[attribute];
+		});
+		if (hookType === "afterFind") instance?.changed?.("customFields", false);
+	});
+};
+var enrich_default = enrichResults;
+
+//#endregion
+exports.default = enrich_default;

package/dist/hooks/enrich.js

@@ -0,0 +1,175 @@
+import { findByEntityIds, findByModelTypeId } from "../repository/definition.js";
+import { findValuesByModelIds } from "../repository/value.js";
+import { findEntriesByModelIds } from "../repository/entries.js";
+import scopeAttributes_default from "../utils/scopeAttributes.js";
+
+//#region src/hooks/enrich.ts
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = [
+	"id",
+	"name",
+	"entityId",
+	"fieldType",
+	"displayName",
+	"validation",
+	"entityType",
+	"modelType",
+	"required",
+	"disabled",
+	"defaultValue"
+];
+const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions }) => {
+	if (!sadotOptions.useCustomFieldsEntries) return {};
+	const customFieldEntries = await findEntriesByModelIds(instancesIds, options ?? {});
+	const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+		const { modelId, customFields } = instanceEntries?.dataValues ?? {};
+		if (!modelId) return;
+		return [modelId, customFields];
+	}).filter((v) => v !== void 0));
+	instancesIds.forEach((instanceId) => {
+		customFieldEntriesByInstanceId[instanceId] ??= {};
+	});
+	return customFieldEntriesByInstanceId;
+};
+const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions }) => {
+	if (sadotOptions.useCustomFieldsEntries) return {};
+	return (await findValuesByModelIds(instancesIds, options ?? {})).reduce((acc, v) => {
+		const { modelId } = v;
+		acc[modelId] ??= [];
+		acc[modelId].push(v);
+		return acc;
+	}, {});
+};
+/**
+* Serialize custom fields value into the format of {[name] -> [fieldData]}
+*/
+const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) => {
+	return customFieldValues.reduce((acc, cfv) => ({
+		...acc,
+		...customFieldDefinitionsHash[cfv.customFieldDefinitionId] && { [customFieldDefinitionsHash[cfv.customFieldDefinitionId].name]: cfv.value }
+	}), {});
+};
+/**
+* A hook to attach the custom fields when fetching a model instances.
+*/
+const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = {
+	useCustomFieldsEntries: false,
+	hasTypeId: false
+}) => async (instancesOrInstance, options) => {
+	if (options.originalAttributes?.length > 0 && !options.originalAttributes?.includes?.("customFields")) return;
+	const primaryKey = "id";
+	let instances = Array.isArray(instancesOrInstance) ? instancesOrInstance : [instancesOrInstance];
+	instances = instances.filter(Boolean);
+	const identifiers = scopeAttributes_default(instances, scopeAttributes);
+	const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+	const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
+		...map,
+		[identifier]: []
+	}), {});
+	let customFieldDefinitionsPromise;
+	let cacheKey;
+	if (options.transaction) {
+		options.transaction.definitionCache ??= /* @__PURE__ */ new Map();
+		cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(",")}`;
+		customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+	}
+	let modelTypeDefinitionsMap;
+	if (!customFieldDefinitionsPromise) {
+		const shouldApplyTypeFiltering = sadotOptions.hasTypeId && instances.length > 0 && instances[0].typeId;
+		const fetchDefinitions = async (transaction = options.transaction) => {
+			if (shouldApplyTypeFiltering) {
+				const uniqueTypeIds = [...new Set(instances.map((instance) => instance.typeId).filter(Boolean))];
+				modelTypeDefinitionsMap = /* @__PURE__ */ new Map();
+				uniqueTypeIds.forEach((typeId) => modelTypeDefinitionsMap.set(typeId, /* @__PURE__ */ new Set()));
+				const allDefinitions = (await Promise.all(uniqueTypeIds.map(async (typeId) => {
+					const defs = await findByModelTypeId(typeId, {
+						withDisabled: false,
+						entityIds: uniqueIdentifiers,
+						modelType,
+						modelOptions,
+						transaction
+					});
+					defs.forEach((def) => modelTypeDefinitionsMap.get(typeId).add(def.id));
+					return defs;
+				}))).flat();
+				const uniqueDefinitionsMap = /* @__PURE__ */ new Map();
+				allDefinitions.forEach((def) => {
+					uniqueDefinitionsMap.set(def.id, def);
+				});
+				return Array.from(uniqueDefinitionsMap.values());
+			}
+			return findByEntityIds(modelType, uniqueIdentifiers, {
+				transaction,
+				modelOptions,
+				attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL
+			});
+		};
+		customFieldDefinitionsPromise = fetchDefinitions();
+		if (!shouldApplyTypeFiltering) options.transaction?.definitionCache?.set(cacheKey, customFieldDefinitionsPromise);
+	}
+	const customFieldDefinitions = await customFieldDefinitionsPromise;
+	if (customFieldDefinitions.length === 0) {
+		instances.forEach((instance) => {
+			instance.customFields = {};
+		});
+		return;
+	}
+	if (modelOptions?.include && modelOptions.useEntityIdFromInclude) modelOptions.include(identifiers).forEach(({ model }) => {
+		customFieldDefinitions.forEach((cfd) => {
+			const entityId = cfd[model.name]?.entityId || cfd[`${model.name}.entityId`];
+			if (entityId && !identifierCustomFieldDefinitionsMapping[entityId]) identifierCustomFieldDefinitionsMapping[entityId] = [];
+		});
+	});
+	const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
+		...map,
+		[definition.id]: definition
+	}), {});
+	customFieldDefinitions.forEach((cfd) => {
+		let entityIdToUse = cfd.entityId;
+		if (modelOptions?.useEntityIdFromInclude && modelOptions.include) {
+			const contextIncludes = modelOptions.include(identifiers);
+			for (const { model } of contextIncludes) {
+				const joinedEntityId = cfd[model.name]?.entityId || cfd[`${model.name}.entityId`];
+				if (joinedEntityId) {
+					entityIdToUse = joinedEntityId;
+					break;
+				}
+			}
+		}
+		if (identifierCustomFieldDefinitionsMapping[entityIdToUse]) identifierCustomFieldDefinitionsMapping[entityIdToUse].push(cfd);
+	});
+	const instancesIds = instances.map((i) => i[primaryKey]);
+	const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([getValuesGroupByInstance({
+		instancesIds,
+		options,
+		sadotOptions
+	}), getCustomFieldEntriesByInstanceId({
+		instancesIds,
+		options,
+		sadotOptions
+	})]);
+	instances.forEach((instance) => {
+		const { id } = instance;
+		const instanceValues = valuesGroupByInstance[id];
+		const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+		const customFields = sadotOptions.useCustomFieldsEntries ? customFieldEntriesByInstanceId[id] : serializedCustomFieldsValues;
+		scopeAttributes.forEach((attribute) => {
+			const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[instance[attribute]];
+			if (entityCustomFieldDefinitions && entityCustomFieldDefinitions.length > 0) entityCustomFieldDefinitions.forEach((customFieldDefinition) => {
+				if (modelTypeDefinitionsMap) {
+					if (!modelTypeDefinitionsMap.get(instance.typeId)?.has(customFieldDefinition.id)) return;
+				}
+				if (customFields[customFieldDefinition.name] === void 0) customFields[customFieldDefinition.name] = null;
+			});
+		});
+		instance.customFields = customFields;
+		options.attributesToRemove?.forEach?.((attribute) => {
+			delete instance.dataValues?.[attribute];
+			delete instance?.[attribute];
+		});
+		if (hookType === "afterFind") instance?.changed?.("customFields", false);
+	});
+};
+var enrich_default = enrichResults;
+
+//#endregion
+export { enrich_default as default };

package/dist/hooks/find.cjs

@@ -0,0 +1,22 @@
+const require_index = require('../utils/logger/index.cjs');
+
+//#region src/hooks/find.ts
+const doScopeAttributesMissing = (scopeAttributes, queryAttributes) => {
+	const attributes = scopeAttributes.filter((attribute) => !queryAttributes.includes(attribute));
+	if (!queryAttributes.includes?.("id")) attributes.push("id");
+	return attributes;
+};
+const beforeFind = (scopeAttributes) => (options) => {
+	const { attributes: queryAttributes } = options;
+	if (queryAttributes?.includes?.("customFields")) {
+		const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
+		require_index.default.debug("sadot - before find hook");
+		if (missingScopeAttributes?.length > 0) {
+			queryAttributes.push(...missingScopeAttributes);
+			options.attributesToRemove = missingScopeAttributes;
+		}
+	}
+};
+
+//#endregion
+exports.beforeFind = beforeFind;

package/dist/hooks/find.js

@@ -0,0 +1,22 @@
+import logger_default from "../utils/logger/index.js";
+
+//#region src/hooks/find.ts
+const doScopeAttributesMissing = (scopeAttributes, queryAttributes) => {
+	const attributes = scopeAttributes.filter((attribute) => !queryAttributes.includes(attribute));
+	if (!queryAttributes.includes?.("id")) attributes.push("id");
+	return attributes;
+};
+const beforeFind = (scopeAttributes) => (options) => {
+	const { attributes: queryAttributes } = options;
+	if (queryAttributes?.includes?.("customFields")) {
+		const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
+		logger_default.debug("sadot - before find hook");
+		if (missingScopeAttributes?.length > 0) {
+			queryAttributes.push(...missingScopeAttributes);
+			options.attributesToRemove = missingScopeAttributes;
+		}
+	}
+};
+
+//#endregion
+export { beforeFind };