rawsql-ts 0.11.0-beta → 0.11.2-beta

package/dist/esm/types/src/transformers/JsonMappingConverter.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Unified JSON mapping converter that handles all supported formats
+ * and provides a single interface for mapping transformations.
+ */
+import { JsonMapping } from './PostgresJsonQueryBuilder';
+import { ModelDrivenJsonMapping } from './ModelDrivenJsonMapping';
+import { EnhancedJsonMapping, LegacyJsonMapping, TypeProtectionConfig } from './EnhancedJsonMapping';
+/**
+ * Input format types that the converter can handle.
+ */
+export type JsonMappingInput = EnhancedJsonMapping | ModelDrivenJsonMapping | LegacyJsonMapping;
+/**
+ * Format detection result.
+ */
+export type MappingFormat = 'enhanced' | 'model-driven' | 'legacy';
+/**
+ * Conversion result with metadata.
+ */
+export interface ConversionResult {
+    /** Detected input format */
+    format: MappingFormat;
+    /** Converted legacy mapping for PostgresJsonQueryBuilder */
+    mapping: JsonMapping;
+    /** Type protection configuration */
+    typeProtection: TypeProtectionConfig;
+    /** Original input for reference */
+    originalInput: JsonMappingInput;
+    /** Additional metadata */
+    metadata?: {
+        typeInfo?: {
+            interface: string;
+            importPath: string;
+            generics?: string[];
+        };
+        version?: string;
+        description?: string;
+    };
+}
+/**
+ * Unified JSON mapping converter that handles all supported formats using the Strategy pattern.
+ *
+ * This converter automatically detects the input format and applies the appropriate conversion
+ * strategy to transform any supported JSON mapping format into a standardized result.
+ *
+ * **Supported Formats:**
+ * - **Enhanced**: Rich format with metadata, type protection, and advanced column configurations
+ * - **Model-Driven**: TypeScript interface-based mapping with structured field definitions
+ * - **Legacy**: Simple format compatible with PostgresJsonQueryBuilder
+ *
+ * **Usage:**
+ * ```typescript
+ * const converter = new JsonMappingConverter();
+ * const result = converter.convert(someMapping);
+ * const legacyMapping = converter.toLegacyMapping(someMapping);
+ * ```
+ *
+ * @public
+ */
+export declare class JsonMappingConverter {
+    /** Ordered list of conversion strategies, checked in priority order */
+    private strategies;
+    /**
+     * Creates a new JsonMappingConverter with all supported strategies.
+     *
+     * Strategies are checked in order of specificity:
+     * 1. Enhanced format (most feature-rich)
+     * 2. Model-driven format (TypeScript-based)
+     * 3. Legacy format (fallback)
+     */
+    constructor();
+    /**
+     * Detects the format of the input mapping without performing conversion.
+     *
+     * This method uses the same strategy pattern as conversion but only returns
+     * the detected format type for inspection purposes.
+     *
+     * @param input - The JSON mapping to analyze
+     * @returns The detected mapping format type
+     *
+     * @throws {Error} When input format is not supported by any strategy
+     *
+     * @example
+     * ```typescript
+     * const format = converter.detectFormat(myMapping);
+     * console.log(`Detected format: ${format}`); // "enhanced", "model-driven", or "legacy"
+     * ```
+     */
+    detectFormat(input: JsonMappingInput): MappingFormat;
+    /**
+     * Converts any supported JSON mapping format to a comprehensive result with metadata.
+     *
+     * This is the primary conversion method that performs format detection and transformation
+     * in a single operation. The result includes the legacy mapping, type protection configuration,
+     * and metadata about the conversion process.
+     *
+     * @param input - The JSON mapping in any supported format (Enhanced, Model-Driven, or Legacy)
+     * @returns Complete conversion result with mapping, metadata, and type protection
+     *
+     * @throws {Error} When the input format is not recognized by any strategy
+     *
+     * @example
+     * ```typescript
+     * const result = converter.convert(enhancedMapping);
+     * console.log(`Format: ${result.format}`);
+     * console.log(`Type protection: ${result.typeProtection.protectedStringFields.length} fields`);
+     *
+     * // Use the converted mapping
+     * const queryBuilder = new PostgresJsonQueryBuilder(result.mapping);
+     * ```
+     *
+     * @see {@link toLegacyMapping} For simple mapping extraction
+     * @see {@link getTypeProtection} For type protection only
+     */
+    convert(input: JsonMappingInput): ConversionResult;
+    /**
+     * Extracts only the legacy JsonMapping for direct use with PostgresJsonQueryBuilder.
+     *
+     * This convenience method performs the full conversion but returns only the mapping portion,
+     * discarding metadata and type protection information. Use this when you only need
+     * the mapping for query building and don't require additional metadata.
+     *
+     * @param input - The JSON mapping in any supported format
+     * @returns Legacy-format JsonMapping ready for PostgresJsonQueryBuilder
+     *
+     * @throws {Error} When the input format is not supported
+     *
+     * @example
+     * ```typescript
+     * const legacyMapping = converter.toLegacyMapping(modelDrivenMapping);
+     * const queryBuilder = new PostgresJsonQueryBuilder(legacyMapping);
+     * const query = queryBuilder.build(selectQuery);
+     * ```
+     *
+     * @see {@link convert} For full conversion with metadata
+     */
+    toLegacyMapping(input: JsonMappingInput): JsonMapping;
+    /**
+     * Extracts type protection configuration for runtime type checking.
+     *
+     * Type protection helps identify fields that should be treated as strings
+     * to prevent injection attacks or type coercion issues. This is particularly
+     * useful when working with user input or external data sources.
+     *
+     * @param input - The JSON mapping in any supported format
+     * @returns Type protection configuration with protected field definitions
+     *
+     * @throws {Error} When the input format is not supported
+     *
+     * @example
+     * ```typescript
+     * const typeProtection = converter.getTypeProtection(enhancedMapping);
+     *
+     * // Apply type protection during data processing
+     * for (const field of typeProtection.protectedStringFields) {
+     *     if (typeof data[field] !== 'string') {
+     *         data[field] = String(data[field]);
+     *     }
+     * }
+     * ```
+     */
+    getTypeProtection(input: JsonMappingInput): TypeProtectionConfig;
+    /**
+     * Validates that the input mapping is well-formed and can be successfully converted.
+     *
+     * This method performs comprehensive validation without attempting conversion,
+     * returning an array of error messages for any issues found. An empty array
+     * indicates the mapping is valid and ready for conversion.
+     *
+     * **Validation Checks:**
+     * - Basic structure validation (object type, required fields)
+     * - Format-specific validation (Enhanced, Model-Driven, Legacy)
+     * - Column configuration validation
+     * - Type protection configuration validation
+     *
+     * @param input - The JSON mapping to validate
+     * @returns Array of validation error messages (empty if valid)
+     *
+     * @example
+     * ```typescript
+     * const errors = converter.validate(suspiciousMapping);
+     * if (errors.length > 0) {
+     *     console.error('Validation failed:', errors);
+     *     throw new Error(`Invalid mapping: ${errors.join(', ')}`);
+     * }
+     *
+     * // Safe to convert
+     * const result = converter.convert(suspiciousMapping);
+     * ```
+     *
+     * @see {@link convert} Performs conversion after implicit validation
+     */
+    validate(input: JsonMappingInput): string[];
+    /**
+     * Creates a new enhanced mapping from legacy mapping.
+     */
+    upgradeToEnhanced(legacy: LegacyJsonMapping, typeInfo?: {
+        interface: string;
+        importPath: string;
+    }): EnhancedJsonMapping;
+}

