trickle-observe 0.2.106 → 0.2.108

package/dist/db-observer.d.ts

@@ -26,6 +26,34 @@ export declare function patchBetterSqlite3(dbConstructor: any, debug: boolean):
  * Called from observe-register when ioredis is required.
  */
 export declare function patchIoredis(ioredisModule: any, debug: boolean): void;
+/**
+ * Patch @prisma/client to capture queries.
+ * Prisma has its own query engine (Rust binary) so patching pg/mysql2 won't work.
+ * Instead, we hook into Prisma's $on('query') event and $use() middleware.
+ */
+export declare function patchPrisma(prismaModule: any, debug: boolean): void;
+/**
+ * Patch Drizzle ORM to capture queries.
+ * Drizzle exposes a logger option in its constructor.
+ * We patch the db object's execute method to capture queries.
+ */
+export declare function patchDrizzle(drizzleModule: any, debug: boolean): void;
+/**
+ * Patch Knex to capture queries.
+ * Knex emits 'query' and 'query-response' events on the knex instance.
+ */
+export declare function patchKnex(knexModule: any, debug: boolean): void;
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+export declare function patchTypeORM(typeormModule: any, debug: boolean): void;
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+export declare function patchSequelize(sequelizeModule: any, debug: boolean): void;
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

package/dist/db-observer.js

@@ -47,6 +47,11 @@ exports.patchPg = patchPg;
 exports.patchMysql2 = patchMysql2;
 exports.patchBetterSqlite3 = patchBetterSqlite3;
 exports.patchIoredis = patchIoredis;
+exports.patchPrisma = patchPrisma;
+exports.patchDrizzle = patchDrizzle;
+exports.patchKnex = patchKnex;
+exports.patchTypeORM = patchTypeORM;
+exports.patchSequelize = patchSequelize;
 exports.patchMongoose = patchMongoose;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -333,6 +338,341 @@ function patchIoredis(ioredisModule, debug) {
     if (debug)
         console.log('[trickle/db] Redis (ioredis) query tracing enabled');
 }
