noormme 1.0.0 → 1.0.2

package/dist/esm/edge-runtime/edge-config.d.ts

@@ -0,0 +1,125 @@
+import { NOORMConfig } from '../types';
+/**
+ * Edge Runtime compatible configuration for NOORMME
+ *
+ * Edge Runtime has specific limitations:
+ * - No file system access (use in-memory database)
+ * - No WAL mode support
+ * - Limited memory and CPU resources
+ * - No persistent storage
+ * - Minimal logging capabilities
+ */
+export declare function getEdgeRuntimeConfig(): NOORMConfig;
+/**
+ * Check if current environment is Edge Runtime
+ */
+export declare function isEdgeRuntime(): boolean;
+/**
+ * Get appropriate configuration based on runtime environment
+ */
+export declare function getRuntimeConfig(): NOORMConfig;
+/**
+ * Edge Runtime compatible database operations
+ */
+export declare class EdgeRuntimeDB {
+    private config;
+    constructor(config?: NOORMConfig);
+    /**
+     * Create a new database instance optimized for Edge Runtime
+     */
+    createInstance(): Promise<import("../noormme").NOORMME>;
+    /**
+     * Execute a simple query in Edge Runtime
+     */
+    executeQuery(query: string, params?: any[]): Promise<unknown>;
+    /**
+     * Perform a read operation in Edge Runtime
+     */
+    read(table: string, conditions?: Record<string, any>): Promise<unknown[]>;
+    /**
+     * Perform a write operation in Edge Runtime
+     */
+    write(table: string, data: Record<string, any>): Promise<unknown>;
+}
+/**
+ * Edge Runtime compatible middleware
+ */
+export declare function createEdgeMiddleware(): {
+    /**
+     * Handle database operations in Edge Runtime
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * Handle API requests in Edge Runtime
+     */
+    handleAPIRequest(request: Request, edgeDB: EdgeRuntimeDB): Promise<Response>;
+};
+/**
+ * Edge Runtime compatible error handler
+ */
+export declare function createEdgeErrorHandler(): {
+    /**
+     * Handle errors in Edge Runtime
+     */
+    handleError(error: Error, context?: string): Response;
+};
+/**
+ * Edge Runtime performance monitoring
+ */
+export declare class EdgeRuntimeMonitor {
+    private metrics;
+    /**
+     * Record a performance metric
+     */
+    recordMetric(name: string, value: number): void;
+    /**
+     * Get performance metrics
+     */
+    getMetrics(): {
+        [k: string]: number;
+    };
+    /**
+     * Monitor a function execution
+     */
+    monitor<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get performance report
+     */
+    getReport(): {
+        totalOperations: number;
+        metrics: {
+            [k: string]: number;
+        };
+        timestamp: string;
+        runtime: string;
+    };
+}
+/**
+ * Edge Runtime utilities
+ */
+export declare const EdgeRuntimeUtils: {
+    /**
+     * Check if running in Edge Runtime
+     */
+    isEdgeRuntime: typeof isEdgeRuntime;
+    /**
+     * Get Edge Runtime configuration
+     */
+    getConfig: typeof getEdgeRuntimeConfig;
+    /**
+     * Create Edge Runtime database instance
+     */
+    createDB: () => EdgeRuntimeDB;
+    /**
+     * Create Edge Runtime middleware
+     */
+    createMiddleware: typeof createEdgeMiddleware;
+    /**
+     * Create Edge Runtime error handler
+     */
+    createErrorHandler: typeof createEdgeErrorHandler;
+    /**
+     * Create Edge Runtime monitor
+     */
+    createMonitor: () => EdgeRuntimeMonitor;
+};

package/dist/esm/edge-runtime/edge-config.js

