@zintrust/core 0.1.0

package/src/profiling/N1Detector.js

@@ -0,0 +1,120 @@
+/**
+ * N+1 Query Pattern Detector
+ * Analyzes query logs to identify N+1 patterns
+ */
+/**\n * N1Detector analyzes query logs to identify N+1 patterns
+ * Groups identical queries and flags those executed 5+ times as critical
+ * Sealed namespace for immutability
+ */
+export const N1Detector = Object.freeze({
+    /**
+     * Create a new N1Detector instance
+     */
+    create() {
+        return {
+            /**
+             * Extract table name from SQL query
+             * Handles SELECT, INSERT, UPDATE, DELETE statements
+             */
+            extractTableFromSQL(sql) {
+                return extractTableFromSQL(sql);
+            },
+            /**
+             * Detect N+1 patterns in query log
+             * Groups identical queries and returns those executed 5+ times as patterns
+             */
+            detect(queryLog) {
+                return detectN1Patterns(queryLog);
+            },
+            /**
+             * Get severity level based on repetition count
+             */
+            getSeverity(count) {
+                return getSeverity(count);
+            },
+            /**
+             * Generate human-readable summary of N+1 patterns
+             */
+            generateSummary(patterns) {
+                return generateSummary(patterns);
+            },
+        };
+    },
+});
+/**
+ * Extract table name from SQL query
+ */
+function extractTableFromSQL(sql) {
+    // Remove excess whitespace and normalize
+    const normalized = sql.trim().replaceAll(/\s+/g, ' ');
+    // INSERT INTO table
+    let match = new RegExp(/INSERT\s+INTO\s+`?(\w+)`?/i).exec(normalized);
+    if (match)
+        return match[1];
+    // UPDATE table
+    match = new RegExp(/UPDATE\s+`?(\w+)`?/i).exec(normalized);
+    if (match)
+        return match[1];
+    // DELETE FROM table
+    match = new RegExp(/DELETE\s+FROM\s+`?(\w+)`?/i).exec(normalized);
+    if (match)
+        return match[1];
+    // SELECT ... FROM table
+    match = new RegExp(/FROM\s+`?(\w+)`?/i).exec(normalized);
+    if (match)
+        return match[1];
+    return 'unknown';
+}
+/**
+ * Detect N+1 patterns in query log
+ */
+function detectN1Patterns(queryLog) {
+    if (queryLog.length === 0) {
+        return [];
+    }
+    // Group queries by SQL
+    const queryGroups = new Map();
+    for (const entry of queryLog) {
+        if (!queryGroups.has(entry.sql)) {
+            queryGroups.set(entry.sql, []);
+        }
+        queryGroups.get(entry.sql)?.push(entry);
+    }
+    // Find patterns with 5+ executions
+    const patterns = [];
+    for (const [sql, entries] of queryGroups) {
+        const count = entries.length;
+        if (count >= 5) {
+            const severity = getSeverity(count);
+            const table = extractTableFromSQL(sql);
+            patterns.push({
+                table,
+                queryCount: count,
+                query: sql,
+                severity,
+            });
+        }
+    }
+    // Sort by query count descending
+    patterns.sort((a, b) => b.queryCount - a.queryCount);
+    return patterns;
+}
+/**
+ * Get severity level based on repetition count
+ */
+function getSeverity(count) {
+    return count >= 10 ? 'critical' : 'warning';
+}
+/**
+ * Generate human-readable summary of N+1 patterns
+ */
+function generateSummary(patterns) {
+    if (patterns.length === 0) {
+        return 'No N+1 patterns detected';
+    }
+    const lines = ['N+1 Query Patterns Detected:'];
+    for (const pattern of patterns) {
+        lines.push(`  [${pattern.severity.toUpperCase()}] Table "${pattern.table}": ${pattern.queryCount} identical queries`);
+    }
+    return lines.join('\n');
+}