package/dist/esm/types/src/transformers/JsonMappingUnifier.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Unified JSON Mapping processor that supports both legacy and model-driven formats.
+ *
+ * @deprecated Use JsonMappingConverter instead. This module is kept for backward compatibility.
+ * This module provides backward compatibility while encouraging migration to the model-driven format.
+ * It automatically detects the input format and normalizes to a consistent internal representation.
+ */
+import { JsonMapping } from './PostgresJsonQueryBuilder';
+import { ModelDrivenJsonMapping } from './ModelDrivenJsonMapping';
+/**
+ * Unified mapping format that can handle both legacy and model-driven inputs.
+ */
+export interface UnifiedMappingInput {
+    typeInfo?: {
+        interface: string;
+        importPath: string;
+    };
+    structure?: any;
+    protectedStringFields?: string[];
+    rootName?: string;
+    rootEntity?: any;
+    nestedEntities?: any[];
+    columns?: any;
+    relationships?: any;
+}
+/**
+ * Result of mapping format detection and conversion.
+ */
+export interface MappingProcessResult {
+    format: 'model-driven' | 'unified' | 'legacy';
+    jsonMapping: JsonMapping;
+    originalInput: UnifiedMappingInput;
+    metadata?: {
+        typeInfo?: {
+            interface: string;
+            importPath: string;
+        };
+        protectedStringFields?: string[];
+        typeProtection?: any;
+    };
+}
+/**
+ * Detects the format of a JSON mapping configuration.
+ *
+ * @param input - The mapping configuration to analyze
+ * @returns The detected format type
+ */
+export declare function detectMappingFormat(input: UnifiedMappingInput): 'model-driven' | 'unified' | 'legacy';
+/**
+ * Main processor that unifies all JSON mapping formats into a consistent JsonMapping.
+ *
+ * @deprecated Use JsonMappingConverter.convert() instead.
+ *
+ * Features:
+ * - Automatic format detection
+ * - Backward compatibility with all existing formats
+ * - Metadata preservation for advanced features
+ * - Zero external dependencies
+ *
+ * @param input - Any supported JSON mapping format
+ * @returns Unified processing result with JsonMapping and metadata
+ */
+export declare function processJsonMapping(input: UnifiedMappingInput): MappingProcessResult;
+/**
+ * Convenience function for direct JsonMapping extraction.
+ *
+ * @deprecated Use JsonMappingConverter.toLegacyMapping() instead.
+ *
+ * @param input - Any supported JSON mapping format
+ * @returns JsonMapping ready for use with PostgresJsonQueryBuilder
+ */
+export declare function unifyJsonMapping(input: UnifiedMappingInput): JsonMapping;
+/**
+ * Type guard to check if input uses model-driven format.
+ *
+ * @param input - Mapping input to check
+ * @returns True if input is model-driven format
+ */
+export declare function isModelDrivenFormat(input: UnifiedMappingInput): input is ModelDrivenJsonMapping;
+/**
+ * Type guard to check if input uses unified format.
+ *
+ * @param input - Mapping input to check
+ * @returns True if input is unified format
+ */
+export declare function isUnifiedFormat(input: UnifiedMappingInput): boolean;
+/**
+ * Type guard to check if input uses legacy format.
+ *
+ * @param input - Mapping input to check
+ * @returns True if input is legacy format
+ */
+export declare function isLegacyFormat(input: UnifiedMappingInput): boolean;
+/**
+ * Migration helper that suggests upgrading to model-driven format.
+ *
+ * @param input - Current mapping configuration
+ * @returns Suggestions for migration (if applicable)
+ */
+export declare function suggestModelDrivenMigration(input: UnifiedMappingInput): string[];

