rawsql-ts 0.20.0 → 0.21.0

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

@@ -1,88 +0,0 @@
-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.
- */
-export interface JsonMapping {
-    rootName: string;
-    rootEntity: {
-        id: string;
-        name: string;
-        columns: {
-            [jsonKey: string]: string;
-        };
-    };
-    nestedEntities: Array<{
-        id: string;
-        name: string;
-        parentId: string;
-        propertyName: string;
-        relationshipType?: "object" | "array";
-        columns: {
-            [jsonKey: string]: string;
-        };
-    }>;
-    resultFormat?: "array" | "single";
-    emptyResult?: string;
-}
-/**
- * PostgreSQL JSON query builder that transforms SimpleSelectQuery into queries
- * that return JSON arrays or single JSON objects using PostgreSQL JSON functions.
- */
-export declare class PostgresJsonQueryBuilder {
-    private selectValueCollector;
-    private objectEntityCteBuilder;
-    private arrayEntityCteBuilder;
-    constructor();
-    /**
-     * Validates the JSON mapping and the original query.
-     * @param query Original query to transform
-     * @param mapping JSON mapping configuration
-     */
-    private validateMapping;
-    /**
-     * Build JSON query from original query and mapping configuration.
-     * @param originalQuery Original query to transform (can be any SelectQuery type)
-     * @param mapping JSON mapping configuration
-     * @returns Transformed query with JSON aggregation
-     */
-    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.
-     * @param originalQuery Original query to transform
-     * @param mapping JSON mapping configuration
-     * @returns Transformed query with JSON aggregation
-     */
-    buildJson(originalQuery: SimpleSelectQuery, mapping: JsonMapping): SimpleSelectQuery;
-    /**
-     * Builds the JSON structure using a unified CTE-based strategy.
-     * @param originalQuery Original query
-     * @param mapping JSON mapping configuration
-     * @returns Query with CTE-based JSON aggregation
-     */
-    private buildJsonWithCteStrategy;
-    /**
-     * Creates the initial Common Table Expression (CTE) from the original query.
-     * @param originalQuery The base SimpleSelectQuery.
-     * @returns An object containing the initial CTE and its alias.
-     */
-    private createInitialCte;
-    /**
-     * Builds the final SELECT query that constructs the root JSON object (or array of objects).
-     * This query uses all previously generated CTEs.
-     * @param finalCtesList The complete list of all CTEs (initial and array CTEs).
-     * @param lastCteAliasForFromClause Alias of the final CTE from which the root object will be built.
-     * @param allEntities Map of all processable entities.
-     * @param mapping JSON mapping configuration.
-     * @returns The final SimpleSelectQuery.
-     */
-    private buildFinalSelectQuery;
-    /**
-     * Build JSON object for entity, using parent JSON columns when available
-     */
-    private buildEntityJsonObject;
-}

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

