@arcaelas/dynamite 1.0.10 → 1.0.13

package/src/decorators/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @file index.ts
+ * @descripcion Decorador @Index para Partition Key
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Index;
+const wrapper_1 = require("../core/wrapper");
+const naming_1 = require("../utils/naming");
+/**
+ * Decorador para marcar propiedad como Partition Key.
+ * Configura la propiedad como índice principal para consultas.
+ */
+function Index() {
+    return (target, prop) => {
+        const ctor = target.constructor;
+        const tableName = (0, naming_1.toSnakePlural)(ctor.name);
+        const entry = (0, wrapper_1.ensureConfig)(ctor, tableName);
+        // Verificar si ya existe un índice primario
+        const existingIndex = [...entry.columns.values()].find((col) => col.index === true);
+        if (existingIndex && existingIndex.name !== String(prop)) {
+            throw new Error(`La tabla ${tableName} ya tiene definida una PartitionKey (${existingIndex.name}). ` +
+                `No se puede definir otra PartitionKey en '${String(prop)}'`);
+        }
+        // Obtener o crear la columna y marcar como índice
+        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
+        column.index = true;
+        // Asegurar que la columna no sea nula por defecto
+        if (column.nullable === undefined) {
+            column.nullable = false;
+        }
+    };
+}
+//# sourceMappingURL=index.js.map

package/src/decorators/index_sort.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file index_sort.ts
+ * @descripcion Decorador @IndexSort para Sort Key
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+/**
+ * Decorador para marcar propiedad como Sort Key.
+ * Configura la propiedad como clave de ordenación para consultas.
+ * Requiere que exista una PartitionKey (@Index) definida previamente.
+ */
+export default function IndexSort(): PropertyDecorator;

package/src/decorators/index_sort.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @file index_sort.ts
+ * @descripcion Decorador @IndexSort para Sort Key
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = IndexSort;
+const wrapper_1 = require("../core/wrapper");
+const naming_1 = require("../utils/naming");
+/**
+ * Decorador para marcar propiedad como Sort Key.
+ * Configura la propiedad como clave de ordenación para consultas.
+ * Requiere que exista una PartitionKey (@Index) definida previamente.
+ */
+function IndexSort() {
+    return (target, prop) => {
+        const ctor = target.constructor;
+        const tableName = (0, naming_1.toSnakePlural)(ctor.name);
+        const entry = (0, wrapper_1.ensureConfig)(ctor, tableName);
+        // Verificar que exista una PartitionKey definida
+        const hasPartitionKey = [...entry.columns.values()].some((col) => col.index === true);
+        if (!hasPartitionKey) {
+            throw new Error(`No se puede definir una SortKey en '${String(prop)}' sin una PartitionKey. ` +
+                `Asegúrate de marcar una propiedad con @Index primero.`);
+        }
+        // Verificar si ya existe una SortKey
+        const existingSortKey = [...entry.columns.values()].find((col) => col.indexSort === true);
+        if (existingSortKey && existingSortKey.name !== String(prop)) {
+            throw new Error(`La tabla ${tableName} ya tiene una SortKey definida (${existingSortKey.name}). ` +
+                `No se puede definir otra SortKey en '${String(prop)}'`);
+        }
+        // Obtener o crear la columna y marcar como índice de ordenación
+        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
+        column.indexSort = true;
+        // Asegurar que la columna no sea nula por defecto
+        if (column.nullable === undefined) {
+            column.nullable = false;
+        }
+    };
+}
+//# sourceMappingURL=index_sort.js.map

package/src/decorators/mutate.d.ts

@@ -0,0 +1,2 @@
+import type { Mutate } from "../core/wrapper";
+export default function Mutate(fn: Mutate): PropertyDecorator;

package/{build/src → src}/decorators/mutate.js

@@ -1,20 +1,11 @@
 "use strict";