package/src/profiling/QueryLogger.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Query Logger
+ * Tracks database query execution with parameters, duration, and context
+ */
+import { QueryLogEntry } from './types';
+/**
+ * QueryLogger tracks all database queries executed during a request context
+ * Provides N+1 detection heuristic by flagging identical queries executed 5+ times
+ */
+export type QueryLoggerInstance = IQueryLogger;
+export interface IQueryLogger {
+    /**
+     * Set current request context ID
+     */
+    setContext(context: string): void;
+    /**
+     * Get current request context ID
+     */
+    getContext(): string;
+    /**
+     * Log a query execution
+     */
+    logQuery(sql: string, params: unknown[], duration: number, context?: string): void;
+    /**
+     * Get query log for a context
+     */
+    getQueryLog(context?: string): QueryLogEntry[];
+    /**
+     * Get query summary (grouped by SQL) for a context
+     */
+    getQuerySummary(context?: string): Map<string, QueryLogEntry & {
+        executionCount: number;
+    }>;
+    /**
+     * Get N+1 suspects (queries executed 5+ times in same context)
+     */
+    getN1Suspects(context?: string, threshold?: number): QueryLogEntry[];
+    /**
+     * Clear logs for a context
+     */
+    clear(context?: string): void;
+    /**
+     * Get all logs
+     */
+    getAllLogs(): Map<string, QueryLogEntry[]>;
+    /**
+     * Get total query count for a context
+     */
+    getQueryCount(context?: string): number;
+    /**
+     * Get total duration for all queries in a context
+     */
+    getTotalDuration(context?: string): number;
+}
+/**
+ * QueryLogger tracks all database queries executed during a request context
+ * Provides N+1 detection heuristic by flagging identical queries executed 5+ times
+ * Sealed namespace for immutability
+ */
+export declare const QueryLogger: Readonly<{
+    logs: Map<string, QueryLogEntry[] | undefined>;
+    getInstance(): IQueryLogger;
+    /**
+     * Set current request context ID
+     */
+    setContext(context: string): void;
+    /**
+     * Get current request context ID
+     */
+    getContext(): string;
+    /**
+     * Log a query execution
+     */
+    logQuery(sql: string, params: unknown[], duration: number, context?: string): void;
+    /**
+     * Get query log for a context
+     */
+    getQueryLog(context?: string): QueryLogEntry[];
+    /**
+     * Get query summary (grouped by SQL) for a context
+     */
+    getQuerySummary(context?: string): Map<string, QueryLogEntry & {
+        executionCount: number;
+    }>;
+    /**
+     * Get N+1 suspects (queries executed 5+ times in same context)
+     * Simple heuristic: identical queries executed many times suggests N+1
+     */
+    getN1Suspects(context?: string, threshold?: number): QueryLogEntry[];
+    /**
+     * Clear logs for a context
+     */
+    clear(context?: string): void;
+    /**
+     * Get all logs
+     */
+    getAllLogs(): Map<string, QueryLogEntry[]>;
+    /**
+     * Get total query count for a context
+     */
+    getQueryCount(context?: string): number;
+    /**
+     * Get total duration for all queries in a context
+     */
+    getTotalDuration(context?: string): number;
+}>;
+//# sourceMappingURL=QueryLogger.d.ts.map