+/**
+ * Patch @prisma/client to capture queries.
+ * Prisma has its own query engine (Rust binary) so patching pg/mysql2 won't work.
+ * Instead, we hook into Prisma's $on('query') event and $use() middleware.
+ */
+function patchPrisma(prismaModule, debug) {
+    debugMode = debug;
+    const PrismaClient = prismaModule.PrismaClient;
+    if (!PrismaClient || PrismaClient.__trickle_patched)
+        return;
+    const originalConstructor = PrismaClient;
+    const OriginalPrototype = PrismaClient.prototype;
+    // Wrap the constructor to inject query logging
+    const patchedConstructor = function (opts = {}) {
+        // Enable query logging in Prisma
+        if (!opts.log)
+            opts.log = [];
+        const logEntries = Array.isArray(opts.log) ? opts.log : [];
+        // Add query event if not already present
+        const hasQueryLog = logEntries.some((entry) => (typeof entry === 'string' && entry === 'query') ||
+            (typeof entry === 'object' && entry.emit === 'event' && entry.level === 'query'));
+        if (!hasQueryLog) {
+            logEntries.push({ emit: 'event', level: 'query' });
+        }
+        opts.log = logEntries;
+        // Call original constructor
+        const instance = new originalConstructor(opts);
+        // Subscribe to query events
+        try {
+            instance.$on('query', (e) => {
+                const queryText = (e.query || '').substring(0, MAX_QUERY_LENGTH);
+                const params = e.params ? (() => { try {
+                    return JSON.parse(e.params).slice(0, 5);
+                }
+                catch {
+                    return undefined;
+                } })() : undefined;
+                writeQuery({
+                    kind: 'query',
+                    query: queryText,
+                    params,
+                    durationMs: e.duration || 0,
+                    rowCount: 0, // Prisma query events don't include row count
+                    timestamp: Date.now(),
+                });
+                if (debugMode) {
+                    console.log(`[trickle/db] Prisma: ${queryText.substring(0, 60)}... (${e.duration}ms)`);
+                }
+            });
+        }
+        catch { /* $on may not be available on all Prisma versions */ }
+        return instance;
+    };
+    // Copy prototype chain
+    patchedConstructor.prototype = OriginalPrototype;
+    Object.setPrototypeOf(patchedConstructor, originalConstructor);
+    // Copy static properties
+    for (const key of Object.getOwnPropertyNames(originalConstructor)) {
+        if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+            try {
+                Object.defineProperty(patchedConstructor, key, Object.getOwnPropertyDescriptor(originalConstructor, key));
+            }
+            catch { }
+        }
+    }
+    prismaModule.PrismaClient = patchedConstructor;
+    prismaModule.PrismaClient.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] Prisma query tracing enabled');
+}
+/**
+ * Patch Drizzle ORM to capture queries.
+ * Drizzle exposes a logger option in its constructor.
+ * We patch the db object's execute method to capture queries.
+ */
+function patchDrizzle(drizzleModule, debug) {
+    debugMode = debug;
+    // drizzle-orm exports various dialect-specific functions
+    // The common pattern is drizzle(client, { logger: true })
+    // We patch by wrapping the module's default export or named exports
+    for (const key of Object.keys(drizzleModule)) {
+        const fn = drizzleModule[key];
+        if (typeof fn !== 'function')
+            continue;
+        if (fn.__trickle_patched)
+            continue;
+        // Only patch functions that look like drizzle constructors
+        // (they take a client + config object)
+        drizzleModule[key] = function patchedDrizzle(...args) {
+            // Inject a custom logger into the config
+            const config = args[1] && typeof args[1] === 'object' ? { ...args[1] } : (args.length > 1 ? args[1] : {});
+            if (typeof config === 'object' && config !== null) {
+                const origLogger = config.logger;
+                config.logger = {
+                    logQuery(query, params) {
+                        const startTime = performance.now();
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: Array.isArray(params) ? params.slice(0, 5) : undefined,
+                            durationMs: 0, // Drizzle logger doesn't provide timing
+                            rowCount: 0,
+                            timestamp: Date.now(),
+                        });
+                        // Call original logger if present
+                        if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+                            origLogger.logQuery(query, params);
+                        }
+                    },
+                };
+                args[1] = config;
+            }
+            return fn.apply(this, args);
+        };
+        drizzleModule[key].__trickle_patched = true;
+    }
+    if (debug)
+        console.log('[trickle/db] Drizzle ORM query tracing enabled');
+}
+/**
+ * Patch Knex to capture queries.
+ * Knex emits 'query' and 'query-response' events on the knex instance.
+ */
+function patchKnex(knexModule, debug) {
+    debugMode = debug;
+    const origKnex = knexModule.default || knexModule;
+    if (typeof origKnex !== 'function' || origKnex.__trickle_patched)
+        return;
+    const wrapped = function patchedKnex(...args) {
+        const instance = origKnex.apply(this, args);
+        // Track query start times
+        const queryTimers = new Map();
+        try {
+            instance.on('query', (data) => {
+                queryTimers.set(data.__knexQueryUid || '', performance.now());
+            });
+            instance.on('query-response', (_response, data) => {
+                const startTime = queryTimers.get(data.__knexQueryUid || '');
+                const durationMs = startTime ? Math.round((performance.now() - startTime) * 100) / 100 : 0;
+                queryTimers.delete(data.__knexQueryUid || '');
+                writeQuery({
+                    kind: 'query',
+                    query: (data.sql || '').substring(0, MAX_QUERY_LENGTH),
+                    params: Array.isArray(data.bindings) ? data.bindings.slice(0, 5) : undefined,
+                    durationMs,
+                    rowCount: 0,
+                    timestamp: Date.now(),
+                });
+            });
+            instance.on('query-error', (error, data) => {
+                const startTime = queryTimers.get(data.__knexQueryUid || '');
+                const durationMs = startTime ? Math.round((performance.now() - startTime) * 100) / 100 : 0;
+                queryTimers.delete(data.__knexQueryUid || '');
+                writeQuery({
+                    kind: 'query',
+                    query: (data.sql || '').substring(0, MAX_QUERY_LENGTH),
+                    durationMs,
+                    rowCount: 0,
+                    error: error?.message?.substring(0, 200),
+                    timestamp: Date.now(),
+                });
+            });
+        }
+        catch { /* query events not available */ }
+        return instance;
+    };
+    // Copy properties
+    Object.setPrototypeOf(wrapped, origKnex);
+    for (const key of Object.getOwnPropertyNames(origKnex)) {
+        if (key !== 'length' && key !== 'name') {
+            try {
+                Object.defineProperty(wrapped, key, Object.getOwnPropertyDescriptor(origKnex, key));
+            }
+            catch { }
+        }
+    }
+    if (knexModule.default) {
+        knexModule.default = wrapped;
+    }
+    else {
+        // knex exports the function directly via module.exports
+        // We can't replace module.exports from here, but observe-register handles that
+    }
+    wrapped.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] Knex query tracing enabled');
+}
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+function patchTypeORM(typeormModule, debug) {
+    debugMode = debug;
+    // Patch DataSource constructor (TypeORM 0.3+)
+    const DataSource = typeormModule.DataSource;
+    if (DataSource && !DataSource.__trickle_patched) {
+        const OrigDataSource = DataSource;
+        typeormModule.DataSource = function PatchedDataSource(options) {
+            // Inject custom logger
+            if (!options._trickle_injected) {
+                options._trickle_injected = true;
+                const origLogger = options.logger;
+                options.logger = {
+                    logQuery(query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: 0,
+                            rowCount: 0,
+                            timestamp: Date.now(),
+                        });
+                        if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+                            origLogger.logQuery(query, parameters);
+                        }
+                    },
+                    logQueryError(error, query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: 0,
+                            rowCount: 0,
+                            error: error.substring(0, 200),
+                            timestamp: Date.now(),
+                        });
+                    },
+                    logQuerySlow(time, query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: time,
+                            rowCount: 0,
+                            timestamp: Date.now(),
+                        });
+                    },
+                    logSchemaBuild() { },
+                    logMigration() { },
+                    log() { },
+                };
+            }
+            return new OrigDataSource(options);
+        };
+        // Copy statics
+        Object.setPrototypeOf(typeormModule.DataSource, OrigDataSource);
+        typeormModule.DataSource.prototype = OrigDataSource.prototype;
+        typeormModule.DataSource.__trickle_patched = true;
+    }
+    // Also patch createConnection (TypeORM 0.2)
+    if (typeormModule.createConnection && !typeormModule.createConnection.__trickle_patched) {
+        const origCreate = typeormModule.createConnection;
+        typeormModule.createConnection = function patchedCreateConnection(options) {
+            if (options && typeof options === 'object' && !options.logging) {
+                options.logging = true;
+            }
+            return origCreate(options);
+        };
+        typeormModule.createConnection.__trickle_patched = true;
+    }
+    if (debug)
+        console.log('[trickle/db] TypeORM query tracing enabled');
+}
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+function patchSequelize(sequelizeModule, debug) {
+    debugMode = debug;
+    const Sequelize = sequelizeModule.Sequelize || sequelizeModule.default || sequelizeModule;
+    if (!Sequelize || typeof Sequelize !== 'function' || Sequelize.__trickle_patched)
+        return;
+    const origConstructor = Sequelize;
+    const patchedSequelize = function (...args) {
+        // Sequelize(uri, options) or Sequelize(database, user, pass, options)
+        let options;
+        if (args.length >= 4) {
+            options = args[3] = args[3] || {};
+        }
+        else if (args.length >= 2 && typeof args[1] === 'object') {
+            options = args[1];
+        }
+        else if (args.length === 1 && typeof args[0] === 'object') {
+            options = args[0];
+        }
+        else {
+            options = {};
+            args.push(options);
+        }
+        // Wrap the logging function
+        const origLogging = options.logging;
+        options.logging = (sql, timing) => {
+            const queryText = typeof sql === 'string' ? sql : String(sql);
+            // Sequelize prepends "Executed (default): " or "Executing (default): " to queries
+            const cleanQuery = queryText.replace(/^Execut(?:ed|ing) \([^)]*\):\s*/, '');
+            const durationMs = typeof timing === 'number' ? timing : 0;
+            writeQuery({
+                kind: 'query',
+                query: cleanQuery.substring(0, MAX_QUERY_LENGTH),
+                durationMs,
+                rowCount: 0,
+                timestamp: Date.now(),
+            });
+            // Call original logger
+            if (typeof origLogging === 'function') {
+                origLogging(sql, timing);
+            }
+        };
+        options.benchmark = true; // Enable timing in log
+        // Call original constructor
+        if (new.target) {
+            return new origConstructor(...args);
+        }
+        return origConstructor.apply(this, args);
+    };
+    // Copy prototype and statics
+    patchedSequelize.prototype = origConstructor.prototype;
+    Object.setPrototypeOf(patchedSequelize, origConstructor);
+    for (const key of Object.getOwnPropertyNames(origConstructor)) {
+        if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+            try {
+                Object.defineProperty(patchedSequelize, key, Object.getOwnPropertyDescriptor(origConstructor, key));
+            }
+            catch { }
+        }
+    }
+    // Replace in module exports
+    if (sequelizeModule.Sequelize) {
+        sequelizeModule.Sequelize = patchedSequelize;
+    }
+    patchedSequelize.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] Sequelize query tracing enabled');
+}
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