-/**
- * @file mutate.ts
- * @descripcion Decorador @Mutate para transformaciones
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = Mutate;
 const wrapper_1 = require("../core/wrapper");
 const naming_1 = require("../utils/naming");
-/** Decorador para aplicar transformaciones automáticas a propiedades */
 function Mutate(fn) {
-    typeof fn !== "function" &&
-        (() => {
-            throw new TypeError("@Mutate requiere función");
-        })();
+    if (typeof fn !== "function")
+        throw new TypeError("@Mutate requiere función");
     return (target, prop) => {
         const ctor = target.constructor;
         const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));

package/src/decorators/name.d.ts

@@ -0,0 +1 @@
+export default function Name(label: string): ClassDecorator & PropertyDecorator;

package/src/decorators/name.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Name;
+const wrapper_1 = require("../core/wrapper");
+const naming_1 = require("../utils/naming");
+function Name(label) {
+    if (!label || typeof label !== "string")
+        throw new TypeError("@Name requiere una cadena no vacía");
+    return (target, prop) => {
+        const ctor = prop === undefined ? target : target.constructor;
+        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
+        if (prop === undefined) {
+            const auto = (0, naming_1.toSnakePlural)(ctor.name);
+            if (entry.name !== auto && entry.name !== label && entry.name) {
+                throw new Error(`La clase ${ctor.name} ya tiene un @Name distinto (${entry.name})`);
+            }
+            entry.name = label;
+        }
+        else {
+            const col = (0, wrapper_1.ensureColumn)(entry, prop, label);
+            if (col.name && col.name !== label) {
+                throw new Error(`La columna '${String(prop)}' ya tiene @Name distinto (${col.name})`);
+            }
+            col.name = label;
+        }
+    };
+}
+//# sourceMappingURL=name.js.map

package/src/decorators/not_null.d.ts

@@ -0,0 +1 @@
+export default function NotNull(): PropertyDecorator;

package/{build/src → src}/decorators/not_null.js

@@ -1,17 +1,10 @@
 "use strict";