package/dist/esm/types/src/transformers/ModelDrivenJsonMapping.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Model-driven JSON mapping structure that mirrors TypeScript model definitions.
+ * This approach provides intuitive, hierarchical mapping that closely resembles the target data structure.
+ */
+import { JsonMapping } from './PostgresJsonQueryBuilder';
+/**
+ * Supported field types for database column mapping.
+ */
+export type FieldType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'auto';
+/**
+ * Field mapping configuration that can be either a simple column name or enhanced mapping with type control.
+ */
+export type FieldMapping = string | {
+    column: string;
+    type?: FieldType;
+} | {
+    from: string;
+    type?: FieldType;
+};
+/**
+ * Nested object or array structure definition.
+ */
+export interface NestedStructure {
+    type: 'object' | 'array';
+    from: string;
+    structure: StructureFields;
+}
+/**
+ * Structure fields can contain either field mappings or nested structures.
+ */
+export type StructureFields = {
+    [key: string]: FieldMapping | NestedStructure;
+};
+/**
+ * Model-driven JSON mapping that mirrors TypeScript interface structure.
+ * This design makes it easy to understand the relationship between models and database columns.
+ */
+export interface ModelDrivenJsonMapping {
+    typeInfo: {
+        interface: string;
+        importPath: string;
+    };
+    structure: StructureFields;
+}
+/**
+ * Type protection configuration extracted from the model-driven mapping.
+ */
+export interface TypeProtectionConfig {
+    protectedStringFields: string[];
+}
+/**
+ * Convert a model-driven JSON mapping to the traditional JsonMapping format.
+ * This enables backward compatibility with existing PostgresJsonQueryBuilder.
+ */
+export declare function convertModelDrivenMapping(modelMapping: ModelDrivenJsonMapping): {
+    jsonMapping: JsonMapping;
+    typeProtection: TypeProtectionConfig;
+};
+/**
+ * Validate that a model-driven mapping structure is well-formed.
+ */
+export declare function validateModelDrivenMapping(mapping: ModelDrivenJsonMapping): string[];