package/src/profiling/QueryLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryLogger.d.ts","sourceRoot":"","sources":["../../../src/profiling/QueryLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC;;OAEG;IACH,UAAU,IAAI,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEnF;;OAEG;IACH,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC;IAE/C;;OAEG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE3F;;OAEG;IACH,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC;IAErE;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B;;OAEG;IACH,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IAE3C;;OAEG;IACH,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAExC;;OAEG;IACH,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5C;AASD;;;;GAIG;AACH,eAAO,MAAM,WAAW;;mBAGP,YAAY;IAG3B;;OAEG;wBACiB,MAAM,GAAG,IAAI;IAcjC;;OAEG;kBACW,MAAM;IAIpB;;OAEG;kBAEI,MAAM,UACH,OAAO,EAAE,YACP,MAAM,YACP,MAAM,GACd,IAAI;IA+BP;;OAEG;0BACkB,MAAM,GAAoB,aAAa,EAAE;IAK9D;;OAEG;8BAEQ,MAAM,GACd,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC;IAiB1D;;;OAGG;4BACoB,MAAM,cAA8B,MAAM,GAAO,aAAa,EAAE;IAavF;;OAEG;oBACa,MAAM,GAAG,IAAI;IAS7B;;OAEG;kBACW,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;IAU1C;;OAEG;4BACoB,MAAM,GAAoB,MAAM;IAIvD;;OAEG;+BACuB,MAAM,GAAoB,MAAM;EAI1D,CAAC"}

package/src/profiling/QueryLogger.js

@@ -0,0 +1,148 @@
+/**
+ * Query Logger
+ * Tracks database query execution with parameters, duration, and context
+ */
+// Private state (exposed on QueryLogger for targeted unit-test coverage)
+const logs = new Map();
+let currentContext = 'default';
+const MAX_CONTEXTS = 1000;
+const MAX_QUERIES_PER_CONTEXT = 500;
+/**
+ * QueryLogger tracks all database queries executed during a request context
+ * Provides N+1 detection heuristic by flagging identical queries executed 5+ times
+ * Sealed namespace for immutability
+ */
+export const QueryLogger = Object.freeze({
+    // Exposed for rare-branch tests that deliberately corrupt the map.
+    logs,
+    getInstance() {
+        return this;
+    },
+    /**
+     * Set current request context ID
+     */
+    setContext(context) {
+        currentContext = context;
+        if (!logs.has(context)) {
+            // Prevent unbounded growth of contexts
+            if (logs.size >= MAX_CONTEXTS) {
+                const firstKey = logs.keys().next().value;
+                if (firstKey !== undefined) {
+                    logs.delete(firstKey);
+                }
+            }
+            logs.set(context, []);
+        }
+    },
+    /**
+     * Get current request context ID
+     */
+    getContext() {
+        return currentContext;
+    },
+    /**
+     * Log a query execution
+     */
+    logQuery(sql, params, duration, context = currentContext) {
+        if (!logs.has(context)) {
+            // Prevent unbounded growth of contexts
+            if (logs.size >= MAX_CONTEXTS) {
+                const firstKey = logs.keys().next().value;
+                if (firstKey !== undefined) {
+                    logs.delete(firstKey);
+                }
+            }
+            logs.set(context, []);
+        }
+        const entry = {
+            sql,
+            params,
+            duration,
+            timestamp: new Date(),
+            context,
+        };
+        const contextLogs = logs.get(context);
+        if (Array.isArray(contextLogs)) {
+            contextLogs.push(entry);
+            // Prevent unbounded growth of queries per context
+            if (contextLogs.length > MAX_QUERIES_PER_CONTEXT) {
+                contextLogs.shift();
+            }
+        }
+    },
+    /**
+     * Get query log for a context
+     */
+    getQueryLog(context = currentContext) {
+        const contextLogs = logs.get(context);
+        return Array.isArray(contextLogs) ? contextLogs : [];
+    },
+    /**
+     * Get query summary (grouped by SQL) for a context
+     */
+    getQuerySummary(context = currentContext) {
+        const queryLogs = this.getQueryLog(context);
+        const summary = new Map();
+        for (const log of queryLogs) {
+            if (!summary.has(log.sql)) {
+                summary.set(log.sql, { ...log, executionCount: 0 });
+            }
+            const entry = summary.get(log.sql);
+            if (entry !== undefined) {
+                entry.executionCount++;
+            }
+        }
+        return summary;
+    },
+    /**
+     * Get N+1 suspects (queries executed 5+ times in same context)
+     * Simple heuristic: identical queries executed many times suggests N+1
+     */
+    getN1Suspects(context = currentContext, threshold = 5) {
+        const summary = this.getQuerySummary(context);
+        const suspects = [];
+        for (const [, entry] of summary) {
+            if (entry.executionCount >= threshold) {
+                suspects.push(entry);
+            }
+        }
+        return suspects;
+    },
+    /**
+     * Clear logs for a context
+     */
+    clear(context) {
+        if (context === undefined) {
+            logs.clear();
+            currentContext = 'default';
+        }
+        else {
+            logs.delete(context);
+        }
+    },
+    /**
+     * Get all logs
+     */
+    getAllLogs() {
+        const copy = new Map();
+        for (const [key, value] of logs.entries()) {
+            if (Array.isArray(value)) {
+                copy.set(key, value);
+            }
+        }
+        return copy;
+    },
+    /**
+     * Get total query count for a context
+     */
+    getQueryCount(context = currentContext) {
+        return this.getQueryLog(context).length;
+    },
+    /**
+     * Get total duration for all queries in a context
+     */
+    getTotalDuration(context = currentContext) {
+        const queryLogs = this.getQueryLog(context);
+        return queryLogs.reduce((total, log) => total + log.duration, 0);
+    },
+});