-/**
- * @file not_null.ts
- * @descripcion Decorador @NotNull para validación no-null
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = NotNull;
 const validate_1 = __importDefault(require("./validate"));
-/** Decorador para validar que el valor no sea nulo, indefinido o string vacío */
 function NotNull() {
     return validate_1.default((value) => value !== null &&
         value !== undefined &&

package/src/decorators/primary_key.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Decorador para marcar una propiedad como clave primaria.
+ * Aplica automáticamente @Index y @IndexSort y marca el campo como primaryKey en los metadatos.
+ * @param name - Nombre opcional para el índice (no utilizado actualmente, mantenido por compatibilidad)
+ */
+export default function PrimaryKey(name?: string): PropertyDecorator;

package/src/decorators/primary_key.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = PrimaryKey;
+const wrapper_1 = require("../core/wrapper");
+const naming_1 = require("../utils/naming");
+const index_1 = __importDefault(require("./index"));
+const index_sort_1 = __importDefault(require("./index_sort"));
+/**
+ * Decorador para marcar una propiedad como clave primaria.
+ * Aplica automáticamente @Index y @IndexSort y marca el campo como primaryKey en los metadatos.
+ * @param name - Nombre opcional para el índice (no utilizado actualmente, mantenido por compatibilidad)
+ */
+function PrimaryKey(name = "primary") {
+    return (target, prop) => {
+        // Aplicar decoradores de índice
+        (0, index_1.default)()(target, prop);
+        (0, index_sort_1.default)()(target, prop);
+        // Marcar explícitamente como clave primaria en los metadatos
+        const ctor = target.constructor;
+        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
+        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
+        // Establecer metadatos adicionales para clave primaria
+        column.primaryKey = true;
+        column.nullable = false; // Las claves primarias no pueden ser nulas
+    };
+}
+//# sourceMappingURL=primary_key.js.map

package/src/decorators/updated_at.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Decorador que marca una propiedad para que se actualice automáticamente con la fecha/hora actual
+ * cada vez que se guarde el modelo.
+ *
+ * @example
+ * class User extends Table<User> {
+ *   @PrimaryKey() id: string;
+ *   name: string;
+ *   @UpdatedAt() updated_at: string;
+ * }
+ */
+export default function UpdatedAt(): (target: any, propertyKey: string | symbol) => void;

package/src/decorators/updated_at.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = UpdatedAt;
+const wrapper_1 = require("../core/wrapper");
+/**
+ * Decorador que marca una propiedad para que se actualice automáticamente con la fecha/hora actual
+ * cada vez que se guarde el modelo.
+ *
+ * @example
+ * class User extends Table<User> {
+ *   @PrimaryKey() id: string;
+ *   name: string;
+ *   @UpdatedAt() updated_at: string;
+ * }
+ */
+function UpdatedAt() {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const entry = (0, wrapper_1.ensureConfig)(ctor, ctor.name);
+        const column = (0, wrapper_1.ensureColumn)(entry, propertyKey, propertyKey);
+        // Marcamos la columna como updatedAt para que se actualice automáticamente al guardar
+        column.updatedAt = true;
+        // No establecemos un valor por defecto aquí, se establecerá en el método save()
+    };
+}
+//# sourceMappingURL=updated_at.js.map

package/src/decorators/validate.d.ts

@@ -0,0 +1 @@
+export default function Validate(validators: ((v: unknown) => true | string) | ((v: unknown) => true | string)[]): PropertyDecorator;

package/{build/src → src}/decorators/validate.js

@@ -1,15 +1,8 @@
 "use strict";
-/**
- * @file validate.ts
- * @descripcion Decorador @Validate para validaciones
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = Validate;
 const wrapper_1 = require("../core/wrapper");
 const naming_1 = require("../utils/naming");
-/** Decorador para aplicar validaciones a propiedades */
 function Validate(validators) {
     const list = Array.isArray(validators) ? validators : [validators];
     if (!list.length || list.some((v) => typeof v !== "function")) {

package/{build/src → src}/index.d.ts

@@ -1,7 +1,15 @@
+/**
+ * @file index.ts
+ * @descripcion Punto de entrada público de la librería
+ * @autor Miguel Alejandro
+ * @fecha 2025-08-07
+ */
 export { Dynamite } from "./core/client";
 export { default as Table } from "./core/table";
+export { default as BelongsTo } from "./decorators/belongs_to";
 export { default as CreatedAt } from "./decorators/created_at";
 export { default as Default } from "./decorators/default";
+export { default as HasMany } from "./decorators/has_many";
 export { default as Index } from "./decorators/index";
 export { default as IndexSort } from "./decorators/index_sort";
 export { default as Mutate } from "./decorators/mutate";
@@ -11,3 +19,4 @@ export { default as PrimaryKey } from "./decorators/primary_key";
 export { default as UpdatedAt } from "./decorators/updated_at";
 export { default as Validate } from "./decorators/validate";
 export { belongsTo, hasMany } from "./utils/relations";
+export type { BelongsTo as BelongsToType, HasMany as HasManyType, NonAttribute, CreationOptional, InferAttributes, FilterableAttributes, QueryOperator, QueryResult, WhereOptions, WhereOptionsWithoutWhere, } from "./@types/index";

package/{build/src → src}/index.js

@@ -1,20 +1,29 @@
 "use strict";
+/**
+ * @file index.ts
+ * @descripcion Punto de entrada público de la librería
+ * @autor Miguel Alejandro
+ * @fecha 2025-08-07
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasMany = exports.belongsTo = exports.Validate = exports.UpdatedAt = exports.PrimaryKey = exports.NotNull = exports.Name = exports.Mutate = exports.IndexSort = exports.Index = exports.Default = exports.CreatedAt = exports.Table = exports.Dynamite = void 0;
-// Core classes
+exports.hasMany = exports.belongsTo = exports.Validate = exports.UpdatedAt = exports.PrimaryKey = exports.NotNull = exports.Name = exports.Mutate = exports.IndexSort = exports.Index = exports.HasMany = exports.Default = exports.CreatedAt = exports.BelongsTo = exports.Table = exports.Dynamite = void 0;
+// Clases núcleo
 var client_1 = require("./core/client");
 Object.defineProperty(exports, "Dynamite", { enumerable: true, get: function () { return client_1.Dynamite; } });
 var table_1 = require("./core/table");
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return __importDefault(table_1).default; } });
-// Legacy connection removed - use Dynamite class instead
-// Decorators
+// Decoradores
+var belongs_to_1 = require("./decorators/belongs_to");
+Object.defineProperty(exports, "BelongsTo", { enumerable: true, get: function () { return __importDefault(belongs_to_1).default; } });
 var created_at_1 = require("./decorators/created_at");
 Object.defineProperty(exports, "CreatedAt", { enumerable: true, get: function () { return __importDefault(created_at_1).default; } });
 var default_1 = require("./decorators/default");
 Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return __importDefault(default_1).default; } });
+var has_many_1 = require("./decorators/has_many");
+Object.defineProperty(exports, "HasMany", { enumerable: true, get: function () { return __importDefault(has_many_1).default; } });
 var index_1 = require("./decorators/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
 var index_sort_1 = require("./decorators/index_sort");
@@ -31,7 +40,7 @@ var updated_at_1 = require("./decorators/updated_at");
 Object.defineProperty(exports, "UpdatedAt", { enumerable: true, get: function () { return __importDefault(updated_at_1).default; } });
 var validate_1 = require("./decorators/validate");
 Object.defineProperty(exports, "Validate", { enumerable: true, get: function () { return __importDefault(validate_1).default; } });
-// Relations
+// Relaciones
 var relations_1 = require("./utils/relations");
 Object.defineProperty(exports, "belongsTo", { enumerable: true, get: function () { return relations_1.belongsTo; } });
 Object.defineProperty(exports, "hasMany", { enumerable: true, get: function () { return relations_1.hasMany; } });

package/{build/src → src}/utils/batch-relations.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanupRelationCache = exports.processIncludesBatch = exports.batchLoadBelongsTo = exports.batchLoadHasMany = void 0;
+const wrapper_1 = require("../core/wrapper");
 /** Cache multi-nivel con TTL */
 const relCache = new Map();
 /** Batch loader para hasMany relations */
@@ -76,7 +77,7 @@ exports.batchLoadBelongsTo = batchLoadBelongsTo;
 const processIncludesBatch = async (Model, items, include, depth = 0) => {
     if (!include || depth > 10 || !items.length)
         return items;
-    const meta = Model.getMeta();
+    const meta = (0, wrapper_1.mustMeta)(Model);
     // Process all relations in parallel
     const relationPromises = Object.entries(include).map(async ([relationKey, relationOptions]) => {
         const relation = meta.relations.get(relationKey);

package/src/utils/circular-detector.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @file circular-detector.ts
+ * @description Detection and prevention of circular references in relations
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+interface TraversalPath {
+    modelName: string;
+    relationKey: string;
+    depth: number;
+}
+interface CircularDetectionConfig {
+    maxDepth: number;
+    maxIncludeDepth: number;
+    trackingEnabled: boolean;
+}
+declare class CircularReferenceDetector {
+    private static readonly DEFAULT_CONFIG;
+    private config;
+    private activePaths;
+    private pathHistory;
+    constructor(config?: Partial<CircularDetectionConfig>);
+    /**
+     * Verificar si una ruta de inclusión es segura
+     */
+    validateIncludePath(modelName: string, includeOptions: any, currentDepth?: number, visitedModels?: Set<string>): void;
+    /**
+     * Validar estructura de relaciones en tiempo de definición
+     */
+    validateRelationStructure(models: Map<string, any>, maxAllowedCycles?: number): ValidationResult;
+    /**
+     * Construir grafo de relaciones
+     */
+    private buildRelationGraph;
+    /**
+     * Detectar ciclos usando DFS
+     */
+    private detectCycles;
+    /**
+     * Generar sugerencias para resolver ciclos
+     */
+    private generateSuggestions;
+    /**
+     * Inferir nombre del modelo target (simplificado)
+     */
+    private inferTargetModelName;
+    /**
+     * Crear contexto de rastreo para includes anidados
+     */
+    createTrackingContext(): CircularTracker;
+    /**
+     * Obtener historial de paths para debugging
+     */
+    getPathHistory(): TraversalPath[];
+    /**
+     * Limpiar historial
+     */
+    clearHistory(): void;
+}
+/**
+ * Tracker específico para una operación de include
+ */
+declare class CircularTracker {
+    private visitedModels;
+    private currentPath;
+    private maxDepth;
+    constructor(maxDepth: number);
+    enter(modelName: string): void;
+    exit(modelName: string): void;
+    getCurrentPath(): string[];
+}
+interface ValidationResult {
+    isValid: boolean;
+    cycles: string[][];
+    suggestions: string[];
+}
+declare class CircularReferenceError extends Error {
+    constructor(message: string);
+}
+declare const circularDetector: CircularReferenceDetector;
+export { CircularReferenceDetector, CircularTracker, CircularReferenceError, ValidationResult, circularDetector };
+export default circularDetector;

package/src/utils/circular-detector.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * @file circular-detector.ts
+ * @description Detection and prevention of circular references in relations
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDetector = exports.CircularReferenceError = exports.CircularTracker = exports.CircularReferenceDetector = void 0;
+class CircularReferenceDetector {
+    static { this.DEFAULT_CONFIG = {
+        maxDepth: 10,
+        maxIncludeDepth: 5,
+        trackingEnabled: true,
+    }; }
+    constructor(config) {
+        this.activePaths = new Set();
+        this.pathHistory = [];
+        this.config = { ...CircularReferenceDetector.DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Verificar si una ruta de inclusión es segura
+     */
+    validateIncludePath(modelName, includeOptions, currentDepth = 0, visitedModels = new Set()) {
+        // Verificar profundidad máxima
+        if (currentDepth > this.config.maxIncludeDepth) {
+            throw new CircularReferenceError(`Include depth exceeded limit of ${this.config.maxIncludeDepth} at model: ${modelName}`);
+        }
+        // Detectar referencia circular directa
+        if (visitedModels.has(modelName)) {
+            const path = Array.from(visitedModels).join(' -> ') + ` -> ${modelName}`;
+            throw new CircularReferenceError(`Circular reference detected in include path: ${path}`);
+        }
+        if (!includeOptions || typeof includeOptions !== 'object') {
+            return;
+        }
+        const newVisited = new Set(visitedModels);
+        newVisited.add(modelName);
+        // Validar cada relación incluida
+        for (const [relationKey, relationOptions] of Object.entries(includeOptions)) {
+            if (this.config.trackingEnabled) {
+                this.pathHistory.push({
+                    modelName,
+                    relationKey,
+                    depth: currentDepth,
+                });
+            }
+            // Si la relación tiene sus propios includes, validar recursivamente
+            if (relationOptions && typeof relationOptions === 'object' && 'include' in relationOptions) {
+                // Aquí necesitaríamos obtener el modelo target de la relación
+                // Por simplicidad, usamos el relationKey como modelo (esto debería mejorar)
+                const targetModelName = this.inferTargetModelName(relationKey);
+                this.validateIncludePath(targetModelName, relationOptions.include, currentDepth + 1, newVisited);
+            }
+        }
+    }
+    /**
+     * Validar estructura de relaciones en tiempo de definición
+     */
+    validateRelationStructure(models, maxAllowedCycles = 0) {
+        const graph = this.buildRelationGraph(models);
+        const cycles = this.detectCycles(graph);
+        return {
+            isValid: cycles.length <= maxAllowedCycles,
+            cycles,
+            suggestions: this.generateSuggestions(cycles),
+        };
+    }
+    /**
+     * Construir grafo de relaciones
+     */
+    buildRelationGraph(models) {
+        const graph = new Map();
+        for (const [modelName, model] of models.entries()) {
+            const relations = [];
+            // Esto necesitaría acceso a los metadatos del modelo
+            // Por ahora simulamos la extracción de relaciones
+            const meta = model.getMeta?.();
+            if (meta?.relations) {
+                for (const [relationKey, relation] of meta.relations.entries()) {
+                    const targetModel = relation.targetModel?.()?.name || relationKey;
+                    relations.push(targetModel);
+                }
+            }
+            graph.set(modelName, relations);
+        }
+        return graph;
+    }
+    /**
+     * Detectar ciclos usando DFS
+     */
+    detectCycles(graph) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (node, path) => {
+            if (recursionStack.has(node)) {
+                // Ciclo detectado
+                const cycleStart = path.indexOf(node);
+                const cycle = path.slice(cycleStart).concat(node);
+                cycles.push(cycle);
+                return;
+            }
+            if (visited.has(node)) {
+                return;
+            }
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const neighbors = graph.get(node) || [];
+            for (const neighbor of neighbors) {
+                dfs(neighbor, [...path]);
+            }
+            recursionStack.delete(node);
+        };
+        for (const node of graph.keys()) {
+            if (!visited.has(node)) {
+                dfs(node, []);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Generar sugerencias para resolver ciclos
+     */
+    generateSuggestions(cycles) {
+        const suggestions = [];
+        for (const cycle of cycles) {
+            if (cycle.length === 2) {
+                suggestions.push(`Circular reference between ${cycle[0]} and ${cycle[1]}. Consider using lazy loading or removing one direction.`);
+            }
+            else {
+                suggestions.push(`Complex circular reference detected: ${cycle.join(' -> ')}. Consider breaking the cycle at the weakest relationship.`);
+            }
+        }
+        if (cycles.length > 0) {
+            suggestions.push('General: Use @NonAttribute for computed relationships or implement lazy loading to break cycles.');
+        }
+        return suggestions;
+    }
+    /**
+     * Inferir nombre del modelo target (simplificado)
+     */
+    inferTargetModelName(relationKey) {
+        // Conversión simple: posts -> Post, user -> User
+        return relationKey.charAt(0).toUpperCase() + relationKey.slice(1).replace(/s$/, '');
+    }
+    /**
+     * Crear contexto de rastreo para includes anidados
+     */
+    createTrackingContext() {
+        return new CircularTracker(this.config.maxIncludeDepth);
+    }
+    /**
+     * Obtener historial de paths para debugging
+     */
+    getPathHistory() {
+        return [...this.pathHistory];
+    }
+    /**
+     * Limpiar historial
+     */
+    clearHistory() {
+        this.pathHistory = [];
+        this.activePaths.clear();
+    }
+}
+exports.CircularReferenceDetector = CircularReferenceDetector;
+/**
+ * Tracker específico para una operación de include
+ */
+class CircularTracker {
+    constructor(maxDepth) {
+        this.visitedModels = new Set();
+        this.currentPath = [];
+        this.maxDepth = maxDepth;
+    }
+    enter(modelName) {
+        if (this.currentPath.length >= this.maxDepth) {
+            throw new CircularReferenceError(`Maximum include depth ${this.maxDepth} exceeded at: ${modelName}`);
+        }
+        if (this.visitedModels.has(modelName)) {
+            const cyclePath = this.currentPath.join(' -> ') + ` -> ${modelName}`;
+            throw new CircularReferenceError(`Circular reference detected: ${cyclePath}`);
+        }
+        this.visitedModels.add(modelName);
+        this.currentPath.push(modelName);
+    }
+    exit(modelName) {
+        this.currentPath.pop();
+        this.visitedModels.delete(modelName);
+    }
+    getCurrentPath() {
+        return [...this.currentPath];
+    }
+}
+exports.CircularTracker = CircularTracker;
+class CircularReferenceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CircularReferenceError';
+    }
+}
+exports.CircularReferenceError = CircularReferenceError;
+// Instancia singleton
+const circularDetector = new CircularReferenceDetector();
+exports.circularDetector = circularDetector;
+exports.default = circularDetector;
+//# sourceMappingURL=circular-detector.js.map