package/dist/observe-register.js

@@ -1203,6 +1203,51 @@ if (enabled) {
             }
             catch { /* not critical */ }
         }
+        // Prisma ORM
+        if (request === '@prisma/client' && !expressPatched.has('@prisma/client')) {
+            expressPatched.add('@prisma/client');
+            try {
+                const { patchPrisma } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchPrisma(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Drizzle ORM
+        if (request.startsWith('drizzle-orm') && !expressPatched.has('drizzle-orm')) {
+            expressPatched.add('drizzle-orm');
+            try {
+                const { patchDrizzle } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchDrizzle(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Knex query builder
+        if (request === 'knex' && !expressPatched.has('knex')) {
+            expressPatched.add('knex');
+            try {
+                const { patchKnex } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchKnex(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // TypeORM
+        if (request === 'typeorm' && !expressPatched.has('typeorm')) {
+            expressPatched.add('typeorm');
+            try {
+                const { patchTypeORM } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchTypeORM(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Sequelize
+        if (request === 'sequelize' && !expressPatched.has('sequelize')) {
+            expressPatched.add('sequelize');
+            try {
+                const { patchSequelize } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchSequelize(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
         // Redis (ioredis)
         if (request === 'ioredis' && !expressPatched.has('ioredis')) {
             expressPatched.add('ioredis');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.106",
+  "version": "0.2.108",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/db-observer.ts

@@ -332,6 +332,367 @@ export function patchIoredis(ioredisModule: any, debug: boolean): void {
   if (debug) console.log('[trickle/db] Redis (ioredis) query tracing enabled');
 }
 
+/**
+ * Patch @prisma/client to capture queries.
+ * Prisma has its own query engine (Rust binary) so patching pg/mysql2 won't work.
+ * Instead, we hook into Prisma's $on('query') event and $use() middleware.
+ */
+export function patchPrisma(prismaModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const PrismaClient = prismaModule.PrismaClient;
+  if (!PrismaClient || (PrismaClient as any).__trickle_patched) return;
+
+  const originalConstructor = PrismaClient;
+  const OriginalPrototype = PrismaClient.prototype;
+
+  // Wrap the constructor to inject query logging
+  const patchedConstructor = function (this: any, opts: any = {}) {
+    // Enable query logging in Prisma
+    if (!opts.log) opts.log = [];
+    const logEntries = Array.isArray(opts.log) ? opts.log : [];
+
+    // Add query event if not already present
+    const hasQueryLog = logEntries.some((entry: any) =>
+      (typeof entry === 'string' && entry === 'query') ||
+      (typeof entry === 'object' && entry.emit === 'event' && entry.level === 'query')
+    );
+    if (!hasQueryLog) {
+      logEntries.push({ emit: 'event', level: 'query' });
+    }
+    opts.log = logEntries;
+
+    // Call original constructor
+    const instance = new originalConstructor(opts);
+
+    // Subscribe to query events
+    try {
+      instance.$on('query', (e: any) => {
+        const queryText = (e.query || '').substring(0, MAX_QUERY_LENGTH);
+        const params = e.params ? (() => { try { return JSON.parse(e.params).slice(0, 5); } catch { return undefined; } })() : undefined;
+        writeQuery({
+          kind: 'query',
+          query: queryText,
+          params,
+          durationMs: e.duration || 0,
+          rowCount: 0, // Prisma query events don't include row count
+          timestamp: Date.now(),
+        });
+        if (debugMode) {
+          console.log(`[trickle/db] Prisma: ${queryText.substring(0, 60)}... (${e.duration}ms)`);
+        }
+      });
+    } catch { /* $on may not be available on all Prisma versions */ }
+
+    return instance;
+  };
+
+  // Copy prototype chain
+  patchedConstructor.prototype = OriginalPrototype;
+  Object.setPrototypeOf(patchedConstructor, originalConstructor);
+
+  // Copy static properties
+  for (const key of Object.getOwnPropertyNames(originalConstructor)) {
+    if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+      try {
+        Object.defineProperty(patchedConstructor, key, Object.getOwnPropertyDescriptor(originalConstructor, key)!);
+      } catch {}
+    }
+  }
+
+  prismaModule.PrismaClient = patchedConstructor;
+  (prismaModule.PrismaClient as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] Prisma query tracing enabled');
+}
+
+/**
+ * Patch Drizzle ORM to capture queries.
+ * Drizzle exposes a logger option in its constructor.
+ * We patch the db object's execute method to capture queries.
+ */
+export function patchDrizzle(drizzleModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // drizzle-orm exports various dialect-specific functions
+  // The common pattern is drizzle(client, { logger: true })
+  // We patch by wrapping the module's default export or named exports
+
+  for (const key of Object.keys(drizzleModule)) {
+    const fn = drizzleModule[key];
+    if (typeof fn !== 'function') continue;
+    if ((fn as any).__trickle_patched) continue;
+
+    // Only patch functions that look like drizzle constructors
+    // (they take a client + config object)
+    drizzleModule[key] = function patchedDrizzle(...args: any[]): any {
+      // Inject a custom logger into the config
+      const config = args[1] && typeof args[1] === 'object' ? { ...args[1] } : (args.length > 1 ? args[1] : {});
+
+      if (typeof config === 'object' && config !== null) {
+        const origLogger = config.logger;
+        config.logger = {
+          logQuery(query: string, params: unknown[]): void {
+            const startTime = performance.now();
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: Array.isArray(params) ? params.slice(0, 5) : undefined,
+              durationMs: 0, // Drizzle logger doesn't provide timing
+              rowCount: 0,
+              timestamp: Date.now(),
+            });
+            // Call original logger if present
+            if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+              (origLogger as any).logQuery(query, params);
+            }
+          },
+        };
+        args[1] = config;
+      }
+
+      return fn.apply(this, args);
+    };
+    (drizzleModule[key] as any).__trickle_patched = true;
+  }
+
+  if (debug) console.log('[trickle/db] Drizzle ORM query tracing enabled');
+}
+
+/**
+ * Patch Knex to capture queries.
+ * Knex emits 'query' and 'query-response' events on the knex instance.
+ */
+export function patchKnex(knexModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const origKnex = knexModule.default || knexModule;
+  if (typeof origKnex !== 'function' || (origKnex as any).__trickle_patched) return;
+
+  const wrapped = function patchedKnex(this: any, ...args: any[]): any {
+    const instance = origKnex.apply(this, args);
+
+    // Track query start times
+    const queryTimers = new Map<string, number>();
+
+    try {
+      instance.on('query', (data: any) => {
+        queryTimers.set(data.__knexQueryUid || '', performance.now());
+      });
+
+      instance.on('query-response', (_response: any, data: any) => {
+        const startTime = queryTimers.get(data.__knexQueryUid || '');
+        const durationMs = startTime ? Math.round((performance.now() - startTime) * 100) / 100 : 0;
+        queryTimers.delete(data.__knexQueryUid || '');
+
+        writeQuery({
+          kind: 'query',
+          query: (data.sql || '').substring(0, MAX_QUERY_LENGTH),
+          params: Array.isArray(data.bindings) ? data.bindings.slice(0, 5) : undefined,
+          durationMs,
+          rowCount: 0,
+          timestamp: Date.now(),
+        });
+      });
+
+      instance.on('query-error', (error: any, data: any) => {
+        const startTime = queryTimers.get(data.__knexQueryUid || '');
+        const durationMs = startTime ? Math.round((performance.now() - startTime) * 100) / 100 : 0;
+        queryTimers.delete(data.__knexQueryUid || '');
+
+        writeQuery({
+          kind: 'query',
+          query: (data.sql || '').substring(0, MAX_QUERY_LENGTH),
+          durationMs,
+          rowCount: 0,
+          error: error?.message?.substring(0, 200),
+          timestamp: Date.now(),
+        });
+      });
+    } catch { /* query events not available */ }
+
+    return instance;
+  };
+
+  // Copy properties
+  Object.setPrototypeOf(wrapped, origKnex);
+  for (const key of Object.getOwnPropertyNames(origKnex)) {
+    if (key !== 'length' && key !== 'name') {
+      try { Object.defineProperty(wrapped, key, Object.getOwnPropertyDescriptor(origKnex, key)!); } catch {}
+    }
+  }
+
+  if (knexModule.default) {
+    knexModule.default = wrapped;
+  } else {
+    // knex exports the function directly via module.exports
+    // We can't replace module.exports from here, but observe-register handles that
+  }
+
+  (wrapped as any).__trickle_patched = true;
+  if (debug) console.log('[trickle/db] Knex query tracing enabled');
+}
+
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+export function patchTypeORM(typeormModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // Patch DataSource constructor (TypeORM 0.3+)
+  const DataSource = typeormModule.DataSource;
+  if (DataSource && !DataSource.__trickle_patched) {
+    const OrigDataSource = DataSource;
+
+    typeormModule.DataSource = function PatchedDataSource(options: any) {
+      // Inject custom logger
+      if (!options._trickle_injected) {
+        options._trickle_injected = true;
+        const origLogger = options.logger;
+
+        options.logger = {
+          logQuery(query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: 0,
+              rowCount: 0,
+              timestamp: Date.now(),
+            });
+            if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+              origLogger.logQuery(query, parameters);
+            }
+          },
+          logQueryError(error: string, query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: 0,
+              rowCount: 0,
+              error: error.substring(0, 200),
+              timestamp: Date.now(),
+            });
+          },
+          logQuerySlow(time: number, query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: time,
+              rowCount: 0,
+              timestamp: Date.now(),
+            });
+          },
+          logSchemaBuild() {},
+          logMigration() {},
+          log() {},
+        };
+      }
+
+      return new OrigDataSource(options);
+    };
+
+    // Copy statics
+    Object.setPrototypeOf(typeormModule.DataSource, OrigDataSource);
+    typeormModule.DataSource.prototype = OrigDataSource.prototype;
+    typeormModule.DataSource.__trickle_patched = true;
+  }
+
+  // Also patch createConnection (TypeORM 0.2)
+  if (typeormModule.createConnection && !(typeormModule.createConnection as any).__trickle_patched) {
+    const origCreate = typeormModule.createConnection;
+    typeormModule.createConnection = function patchedCreateConnection(options: any) {
+      if (options && typeof options === 'object' && !options.logging) {
+        options.logging = true;
+      }
+      return origCreate(options);
+    };
+    (typeormModule.createConnection as any).__trickle_patched = true;
+  }
+
+  if (debug) console.log('[trickle/db] TypeORM query tracing enabled');
+}
+
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+export function patchSequelize(sequelizeModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const Sequelize = sequelizeModule.Sequelize || sequelizeModule.default || sequelizeModule;
+  if (!Sequelize || typeof Sequelize !== 'function' || (Sequelize as any).__trickle_patched) return;
+
+  const origConstructor = Sequelize;
+
+  const patchedSequelize = function (this: any, ...args: any[]) {
+    // Sequelize(uri, options) or Sequelize(database, user, pass, options)
+    let options: any;
+    if (args.length >= 4) {
+      options = args[3] = args[3] || {};
+    } else if (args.length >= 2 && typeof args[1] === 'object') {
+      options = args[1];
+    } else if (args.length === 1 && typeof args[0] === 'object') {
+      options = args[0];
+    } else {
+      options = {};
+      args.push(options);
+    }
+
+    // Wrap the logging function
+    const origLogging = options.logging;
+    options.logging = (sql: string, timing?: any) => {
+      const queryText = typeof sql === 'string' ? sql : String(sql);
+      // Sequelize prepends "Executed (default): " or "Executing (default): " to queries
+      const cleanQuery = queryText.replace(/^Execut(?:ed|ing) \([^)]*\):\s*/, '');
+      const durationMs = typeof timing === 'number' ? timing : 0;
+
+      writeQuery({
+        kind: 'query',
+        query: cleanQuery.substring(0, MAX_QUERY_LENGTH),
+        durationMs,
+        rowCount: 0,
+        timestamp: Date.now(),
+      });
+
+      // Call original logger
+      if (typeof origLogging === 'function') {
+        origLogging(sql, timing);
+      }
+    };
+    options.benchmark = true; // Enable timing in log
+
+    // Call original constructor
+    if (new.target) {
+      return new origConstructor(...args);
+    }
+    return origConstructor.apply(this, args);
+  };
+
+  // Copy prototype and statics
+  patchedSequelize.prototype = origConstructor.prototype;
+  Object.setPrototypeOf(patchedSequelize, origConstructor);
+  for (const key of Object.getOwnPropertyNames(origConstructor)) {
+    if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+      try {
+        Object.defineProperty(patchedSequelize, key, Object.getOwnPropertyDescriptor(origConstructor, key)!);
+      } catch {}
+    }
+  }
+
+  // Replace in module exports
+  if (sequelizeModule.Sequelize) {
+    sequelizeModule.Sequelize = patchedSequelize;
+  }
+  (patchedSequelize as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] Sequelize query tracing enabled');
+}
+
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

package/src/observe-register.ts

@@ -1188,6 +1188,51 @@ if (enabled) {
       } catch { /* not critical */ }
     }
 
+    // Prisma ORM
+    if (request === '@prisma/client' && !expressPatched.has('@prisma/client')) {
+      expressPatched.add('@prisma/client');
+      try {
+        const { patchPrisma } = require(path.join(__dirname, 'db-observer.js'));
+        patchPrisma(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Drizzle ORM
+    if (request.startsWith('drizzle-orm') && !expressPatched.has('drizzle-orm')) {
+      expressPatched.add('drizzle-orm');
+      try {
+        const { patchDrizzle } = require(path.join(__dirname, 'db-observer.js'));
+        patchDrizzle(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Knex query builder
+    if (request === 'knex' && !expressPatched.has('knex')) {
+      expressPatched.add('knex');
+      try {
+        const { patchKnex } = require(path.join(__dirname, 'db-observer.js'));
+        patchKnex(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // TypeORM
+    if (request === 'typeorm' && !expressPatched.has('typeorm')) {
+      expressPatched.add('typeorm');
+      try {
+        const { patchTypeORM } = require(path.join(__dirname, 'db-observer.js'));
+        patchTypeORM(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Sequelize
+    if (request === 'sequelize' && !expressPatched.has('sequelize')) {
+      expressPatched.add('sequelize');
+      try {
+        const { patchSequelize } = require(path.join(__dirname, 'db-observer.js'));
+        patchSequelize(exports, debug);
+      } catch { /* not critical */ }
+    }
+
     // Redis (ioredis)
     if (request === 'ioredis' && !expressPatched.has('ioredis')) {
       expressPatched.add('ioredis');