@@ -1,165 +0,0 @@
-import { CommonTable } from '../models/Clause';
-import { JsonMapping } from './PostgresJsonQueryBuilder';
-/**
- * Entity with processing metadata
- */
-export interface ProcessableEntity {
-    id: string;
-    name: string;
-    columns: {
-        [jsonKey: string]: string;
-    };
-    isRoot: boolean;
-    propertyName: string;
-    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,
- * processing them from the deepest level up to ensure proper dependency ordering.
- *
- * Features:
- * - Depth-based CTE naming (cte_object_depth_N)
- * - NULL handling for entity columns
- * - JSONB/JSON object construction
- * - Hierarchical processing of nested objects
- *
- * Why depth calculation is critical:
- * 1. Object entities can be nested at multiple levels. We must process the deepest
- *    (most distant) objects first to ensure their JSON representations are available
- *    when building their parent entities.
- * 2. Object entity processing is essentially a column compression operation. Entities
- *    at the same depth level can be processed simultaneously since they don't depend
- *    on each other.
- *
- * Example hierarchy:
- * Order (root, depth 0)
- *   └─ Customer (depth 1)
- *       └─ Address (depth 2)
- *   └─ Shipping (depth 1)
- *       └─ Carrier (depth 2)
- *
- * Processing order: depth 2 → depth 1 → depth 0
- */
-export declare class PostgresObjectEntityCteBuilder {
-    private static readonly CTE_OBJECT_PREFIX;
-    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): 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:
-     * - It determines the processing order (deepest first)
-     * - It ensures dependencies are resolved before an entity is processed
-     * - It allows parallel processing of entities at the same depth level
-     *
-     * @param mapping The JSON mapping configuration
-     * @param allEntities Map of all entities in the mapping
-     * @returns Array of object entity information with calculated depths
-     */
-    private collectAndSortObjectEntities;
-    /**
-     * Group 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
-     *
-     * @param parentInfos Array of parent entity information with depths
-     * @returns Map of depth level to entities at that depth
-     */ private groupEntitiesByDepth;
-    /**
-     * Build a CTE that processes all entities at a specific depth level
-     */
-    private buildDepthCte;
-    /**
-     * 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.
-     *
-     * This method extracts column data and creates NULL checks for each column.
-     * The NULL checking is essential for handling outer joins correctly.
-     *
-     * In outer join scenarios, when there's no matching row in the joined table,
-     * all columns from that table will be NULL. Instead of creating an empty object
-     * with all NULL properties (e.g., {id: null, name: null, email: null}),
-     * we want to represent the absence of the entity as NULL itself.
-     *
-     * This ensures cleaner JSON output where missing relationships are represented
-     * as NULL rather than objects with all NULL fields.
-     *
-     * @param entity The entity whose columns are being processed
-     * @returns Object containing arrays of JSON object arguments and NULL check conditions
-     */
-    private prepareEntityColumns;
-    /**
-     * Add child object relationships to JSON object arguments.
-     *
-     * This method processes nested object-type entities that are direct children of the current entity.
-     * For each child entity, it adds the property name and corresponding JSON column reference
-     * to the arguments array that will be used to build the parent's JSON object.
-     *
-     * The child JSON columns are expected to already exist in the data source (created by deeper
-     * level CTEs), as we process from the deepest level up to the root.
-     *
-     * Note: In this context, "child" refers to entities that have an object relationship (0..1)
-     * with their parent. From a data perspective, these are typically entities referenced via
-     * foreign keys, representing "parent" entities in traditional database terminology.
-     *
-     * @param entity The current entity being processed
-     * @param jsonObjectArgs Array to which JSON object arguments will be added
-     * @param mapping The JSON mapping configuration
-     * @param allEntities Map of all entities in the mapping
-     */
-    private addChildObjectRelationships;
-    /**
-     * Create JSON object function call
-     */
-    private createJsonObject;
-    /**
-     * Build NULL condition from NULL checks
-     */
-    private buildNullCondition;
-    /**
-     * Create CASE expression with NULL handling
-     */
-    private createCaseExpression;
-}

package/dist/src/transformers/TypeTransformationPostProcessor.d.ts