package/src/profiling/RequestProfiler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Request Profiler
+ * Comprehensive profiling of request execution combining query, N+1, and memory metrics
+ */
+import { IMemoryProfiler } from './MemoryProfiler';
+import { IQueryLogger } from './QueryLogger';
+import { IN1Detector, ProfileReport } from './types';
+export interface IRequestProfiler {
+    getQueryLogger(): IQueryLogger;
+    getN1Detector(): IN1Detector;
+    getMemoryProfiler(): IMemoryProfiler;
+    captureRequest(fn: () => Promise<unknown>): Promise<ProfileReport>;
+    generateReport(profile: ProfileReport): string;
+}
+/**
+ * RequestProfiler orchestrates query logging, N+1 detection, and memory profiling
+ * Sealed namespace for immutability
+ */
+export declare const RequestProfiler: Readonly<{
+    /**
+     * Create a new request profiler instance
+     */
+    create(): IRequestProfiler;
+}>;
+/**
+ * Re-export MemoryProfiler's static formatBytes for convenience
+ */
+export { MemoryProfiler } from './MemoryProfiler';
+export default RequestProfiler;
+//# sourceMappingURL=RequestProfiler.d.ts.map

package/src/profiling/RequestProfiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestProfiler.d.ts","sourceRoot":"","sources":["../../../src/profiling/RequestProfiler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAkB,MAAM,2BAA2B,CAAC;AAE5E,OAAO,EAAE,YAAY,EAAe,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,WAAW,EAAa,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEzE,MAAM,WAAW,gBAAgB;IAC/B,cAAc,IAAI,YAAY,CAAC;IAC/B,aAAa,IAAI,WAAW,CAAC;IAC7B,iBAAiB,IAAI,eAAe,CAAC;IACrC,cAAc,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC;CAChD;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;cACO,gBAAgB;EAkE1B,CAAC;AAmBH;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,eAAe,eAAe,CAAC"}

package/src/profiling/RequestProfiler.js