@@ -0,0 +1,281 @@
+/// <reference types="./edge-config.d.ts" />
+/**
+ * Edge Runtime compatible configuration for NOORMME
+ *
+ * Edge Runtime has specific limitations:
+ * - No file system access (use in-memory database)
+ * - No WAL mode support
+ * - Limited memory and CPU resources
+ * - No persistent storage
+ * - Minimal logging capabilities
+ */
+export function getEdgeRuntimeConfig() {
+    return {
+        dialect: 'sqlite',
+        connection: {
+            database: ':memory:'
+        },
+        optimization: {
+            enableWALMode: false, // WAL mode not supported in Edge Runtime
+            enableForeignKeys: true,
+            cacheSize: -2000, // 2MB cache (smaller for Edge Runtime)
+            synchronous: 'NORMAL',
+            tempStore: 'MEMORY' // Use memory for temporary storage
+        },
+        logging: {
+            level: 'error', // Minimal logging for performance
+            enabled: false // Disable logging in Edge Runtime
+        }
+    };
+}
+/**
+ * Check if current environment is Edge Runtime
+ */
+export function isEdgeRuntime() {
+    return ((typeof globalThis !== 'undefined' && 'EdgeRuntime' in globalThis) ||
+        (typeof process !== 'undefined' && process.env.NEXT_RUNTIME === 'edge'));
+}
+/**
+ * Get appropriate configuration based on runtime environment
+ */
+export function getRuntimeConfig() {
+    if (isEdgeRuntime()) {
+        return getEdgeRuntimeConfig();
+    }
+    // Default configuration for Node.js runtime
+    return {
+        dialect: 'sqlite',
+        connection: {
+            database: process.env.DATABASE_URL || './app.db'
+        },
+        optimization: {
+            enableWALMode: true,
+            enableForeignKeys: true,
+            cacheSize: -64000, // 64MB cache
+            synchronous: 'NORMAL',
+            tempStore: 'DEFAULT'
+        },
+        logging: {
+            level: process.env.NODE_ENV === 'development' ? 'info' : 'error',
+            enabled: true
+        }
+    };
+}
+/**
+ * Edge Runtime compatible database operations
+ */
+export class EdgeRuntimeDB {
+    config;
+    constructor(config) {
+        this.config = config || getEdgeRuntimeConfig();
+    }
+    /**
+     * Create a new database instance optimized for Edge Runtime
+     */
+    async createInstance() {
+        const { NOORMME } = await import('../noormme');
+        return new NOORMME(this.config);
+    }
+    /**
+     * Execute a simple query in Edge Runtime
+     */
+    async executeQuery(query, params) {
+        const db = await this.createInstance();
+        await db.initialize();
+        try {
+            const result = await db.execute(query, params);
+            return result;
+        }
+        finally {
+            await db.close();
+        }
+    }
+    /**
+     * Perform a read operation in Edge Runtime
+     */
+    async read(table, conditions = {}) {
+        const db = await this.createInstance();
+        await db.initialize();
+        try {
+            const repo = db.getRepository(table);
+            return await repo.findAll();
+        }
+        finally {
+            await db.close();
+        }
+    }
+    /**
+     * Perform a write operation in Edge Runtime
+     */
+    async write(table, data) {
+        const db = await this.createInstance();
+        await db.initialize();
+        try {
+            const repo = db.getRepository(table);
+            return await repo.create(data);
+        }
+        finally {
+            await db.close();
+        }
+    }
+}
+/**
+ * Edge Runtime compatible middleware
+ */
+export function createEdgeMiddleware() {
+    return {
+        /**
+         * Handle database operations in Edge Runtime
+         */
+        async handleRequest(request) {
+            const edgeDB = new EdgeRuntimeDB();
+            try {
+                const url = new URL(request.url);
+                const pathname = url.pathname;
+                if (pathname.startsWith('/api/')) {
+                    return await this.handleAPIRequest(request, edgeDB);
+                }
+                return new Response('Not found', { status: 404 });
+            }
+            catch (error) {
+                console.error('Edge Runtime error:', error);
+                return new Response('Internal Server Error', { status: 500 });
+            }
+        },
+        /**
+         * Handle API requests in Edge Runtime
+         */
+        async handleAPIRequest(request, edgeDB) {
+            const url = new URL(request.url);
+            const method = request.method;
+            const pathname = url.pathname;
+            // Simple routing for Edge Runtime
+            if (pathname === '/api/health') {
+                return new Response(JSON.stringify({
+                    status: 'healthy',
+                    runtime: 'edge',
+                    timestamp: new Date().toISOString()
+                }), {
+                    headers: { 'Content-Type': 'application/json' }
+                });
+            }
+            if (pathname === '/api/users' && method === 'GET') {
+                const users = await edgeDB.read('users');
+                return new Response(JSON.stringify(users), {
+                    headers: { 'Content-Type': 'application/json' }
+                });
+            }
+            if (pathname === '/api/users' && method === 'POST') {
+                const data = await request.json();
+                const user = await edgeDB.write('users', data);
+                return new Response(JSON.stringify(user), {
+                    status: 201,
+                    headers: { 'Content-Type': 'application/json' }
+                });
+            }
+            return new Response('Not found', { status: 404 });
+        }
+    };
+}
+/**
+ * Edge Runtime compatible error handler
+ */
+export function createEdgeErrorHandler() {
+    return {
+        /**
+         * Handle errors in Edge Runtime
+         */
+        handleError(error, context) {
+            // Log error (minimal logging in Edge Runtime)
+            console.error(`Edge Runtime Error${context ? ` in ${context}` : ''}:`, error.message);
+            // Return appropriate response
+            return new Response(JSON.stringify({
+                error: 'Internal Server Error',
+                message: process.env.NODE_ENV === 'development' ? error.message : 'Something went wrong',
+                timestamp: new Date().toISOString()
+            }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' }
+            });
+        }
+    };
+}
+/**
+ * Edge Runtime performance monitoring
+ */
+export class EdgeRuntimeMonitor {
+    metrics = new Map();
+    /**
+     * Record a performance metric
+     */
+    recordMetric(name, value) {
+        this.metrics.set(name, value);
+    }
+    /**
+     * Get performance metrics
+     */
+    getMetrics() {
+        return Object.fromEntries(this.metrics);
+    }
+    /**
+     * Monitor a function execution
+     */
+    async monitor(name, fn) {
+        const start = performance.now();
+        try {
+            const result = await fn();
+            const duration = performance.now() - start;
+            this.recordMetric(`${name}_duration`, duration);
+            this.recordMetric(`${name}_success`, 1);
+            return result;
+        }
+        catch (error) {
+            const duration = performance.now() - start;
+            this.recordMetric(`${name}_duration`, duration);
+            this.recordMetric(`${name}_error`, 1);
+            throw error;
+        }
+    }
+    /**
+     * Get performance report
+     */
+    getReport() {
+        const metrics = this.getMetrics();
+        const totalOperations = Object.keys(metrics).length;
+        return {
+            totalOperations,
+            metrics,
+            timestamp: new Date().toISOString(),
+            runtime: 'edge'
+        };
+    }
+}
+/**
+ * Edge Runtime utilities
+ */
+export const EdgeRuntimeUtils = {
+    /**
+     * Check if running in Edge Runtime
+     */
+    isEdgeRuntime,
+    /**
+     * Get Edge Runtime configuration
+     */
+    getConfig: getEdgeRuntimeConfig,
+    /**
+     * Create Edge Runtime database instance
+     */
+    createDB: () => new EdgeRuntimeDB(),
+    /**
+     * Create Edge Runtime middleware
+     */
+    createMiddleware: createEdgeMiddleware,
+    /**
+     * Create Edge Runtime error handler
+     */
+    createErrorHandler: createEdgeErrorHandler,
+    /**
+     * Create Edge Runtime monitor
+     */
+    createMonitor: () => new EdgeRuntimeMonitor()
+};

