noormme 1.0.0 → 1.0.2

package/dist/cjs/errors/NoormError.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionError = exports.ValidationError = exports.RelationshipNotFoundError = exports.ColumnNotFoundError = exports.TableNotFoundError = exports.NoormError = void 0;
+exports.TypeGenerationError = exports.MigrationError = exports.SchemaDiscoveryError = exports.QueryExecutionError = exports.RelationshipNotFoundError = exports.ValidationError = exports.DatabaseInitializationError = exports.ConnectionError = exports.ColumnNotFoundError = exports.TableNotFoundError = exports.NoormError = void 0;
 /**
  * Enhanced error class with context-aware information
  */
@@ -55,31 +55,105 @@ exports.NoormError = NoormError;
  */
 class TableNotFoundError extends NoormError {
     constructor(tableName, availableTables = []) {
-        super(`Table '${tableName}' not found in schema`, {
+        const message = availableTables.length > 0
+            ? `Table '${tableName}' not found. Available tables: ${availableTables.join(', ')}`
+            : `Table '${tableName}' not found. Check your table name or run schema discovery.`;
+        super(message, {
             table: tableName,
-            operation: 'schema_lookup',
+            operation: 'table_lookup',
             suggestion: availableTables.length > 0
                 ? `Available tables: ${availableTables.join(', ')}`
-                : 'Check your database connection and schema',
+                : 'Check your table name or run schema discovery',
             availableOptions: availableTables
         });
+        this.name = 'TableNotFoundError';
     }
 }
 exports.TableNotFoundError = TableNotFoundError;
 class ColumnNotFoundError extends NoormError {
     constructor(columnName, tableName, availableColumns = []) {
-        const similar = findSimilarColumns(availableColumns, columnName);
-        super(`Column '${columnName}' not found on table '${tableName}'`, {
+        // Find similar column names for better suggestions
+        const similarColumns = availableColumns.filter(col => col.toLowerCase().includes(columnName.toLowerCase()) ||
+            columnName.toLowerCase().includes(col.toLowerCase()) ||
+            ColumnNotFoundError.calculateSimilarity(col, columnName) > 0.6);
+        let suggestion = 'Check your column name or run schema discovery';
+        if (availableColumns.length > 0) {
+            suggestion = `Available columns: ${availableColumns.join(', ')}`;
+            if (similarColumns.length > 0) {
+                suggestion += `\n  → Did you mean '${similarColumns[0]}'? (${Math.round(ColumnNotFoundError.calculateSimilarity(similarColumns[0], columnName) * 100)}% similarity)`;
+            }
+        }
+        super(`Column '${columnName}' not found in table '${tableName}'`, {
             table: tableName,
             operation: 'column_lookup',
-            suggestion: similar.length > 0
-                ? `Did you mean '${similar[0]}'?`
-                : `Available columns: ${availableColumns.join(', ')}`,
+            suggestion: suggestion,
             availableOptions: availableColumns
         });
+        this.name = 'ColumnNotFoundError';
+    }
+    static calculateSimilarity(str1, str2) {
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 1.0;
+        const editDistance = ColumnNotFoundError.levenshteinDistance(longer, shorter);
+        return (longer.length - editDistance) / longer.length;
+    }
+    static levenshteinDistance(str1, str2) {
+        const matrix = [];
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
     }
 }
 exports.ColumnNotFoundError = ColumnNotFoundError;
+class ConnectionError extends NoormError {
+    constructor(message, originalError) {
+        super(message, {
+            operation: 'connection',
+            suggestion: 'Check your database connection settings and ensure the database server is running',
+            originalError
+        });
+        this.name = 'ConnectionError';
+    }
+}
+exports.ConnectionError = ConnectionError;
+class DatabaseInitializationError extends NoormError {
+    constructor(originalError, databasePath) {
+        super(`Failed to initialize database at ${databasePath}: ${originalError.message}`, {
+            operation: 'initialization',
+            suggestion: 'Check database permissions, path validity, and connection settings',
+            originalError
+        });
+        this.name = 'DatabaseInitializationError';
+    }
+}
+exports.DatabaseInitializationError = DatabaseInitializationError;
+class ValidationError extends NoormError {
+    constructor(message, validationIssues = []) {
+        super(message, {
+            operation: 'validation',
+            suggestion: 'Check your input data and ensure it matches the expected schema',
+            availableOptions: validationIssues
+        });
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
 class RelationshipNotFoundError extends NoormError {
     constructor(relationshipName, tableName, availableRelationships = []) {
         super(`Relationship '${relationshipName}' not found on table '${tableName}'`, {
@@ -90,29 +164,76 @@ class RelationshipNotFoundError extends NoormError {
                 : 'No relationships defined for this table',
             availableOptions: availableRelationships
         });
+        this.name = 'RelationshipNotFoundError';
     }
 }
 exports.RelationshipNotFoundError = RelationshipNotFoundError;
-class ValidationError extends NoormError {
-    constructor(message, field, tableName) {
-        super(message, {
+class QueryExecutionError extends NoormError {
+    constructor(query, originalError, context) {
+        super(`Query execution failed: ${originalError.message}`, {
+            operation: context?.operation || 'query_execution',
+            table: context?.table,
+            suggestion: QueryExecutionError.getQuerySuggestion(query, originalError),
+            originalError
+        });
+        this.name = 'QueryExecutionError';
+    }
+    static getQuerySuggestion(query, error) {
+        const errorMsg = error.message.toLowerCase();
+        if (errorMsg.includes('syntax error')) {
+            return 'Check your SQL syntax. Common issues: missing commas, unclosed quotes, or invalid keywords.';
+        }
+        if (errorMsg.includes('no such table')) {
+            return 'Table does not exist. Check table name or run schema discovery to see available tables.';
+        }
+        if (errorMsg.includes('no such column')) {
+            return 'Column does not exist. Check column name or run schema discovery to see available columns.';
+        }
+        if (errorMsg.includes('constraint failed')) {
+            return 'Data constraint violation. Check for required fields, unique constraints, or foreign key references.';
+        }
+        if (errorMsg.includes('database is locked')) {
+            return 'Database is locked. Enable WAL mode for better concurrency: optimization: { enableWALMode: true }';
+        }
+        return 'Review your query and check the original error message for specific details.';
+    }
+}
+exports.QueryExecutionError = QueryExecutionError;
+class SchemaDiscoveryError extends NoormError {
+    constructor(tableName, originalError) {
+        super(`Failed to discover schema for table '${tableName}': ${originalError.message}`, {
             table: tableName,
-            operation: 'validation',
-            suggestion: field ? `Check the value for field '${field}'` : 'Check your input data'
+            operation: 'schema_discovery',
+            suggestion: 'Check table permissions, table name validity, or database connection',
+            originalError
         });
+        this.name = 'SchemaDiscoveryError';
     }
 }
-exports.ValidationError = ValidationError;
-class ConnectionError extends NoormError {
-    constructor(message, originalError) {
-        super(`Database connection failed: ${message}`, {
-            operation: 'connection',
-            suggestion: 'Check your database connection string and ensure the database is running',
+exports.SchemaDiscoveryError = SchemaDiscoveryError;
+class MigrationError extends NoormError {
+    constructor(migrationName, originalError, context) {
+        super(`Migration '${migrationName}' failed${context?.step ? ` at step: ${context.step}` : ''}: ${originalError.message}`, {
+            operation: 'migration',
+            suggestion: 'Check migration SQL syntax, database permissions, or rollback the migration',
             originalError
         });
+        this.name = 'MigrationError';
     }
 }
-exports.ConnectionError = ConnectionError;
+exports.MigrationError = MigrationError;
+class TypeGenerationError extends NoormError {
+    constructor(tableName, originalError) {
+        super(`Failed to generate types for table '${tableName}': ${originalError.message}`, {
+            table: tableName,
+            operation: 'type_generation',
+            suggestion: 'Check table schema, column types, or custom type mappings configuration',
+            originalError
+        });
+        this.name = 'TypeGenerationError';
+    }
+}
+exports.TypeGenerationError = TypeGenerationError;
 /**
  * Helper function to find similar column names using simple string similarity
  */

package/dist/cjs/logging/logger.d.ts

@@ -10,11 +10,16 @@ interface QueryLog {
  * Logger for NOORMME
  */
 export declare class Logger {
-    private config;
     private queryLogs;
     private queryCount;
     private totalQueryTime;
-    constructor(config?: LoggingConfig);
+    private config;
+    private namespace?;
+    constructor(configOrNamespace?: LoggingConfig | string);
+    /**
+     * Format namespace prefix
+     */
+    private getPrefix;
     /**
      * Log debug message
      */

package/dist/cjs/logging/logger.js

@@ -5,19 +5,33 @@ exports.Logger = void 0;
  * Logger for NOORMME
  */
 class Logger {
-    config;
     queryLogs = [];
     queryCount = 0;
     totalQueryTime = 0;
-    constructor(config = {}) {
-        this.config = config;
+    config;
+    namespace;
+    constructor(configOrNamespace) {
+        if (typeof configOrNamespace === 'string') {
+            this.namespace = configOrNamespace;
+            this.config = { enabled: true, level: 'info' };
+        }
+        else {
+            this.config = configOrNamespace || {};
+        }
+    }
+    /**
+     * Format namespace prefix
+     */
+    getPrefix(level) {
+        const prefix = this.namespace ? `[${this.namespace}]` : '';
+        return `[NOORMME ${level.toUpperCase()}]${prefix}`;
     }
     /**
      * Log debug message
      */
     debug(message, ...args) {
         if (this.shouldLog('debug')) {
-            console.debug(`[NOORMME DEBUG] ${message}`, ...args);
+            console.debug(`${this.getPrefix('debug')} ${message}`, ...args);
         }
     }
     /**
@@ -25,7 +39,7 @@ class Logger {
      */
     info(message, ...args) {
         if (this.shouldLog('info')) {
-            console.info(`[NOORMME INFO] ${message}`, ...args);
+            console.info(`${this.getPrefix('info')} ${message}`, ...args);
         }
     }
     /**
@@ -33,7 +47,7 @@ class Logger {
      */
     warn(message, ...args) {
         if (this.shouldLog('warn')) {
-            console.warn(`[NOORMME WARN] ${message}`, ...args);
+            console.warn(`${this.getPrefix('warn')} ${message}`, ...args);
         }
     }
     /**
@@ -41,7 +55,7 @@ class Logger {
      */
     error(message, ...args) {
         if (this.shouldLog('error')) {
-            console.error(`[NOORMME ERROR] ${message}`, ...args);
+            console.error(`${this.getPrefix('error')} ${message}`, ...args);
         }
     }
     /**

package/dist/cjs/noormme.d.ts

@@ -1,7 +1,6 @@
-import type { Kysely } from './kysely.js';
-import { NOORMConfig, SchemaInfo, Repository } from './types/index.js';
+import { Kysely } from './kysely.js';
+import { NOORMConfig, SchemaInfo, Repository, SchemaChange } from './types/index.js';
 import { WatchOptions } from './watch/schema-watcher.js';
-import { QueryAnalyzerOptions } from './performance/query-analyzer.js';
 /**
  * NOORMME - No ORM, just magic!
  * Zero-configuration pseudo-ORM that works with any existing database
@@ -17,12 +16,13 @@ export declare class NOORMME {
     private cacheManager;
     private logger;
     private schemaWatcher;
-    private queryAnalyzer;
+    private metricsCollector;
     private sqliteAutoOptimizer;
     private sqliteAutoIndexer;
     private initialized;
     private repositories;
     private instanceId;
+    private schemaChangeCallbacks;
     constructor(configOrConnectionString?: NOORMConfig | string);
     /**
      * Initialize NOORMME - discovers schema and generates types
@@ -81,7 +81,7 @@ export declare class NOORMME {
     /**
      * Start monitoring schema changes in development mode
      */
-    startSchemaWatching(options?: WatchOptions): void;
+    startSchemaWatching(options?: WatchOptions): Promise<void>;
     /**
      * Stop monitoring schema changes
      */
@@ -89,7 +89,7 @@ export declare class NOORMME {
     /**
      * Register callback for schema changes
      */
-    onSchemaChange(callback: (changes: any[]) => void): void;
+    onSchemaChange(callback: (changes: SchemaChange[]) => void): void;
     /**
      * Get performance metrics
      */
@@ -102,7 +102,7 @@ export declare class NOORMME {
     /**
      * Enable query performance monitoring
      */
-    enablePerformanceMonitoring(options?: QueryAnalyzerOptions): void;
+    enablePerformanceMonitoring(options?: any): void;
     /**
      * Disable query performance monitoring
      */
@@ -111,6 +111,10 @@ export declare class NOORMME {
      * Close database connections
      */
     close(): Promise<void>;
+    /**
+     * Alias for close() - for backward compatibility
+     */
+    destroy(): Promise<void>;
     /**
      * Get the underlying Kysely instance for custom queries
      */
@@ -122,7 +126,7 @@ export declare class NOORMME {
     /**
      * Execute raw SQL
      */
-    execute(sql: string, parameters?: any[]): Promise<any>;
+    execute(sqlString: string, parameters?: unknown[]): Promise<unknown>;
     private mergeConfig;
     /**
      * Parse connection string into NOORMConfig