@@ -1,108 +0,0 @@
-/**
- * Post-processor for transforming database values to appropriate TypeScript types
- * after JSON serialization from PostgreSQL
- */
-export interface TypeTransformationConfig {
-    /** Column transformations mapping - takes precedence over value-based detection */
-    columnTransformations?: {
-        [columnName: string]: TypeTransformation;
-    };
-    /** Global transformation rules by SQL data type */
-    globalTransformations?: {
-        [sqlType: string]: TypeTransformation;
-    };
-    /** Custom transformation functions */
-    customTransformers?: {
-        [transformerName: string]: (value: unknown) => unknown;
-    };
-    /** Enable value-based type detection when column mapping is not provided (default: true) */
-    enableValueBasedDetection?: boolean;
-    /** Strict date detection - only convert ISO 8601 with 'T' separator (default: false) */
-    strictDateDetection?: boolean;
-}
-export interface TypeTransformation {
-    /** Source SQL data type */
-    sourceType: 'DATE' | 'TIMESTAMP' | 'BIGINT' | 'NUMERIC' | 'JSONB' | 'custom';
-    /** Target TypeScript type representation */
-    targetType: 'Date' | 'bigint' | 'string' | 'number' | 'object' | 'custom';
-    /** Custom transformer function name (for custom type) */
-    customTransformer?: string;
-    /** Whether to handle null values (default: true) */
-    handleNull?: boolean;
-    /** Validation function for the value */
-    validator?: (value: unknown) => boolean;
-}
-/**
- * Applies type transformations to JSON results from PostgreSQL
- */
-export declare class TypeTransformationPostProcessor {
-    private config;
-    constructor(config?: TypeTransformationConfig);
-    /**
-     * Transform a single result object
-     * @param result The result object from PostgreSQL JSON query
-     * @returns Transformed result with proper TypeScript types
-     */
-    transformResult<T = unknown>(result: unknown): T;
-    /**
-     * Transform a single object recursively
-     */
-    private transformSingleObject;
-    /**
-     * Detect value type and create appropriate transformation based on value characteristics
-     * This is the core value-based detection logic
-     */
-    private detectValueBasedTransformation;
-    /**
-     * Get global transformation for a specific value (if any match)
-     * This is separate from value-based detection and relies on configured global rules
-     */
-    private getGlobalTransformationForValue;
-    /**
-     * @deprecated Use detectValueBasedTransformation instead
-     * Detect value type and get appropriate global transformation
-     */
-    private detectAndGetGlobalTransformation;
-    /**
-     * Check if string is a valid date string
-     * Supports both strict (ISO 8601 with T separator) and loose detection
-     */
-    private isDateString;
-    /**
-     * Apply a specific transformation to a value
-     */
-    private applyTransformation;
-    /**
-     * Create a default configuration for common PostgreSQL types
-     * Enables value-based detection with loose date detection by default
-     */
-    static createDefaultConfig(): TypeTransformationConfig;
-    /**
-     * Create a safe configuration for handling user input
-     * Disables value-based detection and uses strict date detection
-     */
-    static createSafeConfig(columnMappings?: {
-        [columnName: string]: TypeTransformation;
-    }): TypeTransformationConfig;
-}
-/**
- * Convenience function to create and apply transformations
- */
-export declare function transformDatabaseResult<T = unknown>(result: unknown, config?: TypeTransformationConfig): T;
-/**
- * Type-safe transformation helpers
- */
-export declare const TypeTransformers: {
-    /**
-     * Transform date string to Date object
-     */
-    toDate: (value: string | null) => Date | null;
-    /**
-     * Transform numeric string to BigInt
-     */
-    toBigInt: (value: string | number | null) => bigint | null;
-    /**
-     * Transform JSON string to object
-     */
-    toObject: <T = unknown>(value: string | null) => T | null;
-};

package/dist/src/utils/JsonSchemaValidator.d.ts

@@ -1,81 +0,0 @@
-import { JsonMapping } from '../transformers/PostgresJsonQueryBuilder';
-/**
- * Represents the structure extracted from JsonMapping analysis
- */
-export type ExtractedStructure = 'primitive' | {
-    [key: string]: ExtractedStructure;
-} | ExtractedStructure[];
-/**
- * Represents the expected type structure for validation
- */
-export type ExpectedTypeStructure = 'primitive' | {
-    [key: string]: ExpectedTypeStructure;
-} | ExpectedTypeStructure[];
-/**
- * Result of JsonMapping validation
- */
-export interface ValidationResult {
-    isValid: boolean;
-    errors: string[];
-    missingProperties: string[];
-    extraProperties: string[];
-}
-export declare class JsonSchemaValidator {
-    /**
-     * Validates JsonMapping structure against an expected type structure.
-     * Checks if the JsonMapping covers all required properties and relationships.
-     *
-     * @param jsonMapping The JsonMapping configuration to validate
-     * @param expectedStructure The expected type structure to validate against
-     * @returns ValidationResult containing validation status and detailed errors
-     */
-    static validate(jsonMapping: JsonMapping, expectedStructure: ExpectedTypeStructure): ValidationResult;
-    /**
-     * Validates JsonMapping structure and throws an error if validation fails.
-     * Convenience method for strict validation scenarios.
-     *
-     * @param jsonMapping The JsonMapping configuration to validate
-     * @param expectedStructure The expected type structure to validate against
-     * @throws Error if validation fails with detailed error messages
-     */
-    static validateStrict(jsonMapping: JsonMapping, expectedStructure: ExpectedTypeStructure): void;
-    /**
-     * Extracts structure information from JsonMapping configuration.
-     * Analyzes rootEntity and nestedEntities to build complete structure map.
-     *
-     * @param jsonMapping The JsonMapping to analyze
-     * @returns ExtractedStructure representing the mapping structure
-     */
-    private static extractStructureFromJsonMapping; /**
-     * Extracts structure from a nested entity, including its children.
-     */
-    private static extractNestedEntityStructure; /**
-     * Compares extracted structure with expected structure with proper type guards.
-     */
-    private static compareStructures;
-    /**
-     * Validates JsonMapping structure against a sample object that implements the expected type.
-     * This method extracts structure from the sample object and compares it with JsonMapping.
-     *
-     * @param jsonMapping The JsonMapping configuration to validate
-     * @param sampleObject A sample object that implements the expected interface/type
-     * @returns ValidationResult containing validation status and detailed errors
-     */
-    static validateAgainstSample<T>(jsonMapping: JsonMapping, sampleObject: T): ValidationResult;
-    /**
-     * Validates JsonMapping structure against a sample object and throws an error if validation fails.
-     * Convenience method for strict validation scenarios with sample objects.
-     *
-     * @param jsonMapping The JsonMapping configuration to validate
-     * @param sampleObject A sample object that implements the expected interface/type
-     * @throws Error if validation fails with detailed error messages
-     */
-    static validateAgainstSampleStrict<T>(jsonMapping: JsonMapping, sampleObject: T): void; /**
-     * Extracts structure information from a sample object.
-     * Recursively analyzes the object properties to build a structure map.
-     *
-     * @param sampleObject The sample object to analyze
-     * @returns ExpectedTypeStructure representing the object structure
-     */
-    private static extractStructureFromSample;
-}