package/dist/esm/errors/NoormError.d.ts

@@ -44,13 +44,36 @@ export declare class TableNotFoundError extends NoormError {
 }
 export declare class ColumnNotFoundError extends NoormError {
     constructor(columnName: string, tableName: string, availableColumns?: string[]);
+    private static calculateSimilarity;
+    private static levenshteinDistance;
+}
+export declare class ConnectionError extends NoormError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class DatabaseInitializationError extends NoormError {
+    constructor(originalError: Error, databasePath: string);
+}
+export declare class ValidationError extends NoormError {
+    constructor(message: string, validationIssues?: string[]);
 }
 export declare class RelationshipNotFoundError extends NoormError {
     constructor(relationshipName: string, tableName: string, availableRelationships?: string[]);
 }
-export declare class ValidationError extends NoormError {
-    constructor(message: string, field?: string, tableName?: string);
+export declare class QueryExecutionError extends NoormError {
+    constructor(query: string, originalError: Error, context?: {
+        table?: string;
+        operation?: string;
+    });
+    private static getQuerySuggestion;
 }
-export declare class ConnectionError extends NoormError {
-    constructor(message: string, originalError?: Error);
+export declare class SchemaDiscoveryError extends NoormError {
+    constructor(tableName: string, originalError: Error);
+}
+export declare class MigrationError extends NoormError {
+    constructor(migrationName: string, originalError: Error, context?: {
+        step?: string;
+    });
+}
+export declare class TypeGenerationError extends NoormError {
+    constructor(tableName: string, originalError: Error);
 }

package/dist/esm/errors/NoormError.js

@@ -52,27 +52,98 @@ export class NoormError extends Error {
  */
 export 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';
     }
 }
 export 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];
+    }
+}
+export 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';
+    }
+}
+export 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';
+    }
+}
+export 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';
     }
 }
 export class RelationshipNotFoundError extends NoormError {
@@ -85,24 +156,69 @@ export class RelationshipNotFoundError extends NoormError {
                 : 'No relationships defined for this table',
             availableOptions: availableRelationships
         });
+        this.name = 'RelationshipNotFoundError';
     }
 }
-export class ValidationError extends NoormError {
-    constructor(message, field, tableName) {
-        super(message, {
+export 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.';
+    }
+}
+export 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';
     }
 }
-export 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',
+export 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';
+    }
+}
+export 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';
     }
 }
 /**

package/dist/esm/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
      */