noormme 1.0.0 → 1.0.2

package/dist/cjs/dynamic/dynamic.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicModule = void 0;
 const dynamic_reference_builder_js_1 = require("./dynamic-reference-builder.js");
 const dynamic_table_builder_js_1 = require("./dynamic-table-builder.js");
+const security_validator_js_1 = require("../util/security-validator.js");
 class DynamicModule {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
@@ -20,6 +21,10 @@ class DynamicModule {
      * create an SQL injection vulnerability. Always __always__ validate the user
      * input before passing it to this method.
      *
+     * SECURITY: This method now includes built-in validation to prevent SQL injection
+     * through malicious column references. However, you should still validate that
+     * the column reference is from a trusted source or whitelist of allowed columns.
+     *
      * There are couple of examples below for some use cases, but you can pass
      * `ref` to other methods as well. If the types allow you to pass a `ref`
      * value to some place, it should work.
@@ -32,6 +37,12 @@ class DynamicModule {
      * async function someQuery(filterColumn: string, filterValue: string) {
      *   const { ref } = db.dynamic
      *
+     *   // Validate input against a whitelist of allowed columns
+     *   const allowedColumns = ['first_name', 'last_name', 'email']
+     *   if (!allowedColumns.includes(filterColumn)) {
+     *     throw new Error('Invalid column')
+     *   }
+     *
      *   return await db
      *     .selectFrom('person')
      *     .selectAll()
@@ -49,6 +60,12 @@ class DynamicModule {
      * async function someQuery(orderBy: string) {
      *   const { ref } = db.dynamic
      *
+     *   // Validate against allowed columns
+     *   const allowedColumns = ['first_name', 'last_name', 'created_at']
+     *   if (!allowedColumns.includes(orderBy)) {
+     *     throw new Error('Invalid order column')
+     *   }
+     *
      *   return await db
      *     .selectFrom('person')
      *     .select('person.first_name as fn')
@@ -90,6 +107,8 @@ class DynamicModule {
      * ```
      */
     ref(reference) {
+        // Security validation to prevent SQL injection
+        (0, security_validator_js_1.validateColumnReference)(reference);
         return new dynamic_reference_builder_js_1.DynamicReferenceBuilder(reference);
     }
     /**
@@ -97,6 +116,10 @@ class DynamicModule {
      *
      * The type `T` is allowed to be a union of multiple tables.
      *
+     * SECURITY: This method now includes built-in validation to prevent SQL injection
+     * through malicious table references. However, you should still validate that
+     * the table reference is from a trusted source or whitelist of allowed tables.
+     *
      * <!-- siteExample("select", "Generic find query", 130) -->
      *
      * A generic type-safe helper function for finding a row by a column value:
@@ -126,6 +149,8 @@ class DynamicModule {
      * ```
      */
     table(table) {
+        // Security validation to prevent SQL injection
+        (0, security_validator_js_1.validateTableReference)(table);
         return new dynamic_table_builder_js_1.DynamicTableBuilder(table);
     }
 }

package/dist/cjs/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/cjs/edge-runtime/edge-config.js

@@ -0,0 +1,323 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeRuntimeUtils = exports.EdgeRuntimeMonitor = exports.EdgeRuntimeDB = void 0;
+exports.getEdgeRuntimeConfig = getEdgeRuntimeConfig;
+exports.isEdgeRuntime = isEdgeRuntime;
+exports.getRuntimeConfig = getRuntimeConfig;
+exports.createEdgeMiddleware = createEdgeMiddleware;
+exports.createEdgeErrorHandler = createEdgeErrorHandler;
+/**
+ * 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
+ */
+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
+ */
+function isEdgeRuntime() {
+    return ((typeof globalThis !== 'undefined' && 'EdgeRuntime' in globalThis) ||
+        (typeof process !== 'undefined' && process.env.NEXT_RUNTIME === 'edge'));
+}
+/**
+ * Get appropriate configuration based on runtime environment
+ */
+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
+ */
+class EdgeRuntimeDB {
+    config;
+    constructor(config) {
+        this.config = config || getEdgeRuntimeConfig();
+    }
+    /**
+     * Create a new database instance optimized for Edge Runtime
+     */
+    async createInstance() {
+        const { NOORMME } = await Promise.resolve().then(() => __importStar(require('../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();
+        }
+    }
+}
+exports.EdgeRuntimeDB = EdgeRuntimeDB;
+/**
+ * Edge Runtime compatible middleware
+ */
+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
+ */
+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
+ */
+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'
+        };
+    }
+}
+exports.EdgeRuntimeMonitor = EdgeRuntimeMonitor;
+/**
+ * Edge Runtime utilities
+ */
+exports.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/cjs/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);
 }