noormme 1.0.0 → 1.0.2

package/dist/cjs/testing/test-utils.js

@@ -23,7 +23,7 @@ async function createTestDatabase(config = {}) {
                     password: ''
                 },
                 logging: {
-                    enabled: false // Disable logging in tests by default
+                    enabled: process.env.TEST_DEBUG === 'true' // Enable with TEST_DEBUG=true
                 }
             };
             break;
@@ -95,14 +95,62 @@ async function setupTestSchema(db) {
         .column('user_id')
         .execute();
     // Initialize NOORMME to discover the schema
-    await db.initialize();
+    // Temporarily enable warnings to see discovery errors
+    const originalWarn = console.warn;
+    let discoveryError = null;
+    console.warn = (...args) => {
+        if (args[0]?.includes?.('Schema discovery failed')) {
+            discoveryError = args;
+            console.error('[DISCOVERY ERROR]', ...args);
+        }
+        originalWarn(...args);
+    };
+    try {
+        await db.initialize();
+    }
+    catch (error) {
+        console.error('NOORMME initialization error:', error);
+        throw new Error(`Test setup failed during initialization: ${error}`);
+    }
+    finally {
+        console.warn = originalWarn;
+    }
+    // Verify schema was discovered
+    const schemaInfo = await db.getSchemaInfo();
+    if (schemaInfo.tables.length === 0) {
+        // Try to manually check if tables exist
+        let actualTables = [];
+        try {
+            actualTables = await kysely.selectFrom('sqlite_master')
+                .select(['name', 'type'])
+                .where('type', '=', 'table')
+                .where('name', 'not like', 'sqlite_%')
+                .execute();
+        }
+        catch (e) {
+            console.error('[DEBUG] Failed to query sqlite_master:', e);
+        }
+        throw new Error(`Test setup failed: Schema discovery returned no tables but ${actualTables.length} tables exist in database (${actualTables.map((t) => t.name).join(', ')}). ` +
+            `Discovery error: ${discoveryError ? discoveryError.join(' ') : 'Unknown'}`);
+    }
+    // Verify expected tables exist
+    const tableNames = schemaInfo.tables.map(t => t.name);
+    const expectedTables = ['users', 'posts', 'comments'];
+    const missingTables = expectedTables.filter(t => !tableNames.includes(t));
+    if (missingTables.length > 0) {
+        throw new Error(`Test setup failed: Missing tables: ${missingTables.join(', ')}. ` +
+            `Found tables: ${tableNames.join(', ')}. ` +
+            `Expected: ${expectedTables.join(', ')}`);
+    }
 }
 /**
  * Clean up test database
  */
 async function cleanupTestDatabase(db) {
-    const kysely = db.getKysely();
+    if (!db)
+        return;
     try {
+        const kysely = db.getKysely();
         // Drop tables in reverse order to handle foreign keys
         await kysely.schema.dropTable('comments').ifExists().execute();
         await kysely.schema.dropTable('posts').ifExists().execute();
@@ -111,16 +159,29 @@ async function cleanupTestDatabase(db) {
     catch (error) {
         // Ignore errors during cleanup
     }
-    await db.close();
+    try {
+        await db.close();
+    }
+    catch (error) {
+        // Ignore close errors
+    }
 }
 /**
  * Test data factory
  */
 class TestDataFactory {
     db;
+    static emailCounter = 0;
     constructor(db) {
         this.db = db;
     }
+    /**
+     * Generate a unique email address
+     */
+    generateUniqueEmail() {
+        TestDataFactory.emailCounter++;
+        return `test${Date.now()}_${TestDataFactory.emailCounter}_${Math.random().toString(36).substring(7)}@example.com`;
+    }
     /**
      * Create a test user
      */
@@ -128,7 +189,7 @@ class TestDataFactory {
         const userRepo = this.db.getRepository('users');
         const userData = {
             name: 'Test User',
-            email: `test${Date.now()}@example.com`,
+            email: this.generateUniqueEmail(),
             age: 25,
             active: true,
             ...overrides
@@ -143,7 +204,6 @@ class TestDataFactory {
         for (let i = 0; i < count; i++) {
             const user = await this.createUser({
                 name: `Test User ${i + 1}`,
-                email: `test${Date.now()}_${i}@example.com`,
                 ...overrides
             });
             users.push(user);

package/dist/cjs/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/cjs/types/index.js

@@ -3,3 +3,26 @@
  * Core type definitions for NOORMME
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNOORMConfig = validateNOORMConfig;
+// Configuration validation function type
+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/cjs/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/cjs/types/type-generator.js

@@ -18,7 +18,7 @@ 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';
@@ -36,11 +36,11 @@ 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)
@@ -59,7 +59,7 @@ 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) {
@@ -78,8 +78,8 @@ 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`;
         }
@@ -189,8 +189,8 @@ 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',
@@ -202,8 +202,11 @@ 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',
@@ -214,23 +217,89 @@ 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/cjs/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;