@@ -0,0 +1,94 @@
+/**
+ * Request Profiler
+ * Comprehensive profiling of request execution combining query, N+1, and memory metrics
+ */
+import { MemoryProfiler } from './MemoryProfiler';
+import { N1Detector } from './N1Detector';
+import { QueryLogger } from './QueryLogger';
+/**
+ * RequestProfiler orchestrates query logging, N+1 detection, and memory profiling
+ * Sealed namespace for immutability
+ */
+export const RequestProfiler = Object.freeze({
+    /**
+     * Create a new request profiler instance
+     */
+    create() {
+        const queryLogger = QueryLogger.getInstance();
+        const n1Detector = N1Detector.create();
+        const memoryProfiler = MemoryProfiler.create();
+        let startTime = 0;
+        let endTime = 0;
+        return {
+            getQueryLogger() {
+                return queryLogger;
+            },
+            getN1Detector() {
+                return n1Detector;
+            },
+            getMemoryProfiler() {
+                return memoryProfiler;
+            },
+            async captureRequest(fn) {
+                // Start profiling
+                startTime = Date.now();
+                memoryProfiler.start();
+                queryLogger.setContext('profiling');
+                try {
+                    // Execute the request
+                    await fn();
+                }
+                finally {
+                    // End profiling
+                    endTime = Date.now();
+                    memoryProfiler.end();
+                }
+                // Gather profiling data
+                const duration = endTime - startTime;
+                const queryLog = queryLogger.getQueryLog('profiling');
+                const queriesExecuted = queryLog.length;
+                const patterns = n1Detector.detect(queryLog);
+                const memoryDelta = memoryProfiler.delta();
+                return {
+                    duration,
+                    queriesExecuted,
+                    n1Patterns: patterns,
+                    memoryDelta,
+                    timestamp: new Date(),
+                };
+            },
+            generateReport(profile) {
+                const n1Section = formatN1Section(profile.n1Patterns);
+                const lines = [
+                    '=== Performance Profile Report ===',
+                    `\nTiming: ${profile.duration}ms`,
+                    `Queries: ${profile.queriesExecuted}`,
+                    ...n1Section,
+                    '\nMemory Delta:',
+                    `  Heap Used: ${MemoryProfiler.formatBytes(profile.memoryDelta.heapUsed)}`,
+                    `  Heap Total: ${MemoryProfiler.formatBytes(profile.memoryDelta.heapTotal)}`,
+                    `  External: ${MemoryProfiler.formatBytes(profile.memoryDelta.external)}`,
+                    `  RSS: ${MemoryProfiler.formatBytes(profile.memoryDelta.rss)}`,
+                ];
+                return lines.join('\n');
+            },
+        };
+    },
+});
+/**
+ * Format N+1 section for report
+ */
+function formatN1Section(patterns) {
+    if (patterns.length === 0) {
+        return ['\nN+1 Patterns: None detected'];
+    }
+    return [
+        '\nN+1 Patterns:',
+        ...patterns.map((pattern) => `  [${pattern.severity.toUpperCase()}] "${pattern.table}": ${pattern.queryCount}x`),
+    ];
+}
+/**
+ * Re-export MemoryProfiler's static formatBytes for convenience
+ */
+export { MemoryProfiler } from './MemoryProfiler';
+export default RequestProfiler;