package/dist/esm/types/src/transformers/PostgresArrayEntityCteBuilder.d.ts

@@ -1,97 +1,138 @@
 import { CommonTable } from '../models/Clause';
 import { JsonMapping } from './PostgresJsonQueryBuilder';
-import { ProcessableEntity } from './PostgresObjectEntityCteBuilder';
+import { ProcessableEntity, JsonColumnMapping } from './PostgresObjectEntityCteBuilder';
 /**
- * PostgreSQL-specific builder for creating CTEs for array entities (array relationships).
- * This class handles the creation of CTEs that build JSON/JSONB arrays for child entities,
- * processing them from the deepest level up to ensure proper dependency ordering.
+ * Builds CTEs for array entities using depth-first processing and row compression.
  *
- * Features:
- * - Depth-based CTE naming (cte_array_depth_N)
- * - Row compression using GROUP BY operations
- * - JSONB/JSON array aggregation
- * - Hierarchical processing of nested arrays
- * - Column exclusion to avoid duplication
- *
- * Why depth calculation is critical:
- * 1. Array entities can be nested at multiple levels. We must process the deepest
- *    (most distant) arrays first to ensure their JSON representations are available
- *    when building their parent arrays.
- * 2. Array entity processing is essentially a row compression operation using GROUP BY.
- *    Unlike parent entities which use column compression, arrays require grouping
- *    to aggregate multiple rows into JSON arrays.
- *
- * Example hierarchy:
- * Order (root, depth 0)
- *   └─ Items (array, depth 1)
- *       └─ Details (array, depth 2)
- *
- * Processing order: depth 2 → depth 1 → depth 0
+ * Core concepts:
+ * - Column Compression: OBJECT relationships (user_id, user_name → user_json)
+ * - Row Compression: ARRAY relationships (multiple rows → JSON array via GROUP BY)
+ * - Depth-First: Process deepest arrays first for dependency ordering
+ * - GROUP BY Exclusion: Exclude array-internal columns to prevent over-grouping
  */
 export declare class PostgresArrayEntityCteBuilder {
     private static readonly CTE_ARRAY_PREFIX;
+    private static readonly JSON_FUNCTIONS;
     /**
-     * Build CTEs for all array entities in the correct dependency order
-     * @param ctesSoFar Array of CTEs built so far (starts with the initial CTE)
-     * @param aliasOfCteToBuildUpon Alias of the CTE from which the current array CTE will select
+     * Builds CTEs for all array entities using depth-first processing.
+     * Collects arrays by depth, processes deepest first, chains CTEs.
+     *
+     * @param ctesSoFar Array of CTEs built so far
+     * @param aliasOfCteToBuildUpon Alias of the CTE to build upon
      * @param allEntities Map of all entities in the mapping
      * @param mapping The JSON mapping configuration
-     * @returns Object containing the updated list of all CTEs and the alias of the last CTE created
+     * @param columnMappings Optional mappings from object entity IDs to generated JSON column names
+     * @returns Object containing updated CTEs and last CTE alias
      */
-    buildArrayEntityCtes(ctesSoFar: CommonTable[], aliasOfCteToBuildUpon: string, allEntities: Map<string, ProcessableEntity>, mapping: JsonMapping): {
+    buildArrayEntityCtes(ctesSoFar: CommonTable[], aliasOfCteToBuildUpon: string, allEntities: Map<string, ProcessableEntity>, mapping: JsonMapping, columnMappings?: JsonColumnMapping[]): {
         updatedCtes: CommonTable[];
         lastCteAlias: string;
     };
     /**
-     * Collect all array entities and calculate their depth from root.
-     *
-     * Depth calculation ensures proper processing order where deeper nested
-     * arrays are processed first, making their aggregated data available
-     * for parent array processing.
+     * Collects array entities and calculates depth for dependency ordering.
+     * Depth = distance from root. Deeper arrays processed first.
      *
      * @param mapping The JSON mapping configuration
      * @param allEntities Map of all entities in the mapping
-     * @returns Array of array entity information with calculated depths, sorted deepest first
+     * @returns Array of array entity information with depths, sorted deepest first
      */
     private collectAndSortArrayEntities;
     /**
-     * Group array entities by their depth level.
-     *
-     * Grouping by depth allows us to:
-     * - Process all entities at the same level in a single CTE
-     * - Optimize query performance by reducing the number of CTEs
-     * - Maintain clear dependency ordering
+     * Groups array entities by depth level for batch processing.
      *
      * @param arrayInfos Array of array entity information with depths
      * @returns Map of depth level to entities at that depth
      */
     private groupEntitiesByDepth;
     /**
-     * Build a CTE that processes all array entities at a specific depth level.
-     *
-     * This method creates a single CTE that aggregates multiple array entities
-     * at the same depth, using GROUP BY to compress rows into JSON arrays.
+     * Builds CTE for specific depth level using row compression.
+     * Uses GROUP BY to aggregate multiple rows into JSON arrays.
+     * Excludes array-internal columns from GROUP BY to prevent over-grouping.
      *
      * @param infos Array entities at this depth level
      * @param currentCteAlias Alias of the CTE to build upon
      * @param currentCtes All CTEs built so far
      * @param depth Current depth level being processed
      * @param mapping JSON mapping configuration
+     * @param columnMappings Optional mappings from object entity IDs to generated JSON column names
      * @returns The new CTE and its alias
      */
     private buildDepthCte;
     /**
-     * Build JSON aggregation function for an array entity.
-     *
-     * This method creates a jsonb_agg or json_agg function call that aggregates
-     * the entity's columns into a JSON array. It also handles nested relationships
-     * by including child entity properties in the JSON object.
+     * Creates jsonb_agg function for array entity.
+     * Handles entity columns and nested child relationships.
+     * Uses originalPropertyName to avoid sequential numbering.
      *
      * @param entity The array entity being processed
      * @param nestedEntities All nested entities from the mapping
      * @param allEntities Map of all entities (not used in current implementation)
-     * @param useJsonb Whether to use JSONB functions
+     * @param columnMappings Mappings from object entity IDs to generated JSON column names
      * @returns Object containing the JSON aggregation function
      */
     private buildAggregationDetailsForArrayEntity;
+    /**
+     * Collects array entity columns by depth for GROUP BY exclusion strategy.
+     *
+     * @param mapping The JSON mapping configuration containing all entities
+     * @param currentDepth The current aggregation depth being processed
+     * @returns A map where keys are depth levels and values are sets of column names
+     */
+    private collectArrayEntityColumnsByDepth;
+    /**
+     * Calculates entity depth by traversing up to root.
+     *
+     * @param entity The entity to calculate depth for
+     * @param mapping The JSON mapping containing all entities
+     * @returns The depth level (0 for root level, 1 for first level, etc.)
+     */
+    private calculateEntityDepth;
+    /**
+     * Adds entity columns to depth set.
+     *
+     * @param entity The entity whose columns should be added
+     * @param depth The depth level to add columns to
+     * @param arrayEntitiesByDepth The map to update
+     */
+    private addEntityColumnsToDepthSet;
+    /**
+     * Recursively collects columns from descendant entities.
+     *
+     * @param parentEntityId The ID of the parent entity
+     * @param targetDepth The depth level to assign collected columns to
+     * @param mapping The JSON mapping containing all entities
+     * @param arrayEntitiesByDepth The map to update with collected columns
+     */
+    private collectDescendantColumns;
+    /**
+     * Implements GROUP BY exclusion strategy for array aggregation.
+     * Excludes current array columns and array-internal object JSON columns.
+     *
+     * @param prevSelects SELECT variables from the previous CTE
+     * @param arrayColumns Columns that are being aggregated (should be excluded from GROUP BY)
+     * @param arrayEntitiesByDepth Map of depth levels to their column sets
+     * @param currentDepth The current aggregation depth being processed
+     * @param selectItems Output array for SELECT items
+     * @param groupByItems Output array for GROUP BY items
+     * @param arrayInternalObjectColumns JSON columns from objects within arrays being processed
+     */
+    private processSelectVariablesForGroupBy;
+    /**
+     * Determines if column should be included in GROUP BY clause.
+     * Applies depth-based filtering and special handling for JSON columns.
+     *
+     * @param columnName The name of the column to evaluate
+     * @param arrayEntitiesByDepth Map of depth levels to their column sets
+     * @param currentDepth The current aggregation depth
+     * @returns True if the column should be included in GROUP BY, false otherwise
+     */
+    private shouldIncludeColumnInGroupBy;
+    /**
+     * Applies heuristics for entity JSON column inclusion in GROUP BY.
+     * Uses entity numbering patterns to identify deeply nested entities.
+     *
+     * @param columnName The JSON column name (expected format: entity_N_json)
+     * @param currentDepth The current aggregation depth
+     * @returns True if the JSON column should be included, false otherwise
+     */
+    private shouldIncludeJsonColumn;
 }

package/dist/esm/types/src/transformers/PostgresJsonQueryBuilder.d.ts

@@ -1,5 +1,6 @@
 import { SimpleSelectQuery } from '../models/SimpleSelectQuery';
 import { SelectQuery } from '../models/SelectQuery';
+import { QueryBuildOptions } from './DynamicQueryBuilder';
 /**
  * Universal JSON mapping definition for creating any level of JSON structures.
  * Supports flat arrays, nested objects, and unlimited hierarchical structures.
@@ -23,7 +24,6 @@ export interface JsonMapping {
             [jsonKey: string]: string;
         };
     }>;
-    useJsonb?: boolean;
     resultFormat?: "array" | "single";
     emptyResult?: string;
 }
@@ -48,8 +48,8 @@ export declare class PostgresJsonQueryBuilder {
      * @param mapping JSON mapping configuration
      * @returns Transformed query with JSON aggregation
      */
-    buildJsonQuery(originalQuery: SelectQuery, mapping: JsonMapping): SimpleSelectQuery;
-    buildJsonQuery(originalQuery: SimpleSelectQuery, mapping: JsonMapping): SimpleSelectQuery;
+    buildJsonQuery(originalQuery: SelectQuery, mapping: JsonMapping, options?: QueryBuildOptions): SimpleSelectQuery;
+    buildJsonQuery(originalQuery: SimpleSelectQuery, mapping: JsonMapping, options?: QueryBuildOptions): SimpleSelectQuery;
     /**
      * Build JSON query from original query and mapping configuration.
      * @deprecated Use buildJsonQuery instead. This method will be removed in a future version.

package/dist/esm/types/src/transformers/PostgresObjectEntityCteBuilder.d.ts

@@ -14,6 +14,23 @@ export interface ProcessableEntity {
     parentId?: string;
     relationshipType?: "object" | "array";
 }
+/**
+ * JSON column mapping information
+ */
+export interface JsonColumnMapping {
+    entityId: string;
+    entityName: string;
+    generatedColumnName: string;
+    depth: number;
+}
+/**
+ * Result from CTE builder including column mappings
+ */
+export interface CteBuilderResult {
+    ctes: CommonTable[];
+    lastCteAlias: string;
+    columnMappings: JsonColumnMapping[];
+}
 /**
  * PostgreSQL-specific builder for creating CTEs for object entities (object relationships).
  * This class handles the creation of CTEs that build JSON/JSONB objects for object entities,
@@ -43,19 +60,23 @@ export interface ProcessableEntity {
  * Processing order: depth 2 → depth 1 → depth 0
  */
 export declare class PostgresObjectEntityCteBuilder {
-    private static readonly JSON_COLUMN_SUFFIX;
     private static readonly CTE_OBJECT_PREFIX;
-    private static readonly WILDCARD_COLUMN; /**
+    private static readonly WILDCARD_COLUMN;
+    private jsonColumnCounter;
+    private entityToJsonColumnMap;
+    private columnMappings;
+    /**
      * Build CTEs for all object entities in the correct dependency order
      * @param initialCte The starting CTE containing all raw data
      * @param allEntities Map of all entities in the mapping
      * @param mapping The JSON mapping configuration
      * @returns Array of CTEs and the alias of the last CTE created
      */
-    buildObjectEntityCtes(initialCte: CommonTable, allEntities: Map<string, ProcessableEntity>, mapping: JsonMapping): {
-        ctes: CommonTable[];
-        lastCteAlias: string;
-    }; /**
+    buildObjectEntityCtes(initialCte: CommonTable, allEntities: Map<string, ProcessableEntity>, mapping: JsonMapping): CteBuilderResult;
+    /**
+     * Generate unique JSON column name with entity name and counter
+     */
+    private generateUniqueJsonColumnName; /**
      * Collect all object entities and calculate their depth from root.
      *
      * Depth calculation is crucial because:
@@ -87,6 +108,10 @@ export declare class PostgresObjectEntityCteBuilder {
      * Build JSON column for a single entity with NULL handling
      */
     private buildEntityJsonColumn;
+    /**
+     * Calculate approximate depth for an entity (for mapping purposes)
+     */
+    private calculateApproximateDepth;
     /**
      * Prepare entity columns and NULL checks.
      *

package/dist/esm/types/src/transformers/SelectableColumnCollector.d.ts

@@ -20,12 +20,23 @@ import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
 import { ValueComponent } from "../models/ValueComponent";
 import { TableColumnResolver } from "./TableColumnResolver";
 /**
- * A visitor that collects all ColumnReference instances from a SQL query structure.
+ * A visitor that collects all ColumnReference instances from SimpleSelectQuery structures.
  * This visitor scans through all clauses and collects all unique ColumnReference objects.
  * It does not scan Common Table Expressions (CTEs) or subqueries.
  *
- * Important: Only collects column references to tables defined in the root FROM/JOIN clauses,
- * as these are the only columns that can be directly referenced in the query.
+ * IMPORTANT: This collector only supports SimpleSelectQuery. BinarySelectQuery
+ * (UNION/INTERSECT/EXCEPT) will throw an error and should be decomposed into
+ * individual SimpleSelectQuery branches before using this collector.
+ *
+ * Behavioral notes:
+ * - Only collects column references to tables defined in the root FROM/JOIN clauses
+ * - For aliased columns (e.g., 'title as name'), collects both the original column
+ *   reference ('title') AND the alias ('name') to enable complete dependency tracking
+ *
+ * Use cases:
+ * - Dependency analysis and schema migration tools
+ * - Column usage tracking within individual SELECT branches
+ * - Security analysis for column-level access control
  */
 export declare class SelectableColumnCollector implements SqlComponentVisitor<void> {
     private handlers;