noormme 1.0.0 → 1.0.2

package/dist/esm/types/index.d.ts

@@ -2,19 +2,22 @@
  * Core type definitions for NOORMME
  */
 export interface NOORMConfig {
-    dialect: 'sqlite';
+    dialect: 'sqlite' | 'postgresql' | 'mysql';
     connection: ConnectionConfig;
     introspection?: IntrospectionConfig;
     cache?: CacheConfig;
     logging?: LoggingConfig;
     performance?: PerformanceConfig;
+    automation?: AutomationConfig;
+    optimization?: OptimizationConfig;
+    sqlite?: SQLiteConfig;
 }
 export interface ConnectionConfig {
-    host: string;
-    port: number;
+    host?: string;
+    port?: number;
     database: string;
-    username: string;
-    password: string;
+    username?: string;
+    password?: string;
     ssl?: boolean | object;
     pool?: PoolConfig;
 }
@@ -42,6 +45,36 @@ export interface PerformanceConfig {
     enableQueryOptimization?: boolean;
     enableBatchLoading?: boolean;
     maxBatchSize?: number;
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+    enableBatchOperations?: boolean;
+    slowQueryThreshold?: number;
+}
+export interface AutomationConfig {
+    enableAutoOptimization?: boolean;
+    enableIndexRecommendations?: boolean;
+    enableQueryAnalysis?: boolean;
+    enableMigrationGeneration?: boolean;
+    enablePerformanceMonitoring?: boolean;
+    enableSchemaWatcher?: boolean;
+}
+export interface OptimizationConfig {
+    enableWALMode?: boolean;
+    enableForeignKeys?: boolean;
+    cacheSize?: number;
+    synchronous?: 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';
+    tempStore?: 'DEFAULT' | 'FILE' | 'MEMORY';
+    autoVacuumMode?: 'NONE' | 'FULL' | 'INCREMENTAL';
+    journalMode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';
+}
+export interface SQLiteConfig {
+    enableWALMode?: boolean;
+    enableForeignKeys?: boolean;
+    cacheSize?: number;
+    synchronous?: 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';
+    tempStore?: 'DEFAULT' | 'FILE' | 'MEMORY';
+    autoVacuumMode?: 'NONE' | 'FULL' | 'INCREMENTAL';
+    journalMode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';
 }
 export interface SchemaInfo {
     tables: TableInfo[];
@@ -60,7 +93,7 @@ export interface ColumnInfo {
     name: string;
     type: string;
     nullable: boolean;
-    defaultValue?: any;
+    defaultValue?: unknown;
     isPrimaryKey: boolean;
     isAutoIncrement: boolean;
     maxLength?: number;
@@ -111,15 +144,16 @@ export interface EntityType {
     selectType: string;
 }
 export interface Repository<T> {
-    findById(id: any): Promise<T | null>;
+    objects: any;
+    findById(id: string | number): Promise<T | null>;
     findAll(): Promise<T[]>;
     create(data: Partial<T>): Promise<T>;
     update(entity: T): Promise<T>;
-    delete(id: any): Promise<boolean>;
-    findWithRelations(id: any, relations: string[]): Promise<T | null>;
+    delete(id: string | number): Promise<boolean>;
+    findWithRelations(id: string | number, relations: string[]): Promise<T | null>;
     loadRelationships(entities: T[], relations: string[]): Promise<void>;
     count(): Promise<number>;
-    exists(id: any): Promise<boolean>;
+    exists(id: string | number): Promise<boolean>;
     paginate(options: {
         page: number;
         limit: number;
@@ -139,17 +173,48 @@ export interface Repository<T> {
             hasPrev: boolean;
         };
     }>;
-    withCount(id: any, relationships: string[]): Promise<T & Record<string, number>>;
-    [key: string]: any;
+    withCount(id: string | number, relationships: string[]): Promise<T & Record<string, number>>;
+    [key: string]: unknown;
 }
 export interface SchemaChange {
     type: 'table_added' | 'table_removed' | 'column_added' | 'column_removed' | 'column_modified';
     table: string;
     column?: string;
-    details?: any;
+    details?: unknown;
 }
 export interface RefreshResult {
     schemaInfo: SchemaInfo;
     changes: SchemaChange[];
     typesRegenerated: boolean;
 }
+export interface ConnectionPoolConfig {
+    min?: number;
+    max?: number;
+    idleTimeout?: number;
+    acquireTimeout?: number;
+}
+export interface QueryCacheConfig {
+    enabled: boolean;
+    ttl: number;
+    maxSize: number;
+}
+export interface BatchConfig {
+    maxBatchSize: number;
+    batchTimeout: number;
+}
+export interface OptimizationRecommendation {
+    type: 'index' | 'query' | 'schema' | 'performance';
+    priority: 'low' | 'medium' | 'high';
+    description: string;
+    suggestion: string;
+    estimatedImpact: string;
+}
+export interface BaseRepository<T> {
+    findAll(): Promise<T[]>;
+    findById(id: string | number): Promise<T | null>;
+    create(data: Partial<T>): Promise<T>;
+    update(id: string | number, data: Partial<T>): Promise<T>;
+    delete(id: string | number): Promise<boolean>;
+    count(): Promise<number>;
+}
+export declare function validateNOORMConfig(config: NOORMConfig): void;

package/dist/esm/types/index.js

@@ -2,4 +2,25 @@
 /**
  * Core type definitions for NOORMME
  */
-export {};
+// Configuration validation function type
+export function validateNOORMConfig(config) {
+    if (!config.dialect) {
+        throw new Error('Dialect is required');
+    }
+    if (!config.connection?.database) {
+        throw new Error('Database path is required');
+    }
+    // Validate dialect-specific requirements
+    if (config.dialect === 'sqlite') {
+        if (!config.connection.database.endsWith('.db') && !config.connection.database.endsWith('.sqlite')) {
+            console.warn('SQLite database path should typically end with .db or .sqlite');
+        }
+    }
+    // Validate performance settings
+    if (config.performance?.maxBatchSize && config.performance.maxBatchSize <= 0) {
+        throw new Error('maxBatchSize must be greater than 0');
+    }
+    if (config.performance?.maxCacheSize && config.performance.maxCacheSize <= 0) {
+        throw new Error('maxCacheSize must be greater than 0');
+    }
+}

package/dist/esm/types/type-generator.d.ts

@@ -41,6 +41,14 @@ export declare class TypeGenerator {
      * Get relationships for a specific table
      */
     private getRelationshipsForTable;
+    /**
+     * Generate relationship interfaces
+     */
+    private generateRelationshipInterfaces;
+    /**
+     * Convert string to camelCase
+     */
+    private toCamelCase;
     /**
      * Get relationship type name
      */

package/dist/esm/types/type-generator.js

@@ -16,7 +16,7 @@ export class TypeGenerator {
         let types = '';
         // Generate entity types for each table
         for (const table of schemaInfo.tables) {
-            const entity = this.generateEntityType(table);
+            const entity = this.generateEntityType(table, schemaInfo.relationships);
             entities.push(entity);
             interfaces += entity.interface + '\n\n';
             types += entity.insertType + '\n\n';
@@ -34,11 +34,11 @@ export class TypeGenerator {
     /**
      * Generate entity type for a table
      */
-    generateEntityType(table) {
+    generateEntityType(table, relationships) {
         const entityName = this.toPascalCase(table.name);
         const tableName = table.name;
         // Generate main entity interface
-        const interfaceCode = this.generateEntityInterface(table, entityName);
+        const interfaceCode = this.generateEntityInterface(table, entityName, relationships);
         // Generate insert type (all columns except auto-generated ones)
         const insertType = this.generateInsertType(table, entityName);
         // Generate update type (all columns optional except primary key)
@@ -57,7 +57,7 @@ export class TypeGenerator {
     /**
      * Generate main entity interface
      */
-    generateEntityInterface(table, entityName) {
+    generateEntityInterface(table, entityName, relationships) {
         let interfaceCode = `export interface ${entityName} {\n`;
         // Add primary key columns first
         for (const column of table.columns) {
@@ -76,8 +76,8 @@ export class TypeGenerator {
             }
         }
         // Add relationship properties
-        const relationships = this.getRelationshipsForTable(table.name);
-        for (const rel of relationships) {
+        const tableRelationships = this.getRelationshipsForTable(table.name, relationships);
+        for (const rel of tableRelationships) {
             const relType = this.getRelationshipType(rel);
             interfaceCode += `  ${rel.name}?: ${relType}\n`;
         }
@@ -187,8 +187,8 @@ export class TypeGenerator {
             'timestamp': 'Date',
             'timestamptz': 'Date',
             'time': 'Date',
-            'json': 'any',
-            'jsonb': 'any',
+            'json': 'Record<string, unknown>',
+            'jsonb': 'Record<string, unknown>',
             'uuid': 'string',
             // MySQL specific types
             'longtext': 'string',
@@ -200,8 +200,11 @@ export class TypeGenerator {
             'double': 'number',
             'bool': 'boolean',
             'datetime': 'Date',
-            // SQLite specific types
+            // SQLite specific types (enhanced)
             'blob': 'Buffer',
+            'int2': 'number',
+            'int8': 'number',
+            'clob': 'string',
             // MSSQL specific types
             'nvarchar': 'string',
             'nchar': 'string',
@@ -212,23 +215,89 @@ export class TypeGenerator {
         };
         // Try exact match first
         if (typeMapping[column.type.toLowerCase()]) {
-            return typeMapping[column.type.toLowerCase()];
+            let mappedType = typeMapping[column.type.toLowerCase()];
+            // Handle nullable columns
+            if (column.nullable && mappedType !== 'unknown') {
+                mappedType = `${mappedType} | null`;
+            }
+            return mappedType;
         }
         // Handle parameterized types (e.g., varchar(255), decimal(10,2))
         const baseType = column.type.toLowerCase().split('(')[0];
         if (typeMapping[baseType]) {
-            return typeMapping[baseType];
+            let mappedType = typeMapping[baseType];
+            // Handle nullable columns
+            if (column.nullable && mappedType !== 'unknown') {
+                mappedType = `${mappedType} | null`;
+            }
+            return mappedType;
         }
-        // Default to any for unknown types
-        return 'any';
+        // Default to unknown for unknown types
+        return column.nullable ? 'unknown | null' : 'unknown';
     }
     /**
      * Get relationships for a specific table
      */
-    getRelationshipsForTable(tableName) {
-        // This would be passed from the schema discovery
-        // For now, return empty array
-        return [];
+    getRelationshipsForTable(tableName, relationships) {
+        return relationships.filter(rel => rel.fromTable === tableName || rel.toTable === tableName);
+    }
+    /**
+     * Generate relationship interfaces
+     */
+    generateRelationshipInterfaces(relationships) {
+        if (relationships.length === 0) {
+            return '';
+        }
+        let relationshipInterfaces = '// Relationship Types\n\n';
+        // Group relationships by type
+        const groupedRelationships = relationships.reduce((acc, rel) => {
+            const key = `${rel.fromTable}_${rel.toTable}_${rel.type}`;
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            acc[key].push(rel);
+            return acc;
+        }, {});
+        for (const [key, rels] of Object.entries(groupedRelationships)) {
+            const rel = rels[0]; // Use first relationship as template
+            const fromEntity = this.toPascalCase(rel.fromTable);
+            const toEntity = this.toPascalCase(rel.toTable);
+            switch (rel.type) {
+                case 'one-to-many':
+                    relationshipInterfaces += `export interface ${fromEntity}With${toEntity}s extends ${fromEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.toTable)}s: ${toEntity}[]\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    relationshipInterfaces += `export interface ${toEntity}With${fromEntity} extends ${toEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.fromTable)}: ${fromEntity}\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    break;
+                case 'many-to-one':
+                    relationshipInterfaces += `export interface ${fromEntity}With${toEntity} extends ${fromEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.toTable)}: ${toEntity}\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    relationshipInterfaces += `export interface ${toEntity}With${fromEntity}s extends ${toEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.fromTable)}s: ${fromEntity}[]\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    break;
+                case 'many-to-many':
+                    relationshipInterfaces += `export interface ${fromEntity}With${toEntity}s extends ${fromEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.toTable)}s: ${toEntity}[]\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    relationshipInterfaces += `export interface ${toEntity}With${fromEntity}s extends ${toEntity} {\n`;
+                    relationshipInterfaces += `  ${this.toCamelCase(rel.fromTable)}s: ${fromEntity}[]\n`;
+                    relationshipInterfaces += `}\n\n`;
+                    break;
+            }
+        }
+        return relationshipInterfaces;
+    }
+    /**
+     * Convert string to camelCase
+     */
+    toCamelCase(str) {
+        return str.replace(/([-_][a-z])/gi, ($1) => {
+            return $1.toUpperCase().replace('-', '').replace('_', '');
+        });
     }
     /**
      * Get relationship type name

package/dist/esm/util/safe-sql-helpers.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Safe SQL helper utilities
+ * Provides secure alternatives to dangerous sql.raw() and sql.lit() methods
+ */
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+/**
+ * Safely creates a SQL ORDER BY direction clause
+ * Only allows 'ASC' or 'DESC'
+ */
+export declare function safeOrderDirection(direction: string): RawBuilder<unknown>;
+/**
+ * Safely creates a SQL LIMIT clause
+ * Validates that the limit is a positive integer
+ */
+export declare function safeLimit(limit: number | string): RawBuilder<unknown>;
+/**
+ * Safely creates a SQL OFFSET clause
+ * Validates that the offset is a non-negative integer
+ */
+export declare function safeOffset(offset: number | string): RawBuilder<unknown>;
+/**
+ * Safely creates SQL keywords from a whitelist
+ * Useful for database-specific syntax that must be hardcoded
+ */
+export declare function safeKeyword(keyword: string, allowedKeywords: string[]): RawBuilder<unknown>;
+/**
+ * Type-safe enum for common SQL keywords
+ */
+export declare const SafeSQLKeywords: {
+    /**
+     * Lock modes for SELECT statements
+     */
+    readonly LockMode: {
+        readonly FOR_UPDATE: "FOR UPDATE";
+        readonly FOR_SHARE: "FOR SHARE";
+        readonly FOR_NO_KEY_UPDATE: "FOR NO KEY UPDATE";
+        readonly FOR_KEY_SHARE: "FOR KEY SHARE";
+    };
+    /**
+     * Join types
+     */
+    readonly JoinType: {
+        readonly INNER: "INNER";
+        readonly LEFT: "LEFT";
+        readonly RIGHT: "RIGHT";
+        readonly FULL: "FULL";
+        readonly CROSS: "CROSS";
+    };
+    /**
+     * Set operations
+     */
+    readonly SetOperation: {
+        readonly UNION: "UNION";
+        readonly UNION_ALL: "UNION ALL";
+        readonly INTERSECT: "INTERSECT";
+        readonly EXCEPT: "EXCEPT";
+    };
+    /**
+     * SQLite-specific pragmas (use with extreme caution)
+     */
+    readonly SafePragma: {
+        readonly OPTIMIZE: "OPTIMIZE";
+        readonly WAL_CHECKPOINT: "WAL_CHECKPOINT";
+    };
+};
+/**
+ * Safely creates a lock mode clause for SELECT statements
+ */
+export declare function safeLockMode(mode: keyof typeof SafeSQLKeywords.LockMode): RawBuilder<unknown>;
+/**
+ * Type-safe ORDER BY builder
+ * Validates column names and direction
+ */
+export interface SafeOrderBy {
+    column: string;
+    direction?: 'ASC' | 'DESC';
+}
+/**
+ * Creates a safe ORDER BY clause from validated columns
+ */
+export declare function safeOrderBy(orderBy: SafeOrderBy[], allowedColumns: string[]): RawBuilder<unknown>;
+/**
+ * Validates and creates a safe boolean value for SQL
+ */
+export declare function safeBoolean(value: boolean | string | number): RawBuilder<boolean>;
+/**
+ * Creates a safe CASE statement with validated conditions
+ */
+export interface SafeCaseWhen<T> {
+    condition: RawBuilder<boolean>;
+    result: T;
+}
+export declare function safeCaseStatement<T>(cases: SafeCaseWhen<T>[], elseResult: T): RawBuilder<T>;
+/**
+ * Example usage and best practices
+ */
+export declare const SafeSQLExamples: {
+    /**
+     * Example: Safe pagination with user input
+     */
+    safePagination: () => {
+        limit: RawBuilder<unknown>;
+        offset: RawBuilder<unknown>;
+    };
+    /**
+     * Example: Safe sorting with user input
+     */
+    safeSorting: (userSortColumn: string, userDirection: string) => {
+        column: RawBuilder<unknown>;
+        direction: RawBuilder<unknown>;
+    };
+    /**
+     * Example: Safe lock mode for transactions
+     */
+    safeTransactionLock: () => RawBuilder<unknown>;
+};
+/**
+ * Helper to validate that a value is from a specific enum
+ */
+export declare function validateEnum<T extends string>(value: string, enumValues: readonly T[], fieldName?: string): T;
+/**
+ * Helper to validate numeric ranges
+ */
+export declare function validateNumericRange(value: number | string, min: number, max: number, fieldName?: string): number;

package/dist/esm/util/safe-sql-helpers.js

@@ -0,0 +1,209 @@
+/// <reference types="./safe-sql-helpers.d.ts" />
+/**
+ * Safe SQL helper utilities
+ * Provides secure alternatives to dangerous sql.raw() and sql.lit() methods
+ */
+import { sql } from '../raw-builder/sql.js';
+/**
+ * Safely creates a SQL ORDER BY direction clause
+ * Only allows 'ASC' or 'DESC'
+ */
+export function safeOrderDirection(direction) {
+    const normalized = direction.toUpperCase().trim();
+    if (normalized !== 'ASC' && normalized !== 'DESC') {
+        throw new Error(`Invalid order direction: "${direction}". Only "ASC" and "DESC" are allowed.`);
+    }
+    return sql.raw(normalized);
+}
+/**
+ * Safely creates a SQL LIMIT clause
+ * Validates that the limit is a positive integer
+ */
+export function safeLimit(limit) {
+    const numLimit = typeof limit === 'string' ? parseInt(limit, 10) : limit;
+    if (!Number.isInteger(numLimit) || numLimit <= 0 || numLimit > 10000) {
+        throw new Error(`Invalid limit: "${limit}". Must be a positive integer between 1 and 10000.`);
+    }
+    return sql.raw(numLimit.toString());
+}
+/**
+ * Safely creates a SQL OFFSET clause
+ * Validates that the offset is a non-negative integer
+ */
+export function safeOffset(offset) {
+    const numOffset = typeof offset === 'string' ? parseInt(offset, 10) : offset;
+    if (!Number.isInteger(numOffset) || numOffset < 0 || numOffset > 1000000) {
+        throw new Error(`Invalid offset: "${offset}". Must be a non-negative integer between 0 and 1000000.`);
+    }
+    return sql.raw(numOffset.toString());
+}
+/**
+ * Safely creates SQL keywords from a whitelist
+ * Useful for database-specific syntax that must be hardcoded
+ */
+export function safeKeyword(keyword, allowedKeywords) {
+    const normalized = keyword.toUpperCase().trim();
+    const allowedNormalized = allowedKeywords.map(k => k.toUpperCase().trim());
+    if (!allowedNormalized.includes(normalized)) {
+        throw new Error(`Invalid keyword: "${keyword}". Allowed keywords: ${allowedKeywords.join(', ')}`);
+    }
+    return sql.raw(normalized);
+}
+/**
+ * Type-safe enum for common SQL keywords
+ */
+export const SafeSQLKeywords = {
+    /**
+     * Lock modes for SELECT statements
+     */
+    LockMode: {
+        FOR_UPDATE: 'FOR UPDATE',
+        FOR_SHARE: 'FOR SHARE',
+        FOR_NO_KEY_UPDATE: 'FOR NO KEY UPDATE',
+        FOR_KEY_SHARE: 'FOR KEY SHARE',
+    },
+    /**
+     * Join types
+     */
+    JoinType: {
+        INNER: 'INNER',
+        LEFT: 'LEFT',
+        RIGHT: 'RIGHT',
+        FULL: 'FULL',
+        CROSS: 'CROSS',
+    },
+    /**
+     * Set operations
+     */
+    SetOperation: {
+        UNION: 'UNION',
+        UNION_ALL: 'UNION ALL',
+        INTERSECT: 'INTERSECT',
+        EXCEPT: 'EXCEPT',
+    },
+    /**
+     * SQLite-specific pragmas (use with extreme caution)
+     */
+    SafePragma: {
+        OPTIMIZE: 'OPTIMIZE',
+        WAL_CHECKPOINT: 'WAL_CHECKPOINT',
+    },
+};
+/**
+ * Safely creates a lock mode clause for SELECT statements
+ */
+export function safeLockMode(mode) {
+    return sql.raw(SafeSQLKeywords.LockMode[mode]);
+}
+/**
+ * Creates a safe ORDER BY clause from validated columns
+ */
+export function safeOrderBy(orderBy, allowedColumns) {
+    if (orderBy.length === 0) {
+        throw new Error('At least one order by clause is required');
+    }
+    const clauses = orderBy.map(({ column, direction = 'ASC' }) => {
+        if (!allowedColumns.includes(column)) {
+            throw new Error(`Invalid order by column: "${column}". Allowed columns: ${allowedColumns.join(', ')}`);
+        }
+        const dir = direction.toUpperCase();
+        if (dir !== 'ASC' && dir !== 'DESC') {
+            throw new Error(`Invalid direction: "${direction}". Must be ASC or DESC`);
+        }
+        return `${column} ${dir}`;
+    });
+    return sql.raw(clauses.join(', '));
+}
+/**
+ * Validates and creates a safe boolean value for SQL
+ */
+export function safeBoolean(value) {
+    let boolValue;
+    if (typeof value === 'boolean') {
+        boolValue = value;
+    }
+    else if (value === 'true' || value === '1' || value === 1) {
+        boolValue = true;
+    }
+    else if (value === 'false' || value === '0' || value === 0) {
+        boolValue = false;
+    }
+    else {
+        throw new Error(`Invalid boolean value: "${value}". Must be true, false, 1, 0, "true", or "false"`);
+    }
+    // Use parameterized value instead of raw SQL
+    return sql `${boolValue}`;
+}
+export function safeCaseStatement(cases, elseResult) {
+    if (cases.length === 0) {
+        throw new Error('At least one WHEN clause is required');
+    }
+    // Note: This function needs to be refactored to not use sql.raw()
+    // For now, we construct the CASE statement carefully
+    const whenClauses = cases
+        .map((c, i) => {
+        // Conditions must be RawBuilder instances to ensure they're safe
+        const conditionSql = c.condition.toOperationNode();
+        return `WHEN ${conditionSql} THEN ${c.result}`;
+    })
+        .join(' ');
+    return sql.raw(`CASE ${whenClauses} ELSE ${elseResult} END`);
+}
+/**
+ * Example usage and best practices
+ */
+export const SafeSQLExamples = {
+    /**
+     * Example: Safe pagination with user input
+     */
+    safePagination: () => {
+        const userPage = '2'; // From request
+        const userLimit = '10'; // From request
+        const offset = (parseInt(userPage) - 1) * parseInt(userLimit);
+        return {
+            limit: safeLimit(userLimit),
+            offset: safeOffset(offset),
+        };
+    },
+    /**
+     * Example: Safe sorting with user input
+     */
+    safeSorting: (userSortColumn, userDirection) => {
+        const allowedColumns = ['name', 'email', 'created_at', 'updated_at'];
+        if (!allowedColumns.includes(userSortColumn)) {
+            throw new Error('Invalid sort column');
+        }
+        return {
+            column: sql.ref(userSortColumn),
+            direction: safeOrderDirection(userDirection),
+        };
+    },
+    /**
+     * Example: Safe lock mode for transactions
+     */
+    safeTransactionLock: () => {
+        return safeLockMode('FOR_UPDATE');
+    },
+};
+/**
+ * Helper to validate that a value is from a specific enum
+ */
+export function validateEnum(value, enumValues, fieldName = 'value') {
+    if (!enumValues.includes(value)) {
+        throw new Error(`Invalid ${fieldName}: "${value}". Allowed values: ${enumValues.join(', ')}`);
+    }
+    return value;
+}
+/**
+ * Helper to validate numeric ranges
+ */
+export function validateNumericRange(value, min, max, fieldName = 'value') {
+    const num = typeof value === 'string' ? parseFloat(value) : value;
+    if (isNaN(num)) {
+        throw new Error(`Invalid ${fieldName}: "${value}". Must be a number`);
+    }
+    if (num < min || num > max) {
+        throw new Error(`Invalid ${fieldName}: ${num}. Must be between ${min} and ${max}`);
+    }
+    return num;
+}