package/src/profiling/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Profiling Type Definitions
+ * Shared interfaces for query logging, N+1 detection, and memory profiling
+ */
+export declare const PROFILING_TYPES_MODULE: string;
+/**
+ * Log entry for a single database query execution
+ */
+export interface QueryLogEntry {
+    sql: string;
+    params: unknown[];
+    duration: number;
+    timestamp: Date;
+    context: string;
+    executionCount?: number;
+}
+/**
+ * Detected N+1 query pattern
+ */
+export interface N1Pattern {
+    table: string;
+    queryCount: number;
+    query: string;
+    severity: 'warning' | 'critical';
+}
+/**
+ * Memory snapshot at a point in time
+ */
+export interface MemorySnapshot {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+    timestamp: Date;
+}
+/**
+ * Memory delta between two snapshots
+ */
+export interface MemoryDelta {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+}
+/**
+ * N1Detector analyzes query logs to identify N+1 patterns
+ * Groups identical queries and flags those executed 5+ times as critical
+ */
+export interface IN1Detector {
+    /**
+     * Extract table name from SQL query
+     */
+    extractTableFromSQL(sql: string): string;
+    /**
+     * Detect N+1 patterns in query log
+     */
+    detect(queryLog: QueryLogEntry[]): N1Pattern[];
+    /**
+     * Get severity level based on repetition count
+     */
+    getSeverity(count: number): 'warning' | 'critical';
+    /**
+     * Generate human-readable summary of N+1 patterns
+     */
+    generateSummary(patterns: N1Pattern[]): string;
+}
+/**
+ * Complete profile report for a request
+ */
+export interface ProfileReport {
+    duration: number;
+    queriesExecuted: number;
+    n1Patterns: N1Pattern[];
+    memoryDelta: MemoryDelta;
+    timestamp: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/src/profiling/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/profiling/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,sBAAsB,QAAkC,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAEzC;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,CAAC;IAE/C;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC;IAEnD;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;CAChD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;CACjB"}

package/src/profiling/types.js

@@ -0,0 +1,5 @@
+/**
+ * Profiling Type Definitions
+ * Shared interfaces for query logging, N+1 detection, and memory profiling
+ */
+export const PROFILING_TYPES_MODULE = Object.freeze('ProfilingTypes');

package/src/routing/Router.d.ts

@@ -0,0 +1,52 @@
+import { IRequest } from '../http/Request';
+import { IResponse } from '../http/Response';
+/**
+ * Router - HTTP Routing Engine
+ * Matches incoming requests to route handlers
+ */
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export interface RouteMatch {
+    handler: RouteHandler;
+    params: Record<string, string>;
+}
+export interface Route {
+    method: string;
+    path: string;
+    pattern: RegExp;
+    handler: RouteHandler;
+    paramNames: string[];
+}
+export type RouteGroupCallback = (router: IRouter) => void;
+export interface ResourceController {
+    index?: RouteHandler;
+    show?: RouteHandler;
+    store?: RouteHandler;
+    update?: RouteHandler;
+    destroy?: RouteHandler;
+}
+export type IRouter = {
+    routes: Route[];
+    prefix: string;
+    routeIndex: Map<string, Route[]>;
+};
+export declare const createRouter: () => IRouter;
+/**
+ * Router - Sealed namespace for HTTP routing
+ * All operations grouped in frozen namespace to prevent mutation
+ */
+export declare const Router: Readonly<{
+    createRouter: () => IRouter;
+    scopeRouter: (router: IRouter, prefix: string) => IRouter;
+    group: (router: IRouter, prefix: string, callback: RouteGroupCallback) => void;
+    resource: (router: IRouter, path: string, controller: ResourceController) => void;
+    get: (router: IRouter, path: string, handler: RouteHandler) => void;
+    post: (router: IRouter, path: string, handler: RouteHandler) => void;
+    put: (router: IRouter, path: string, handler: RouteHandler) => void;
+    patch: (router: IRouter, path: string, handler: RouteHandler) => void;
+    del: (router: IRouter, path: string, handler: RouteHandler) => void;
+    any: (router: IRouter, path: string, handler: RouteHandler) => void;
+    match: (router: IRouter, method: string, path: string) => RouteMatch | null;
+    getRoutes: (router: IRouter) => Route[];
+}>;
+export default Router;
+//# sourceMappingURL=Router.d.ts.map

package/src/routing/Router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../../src/routing/Router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEnF,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,OAI9B,CAAC;AAoMH;;;GAGG;AACH,eAAO,MAAM,MAAM;wBA5Ma,OAAO;0BA8IV,OAAO,UAAU,MAAM,KAAG,OAAO;oBAMvC,OAAO,UAAU,MAAM,YAAY,kBAAkB,KAAG,IAAI;uBAIzD,OAAO,QAAQ,MAAM,cAAc,kBAAkB,KAAG,IAAI;kBAgBjE,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;mBAIlD,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;kBAIpD,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;oBAIjD,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;kBAIrD,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;kBAInD,OAAO,QAAQ,MAAM,WAAW,YAAY,KAAG,IAAI;oBAOjD,OAAO,UAAU,MAAM,QAAQ,MAAM,KAAG,UAAU,GAAG,IAAI;wBAGrD,OAAO,KAAG,KAAK,EAAE;EAmB1C,CAAC;AAEH,eAAe,MAAM,CAAC"}