package/dist/transformers/EnhancedJsonMapping.js

@@ -1,223 +0,0 @@
-"use strict";
-/**
- * Enhanced JSON mapping structure that extends the base JsonMapping interface
- * with additional metadata and type safety features.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertColumnsToLegacy = convertColumnsToLegacy;
-exports.convertToLegacyJsonMapping = convertToLegacyJsonMapping;
-exports.toLegacyMapping = toLegacyMapping;
-exports.extractTypeProtection = extractTypeProtection;
-/**
- * Converts enhanced column configurations to simple string mappings for legacy compatibility.
- *
- * This function transforms complex column configurations (with type info, nullable flags, etc.)
- * into simple string mappings that can be used with PostgresJsonQueryBuilder.
- *
- * **Supported Input Formats:**
- * - Simple strings: `"user_name"` → `"user_name"`
- * - Column config: `{ column: "u.name", type: "string" }` → `"u.name"`
- * - From config: `{ from: "user_name", nullable: true }` → `"user_name"`
- *
- * @param columns - Record of field names to column configurations
- * @returns Record of field names to column source strings
- *
- * @example
- * ```typescript
- * const enhanced = {
- *   id: { column: "u.user_id", type: "number" },
- *   name: { from: "user_name", type: "string" },
- *   email: "email_address"
- * };
- *
- * const legacy = convertColumnsToLegacy(enhanced);
- * // Result: { id: "u.user_id", name: "user_name", email: "email_address" }
- * ```
- */
-function convertColumnsToLegacy(columns) {
-    const result = {};
-    for (const [key, config] of Object.entries(columns)) {
-        if (typeof config === 'string') {
-            result[key] = config;
-        }
-        else if (config && typeof config === 'object') {
-            if ('column' in config) {
-                result[key] = config.column;
-            }
-            else if ('from' in config) {
-                result[key] = config.from;
-            }
-            else {
-                result[key] = key; // fallback
-            }
-        }
-        else {
-            result[key] = key; // fallback
-        }
-    }
-    return result;
-}
-/**
- * Converts any unified JSON mapping format to legacy JsonMapping format.
- *
- * This universal converter handles Enhanced, Unified, and Legacy formats, providing
- * a single interface for converting complex mapping configurations to the simple
- * format expected by PostgresJsonQueryBuilder.
- *
- * **Supported Input Formats:**
- * - **Enhanced**: With metadata, type protection, and advanced column configs
- * - **Unified**: Standard format with rootName and rootEntity
- * - **Legacy**: Already compatible format (returned as-is)
- *
- * **Features:**
- * - Automatic format detection
- * - Column configuration simplification
- * - Nested entity handling
- * - Type protection extraction
- *
- * @param input - JSON mapping in any supported format
- * @returns Legacy JsonMapping compatible with PostgresJsonQueryBuilder
- *
- * @throws {Error} When input is null, undefined, or malformed
- *
- * @example
- * ```typescript
- * // Enhanced format input
- * const enhanced = {
- *   rootName: "User",
- *   rootEntity: {
- *     columns: {
- *       id: { column: "u.user_id", type: "number" },
- *       name: { column: "u.user_name", type: "string" }
- *     }
- *   },
- *   metadata: { version: "2.0" }
- * };
- *
- * const legacy = convertToLegacyJsonMapping(enhanced);
- * // Result: Compatible with PostgresJsonQueryBuilder
- * ```
- *
- * @see {@link convertColumnsToLegacy} For column-specific conversion
- * @see {@link extractTypeProtection} For type safety features
- */
-function convertToLegacyJsonMapping(input) {
-    if (!input) {
-        throw new Error('Input mapping is required');
-    }
-    // If it's already in legacy format, return as-is
-    if (input.rootName && input.rootEntity &&
-        typeof input.rootEntity.columns === 'object' &&
-        !input.typeInfo && !input.typeProtection && !input.metadata) {
-        // Check if columns are already in string format
-        const allColumnsAreStrings = Object.values(input.rootEntity.columns).every(col => typeof col === 'string');
-        if (allColumnsAreStrings) {
-            return input;
-        }
-    }
-    // Enhanced format conversion
-    if (input.rootName && input.rootEntity) {
-        return {
-            rootName: input.rootName,
-            rootEntity: {
-                id: input.rootEntity.id || 'root',
-                name: input.rootEntity.name || input.rootName,
-                columns: convertColumnsToLegacy(input.rootEntity.columns || {})
-            },
-            nestedEntities: (input.nestedEntities || []).map((entity) => ({
-                id: entity.id,
-                name: entity.name,
-                parentId: entity.parentId,
-                propertyName: entity.propertyName,
-                relationshipType: entity.relationshipType,
-                columns: convertColumnsToLegacy(entity.columns || {})
-            })),
-            resultFormat: input.resultFormat,
-            emptyResult: input.emptyResult
-        };
-    }
-    throw new Error('Unsupported mapping format');
-}
-/**
- * Converts enhanced mapping to legacy format for backward compatibility.
- */
-function toLegacyMapping(enhanced) {
-    return {
-        rootName: enhanced.rootName,
-        rootEntity: {
-            id: enhanced.rootEntity.id,
-            name: enhanced.rootEntity.name,
-            columns: convertColumnsToLegacy(enhanced.rootEntity.columns)
-        },
-        nestedEntities: enhanced.nestedEntities.map(entity => ({
-            id: entity.id,
-            name: entity.name,
-            parentId: entity.parentId,
-            propertyName: entity.propertyName,
-            relationshipType: entity.relationshipType,
-            columns: convertColumnsToLegacy(entity.columns)
-        })),
-        resultFormat: enhanced.resultFormat,
-        emptyResult: enhanced.emptyResult
-    };
-}
-/**
- * Extracts type protection configuration from enhanced mapping.
- */
-function extractTypeProtection(enhanced) {
-    const protectedStringFields = [];
-    const dateFields = [];
-    const numberFields = [];
-    // Use existing type protection if available
-    if (enhanced.typeProtection) {
-        return {
-            protectedStringFields: enhanced.typeProtection.protectedStringFields || [],
-            dateFields: enhanced.typeProtection.dateFields,
-            numberFields: enhanced.typeProtection.numberFields,
-            customTransforms: enhanced.typeProtection.customTransforms
-        };
-    }
-    // Process root entity
-    for (const [key, config] of Object.entries(enhanced.rootEntity.columns)) {
-        if (typeof config === 'object' && config.type) {
-            const columnName = config.column;
-            switch (config.type) {
-                case 'string':
-                    protectedStringFields.push(columnName);
-                    break;
-                case 'date':
-                    dateFields.push(columnName);
-                    break;
-                case 'number':
-                    numberFields.push(columnName);
-                    break;
-            }
-        }
-    }
-    // Process nested entities
-    for (const entity of enhanced.nestedEntities) {
-        for (const [key, config] of Object.entries(entity.columns)) {
-            if (typeof config === 'object' && config.type) {
-                const columnName = config.column;
-                switch (config.type) {
-                    case 'string':
-                        protectedStringFields.push(columnName);
-                        break;
-                    case 'date':
-                        dateFields.push(columnName);
-                        break;
-                    case 'number':
-                        numberFields.push(columnName);
-                        break;
-                }
-            }
-        }
-    }
-    return {
-        protectedStringFields,
-        dateFields: dateFields.length > 0 ? dateFields : undefined,
-        numberFields: numberFields.length > 0 ? numberFields : undefined,
-        customTransforms: undefined
-    };
-}
-//# sourceMappingURL=EnhancedJsonMapping.js.map

package/dist/transformers/EnhancedJsonMapping.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EnhancedJsonMapping.js","sourceRoot":"","sources":["../../src/transformers/EnhancedJsonMapping.ts"],"names":[],"mappings":"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"}