trickle-observe 0.2.94 → 0.2.96

package/dist/db-observer.d.ts

@@ -13,3 +13,21 @@
  * Called from observe-register when pg is required.
  */
 export declare function patchPg(pgModule: any, debug: boolean): void;
+/**
+ * Patch mysql2 to capture queries.
+ */
+export declare function patchMysql2(mysqlModule: any, debug: boolean): void;
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+export declare function patchBetterSqlite3(dbConstructor: any, debug: boolean): void;
+/**
+ * Patch ioredis to capture Redis commands.
+ * Called from observe-register when ioredis is required.
+ */
+export declare function patchIoredis(ioredisModule: any, debug: boolean): void;
+/**
+ * Patch mongoose to capture MongoDB operations.
+ * Called from observe-register when mongoose is required.
+ */
+export declare function patchMongoose(mongooseModule: any, debug: boolean): void;

package/dist/db-observer.js

@@ -44,6 +44,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchPg = patchPg;
+exports.patchMysql2 = patchMysql2;
+exports.patchBetterSqlite3 = patchBetterSqlite3;
+exports.patchIoredis = patchIoredis;
+exports.patchMongoose = patchMongoose;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 let queriesFile = null;
@@ -197,3 +201,190 @@ function patchPg(pgModule, debug) {
         console.log('[trickle/db] PostgreSQL query tracing enabled');
     }
 }
+/**
+ * Patch mysql2 to capture queries.
+ */
+function patchMysql2(mysqlModule, debug) {
+    debugMode = debug;
+    // Patch Connection.prototype.query and .execute
+    const Connection = mysqlModule.Connection;
+    if (!Connection || !Connection.prototype)
+        return;
+    for (const method of ['query', 'execute']) {
+        const original = Connection.prototype[method];
+        if (!original || original.__trickle_patched)
+            continue;
+        Connection.prototype[method] = function patchedMethod(...args) {
+            const startTime = performance.now();
+            let queryText = typeof args[0] === 'string' ? args[0] : args[0]?.sql || '';
+            const truncated = queryText.length > MAX_QUERY_LENGTH ? queryText.substring(0, MAX_QUERY_LENGTH) + '...' : queryText;
+            const result = original.apply(this, args);
+            if (result && typeof result.then === 'function') {
+                return result.then((res) => {
+                    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                    const rows = Array.isArray(res) ? res[0] : res;
+                    writeQuery({
+                        kind: 'query', query: truncated, durationMs,
+                        rowCount: Array.isArray(rows) ? rows.length : 0,
+                        columns: Array.isArray(rows) && rows[0] ? Object.keys(rows[0]) : undefined,
+                        timestamp: Date.now(),
+                    });
+                    return res;
+                }, (err) => {
+                    writeQuery({
+                        kind: 'query', query: truncated,
+                        durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                        rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+                    });
+                    throw err;
+                });
+            }
+            return result;
+        };
+        Connection.prototype[method].__trickle_patched = true;
+    }
+    if (debug)
+        console.log('[trickle/db] MySQL query tracing enabled');
+}
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+function patchBetterSqlite3(dbConstructor, debug) {
+    debugMode = debug;
+    // better-sqlite3 returns a Database constructor — patch its prototype
+    const origPrepare = dbConstructor.prototype?.prepare;
+    if (!origPrepare || origPrepare.__trickle_patched)
+        return;
+    dbConstructor.prototype.prepare = function patchedPrepare(sql) {
+        const stmt = origPrepare.call(this, sql);
+        const truncated = sql.length > MAX_QUERY_LENGTH ? sql.substring(0, MAX_QUERY_LENGTH) + '...' : sql;
+        // Patch run, get, all methods on the statement
+        for (const method of ['run', 'get', 'all']) {
+            const origMethod = stmt[method];
+            if (!origMethod)
+                continue;
+            stmt[method] = function (...args) {
+                const startTime = performance.now();
+                try {
+                    const result = origMethod.apply(this, args);
+                    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                    const rowCount = method === 'all' ? (Array.isArray(result) ? result.length : 0)
+                        : method === 'get' ? (result ? 1 : 0)
+                            : (result?.changes || 0);
+                    writeQuery({
+                        kind: 'query', query: truncated, durationMs, rowCount, timestamp: Date.now(),
+                    });
+                    return result;
+                }
+                catch (err) {
+                    writeQuery({
+                        kind: 'query', query: truncated,
+                        durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                        rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+                    });
+                    throw err;
+                }
+            };
+        }
+        return stmt;
+    };
+    dbConstructor.prototype.prepare.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] SQLite query tracing enabled');
+}
+/**
+ * Patch ioredis to capture Redis commands.
+ * Called from observe-register when ioredis is required.
+ */
+function patchIoredis(ioredisModule, debug) {
+    debugMode = debug;
+    const RedisClass = ioredisModule.default || ioredisModule;
+    const proto = RedisClass.prototype;
+    if (!proto || proto.sendCommand?.__trickle_patched)
+        return;
+    const origSendCommand = proto.sendCommand;
+    if (!origSendCommand)
+        return;
+    proto.sendCommand = function patchedSendCommand(command, ...rest) {
+        const cmdName = command?.name || 'UNKNOWN';
+        const cmdArgs = (command?.args || []).slice(0, 3).map((a) => typeof a === 'string' ? (a.length > 50 ? a.substring(0, 50) + '...' : a) : String(a).substring(0, 50));
+        const queryStr = `${cmdName.toUpperCase()} ${cmdArgs.join(' ')}`.trim();
+        const startTime = performance.now();
+        const result = origSendCommand.call(this, command, ...rest);
+        // ioredis returns a Promise
+        if (result && typeof result.then === 'function') {
+            result.then(() => {
+                writeQuery({
+                    kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+                    durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                    rowCount: 1, timestamp: Date.now(),
+                });
+            }, (err) => {
+                writeQuery({
+                    kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+                    durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                    rowCount: 0, error: err?.message?.substring(0, 200), timestamp: Date.now(),
+                });
+            });
+        }
+        return result;
+    };
+    proto.sendCommand.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] Redis (ioredis) query tracing enabled');
+}
+/**
+ * Patch mongoose to capture MongoDB operations.
+ * Called from observe-register when mongoose is required.
+ */
+function patchMongoose(mongooseModule, debug) {
+    debugMode = debug;
+    const Model = mongooseModule.Model;
+    if (!Model || Model.__trickle_patched)
+        return;
+    const methodsToWrap = [
+        'find', 'findOne', 'findById', 'findOneAndUpdate', 'findOneAndDelete',
+        'create', 'insertMany', 'updateOne', 'updateMany',
+        'deleteOne', 'deleteMany', 'countDocuments', 'aggregate',
+    ];
+    for (const method of methodsToWrap) {
+        const orig = Model[method];
+        if (!orig || orig.__trickle_patched)
+            continue;
+        Model[method] = function patchedMethod(...args) {
+            const collName = this.modelName || this.collection?.name || '?';
+            let filterStr = '';
+            if (args[0] && typeof args[0] === 'object') {
+                try {
+                    filterStr = ' ' + JSON.stringify(args[0]).substring(0, 200);
+                }
+                catch { }
+            }
+            const queryStr = `db.${collName}.${method}(${filterStr.trim()})`;
+            const startTime = performance.now();
+            const result = orig.apply(this, args);
+            // Mongoose methods return Query objects (thenables) or Promises
+            if (result && typeof result.then === 'function') {
+                result.then((res) => {
+                    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                    const rowCount = Array.isArray(res) ? res.length : (res ? 1 : 0);
+                    writeQuery({
+                        kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+                        durationMs, rowCount, timestamp: Date.now(),
+                    });
+                }, (err) => {
+                    writeQuery({
+                        kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+                        durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                        rowCount: 0, error: err?.message?.substring(0, 200), timestamp: Date.now(),
+                    });
+                });
+            }
+            return result;
+        };
+        Model[method].__trickle_patched = true;
+    }
+    Model.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] MongoDB (mongoose) query tracing enabled');
+}

package/dist/observe-register.js

@@ -1123,14 +1123,48 @@ if (enabled) {
             }
             catch { /* fall through to normal processing */ }
         }
-        // ── PostgreSQL auto-detection: patch pg to capture SQL queries ──
+        // ── Database auto-detection: patch database drivers to capture SQL queries ──
         if (request === 'pg' && !expressPatched.has('pg')) {
             expressPatched.add('pg');
             try {
                 const { patchPg } = require(path_1.default.join(__dirname, 'db-observer.js'));
                 patchPg(exports, debug);
             }
-            catch { /* pg observer not critical */ }
+            catch { /* not critical */ }
+        }
+        if ((request === 'mysql2' || request === 'mysql2/promise') && !expressPatched.has('mysql2')) {
+            expressPatched.add('mysql2');
+            try {
+                const { patchMysql2 } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchMysql2(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        if (request === 'better-sqlite3' && !expressPatched.has('better-sqlite3')) {
+            expressPatched.add('better-sqlite3');
+            try {
+                const { patchBetterSqlite3 } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchBetterSqlite3(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Redis (ioredis)
+        if (request === 'ioredis' && !expressPatched.has('ioredis')) {
+            expressPatched.add('ioredis');
+            try {
+                const { patchIoredis } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchIoredis(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // MongoDB (mongoose)
+        if (request === 'mongoose' && !expressPatched.has('mongoose')) {
+            expressPatched.add('mongoose');
+            try {
+                const { patchMongoose } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchMongoose(exports, debug);
+            }
+            catch { /* not critical */ }
         }
         // Resolve to absolute path for dedup — do this FIRST since bundlers like
         // tsx/esbuild may use path aliases (e.g., @config/env) that don't start

package/package.json

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

package/src/db-observer.ts

@@ -183,3 +183,211 @@ export function patchPg(pgModule: any, debug: boolean): void {
     console.log('[trickle/db] PostgreSQL query tracing enabled');
   }
 }
+
+/**
+ * Patch mysql2 to capture queries.
+ */
+export function patchMysql2(mysqlModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // Patch Connection.prototype.query and .execute
+  const Connection = mysqlModule.Connection;
+  if (!Connection || !Connection.prototype) return;
+
+  for (const method of ['query', 'execute'] as const) {
+    const original = Connection.prototype[method];
+    if (!original || (original as any).__trickle_patched) continue;
+
+    Connection.prototype[method] = function patchedMethod(...args: any[]): any {
+      const startTime = performance.now();
+      let queryText = typeof args[0] === 'string' ? args[0] : args[0]?.sql || '';
+      const truncated = queryText.length > MAX_QUERY_LENGTH ? queryText.substring(0, MAX_QUERY_LENGTH) + '...' : queryText;
+
+      const result = original.apply(this, args);
+      if (result && typeof result.then === 'function') {
+        return result.then(
+          (res: any) => {
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            const rows = Array.isArray(res) ? res[0] : res;
+            writeQuery({
+              kind: 'query', query: truncated, durationMs,
+              rowCount: Array.isArray(rows) ? rows.length : 0,
+              columns: Array.isArray(rows) && rows[0] ? Object.keys(rows[0]) : undefined,
+              timestamp: Date.now(),
+            });
+            return res;
+          },
+          (err: any) => {
+            writeQuery({
+              kind: 'query', query: truncated,
+              durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+              rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+            });
+            throw err;
+          },
+        );
+      }
+      return result;
+    };
+    (Connection.prototype[method] as any).__trickle_patched = true;
+  }
+
+  if (debug) console.log('[trickle/db] MySQL query tracing enabled');
+}
+
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+export function patchBetterSqlite3(dbConstructor: any, debug: boolean): void {
+  debugMode = debug;
+
+  // better-sqlite3 returns a Database constructor — patch its prototype
+  const origPrepare = dbConstructor.prototype?.prepare;
+  if (!origPrepare || (origPrepare as any).__trickle_patched) return;
+
+  dbConstructor.prototype.prepare = function patchedPrepare(sql: string): any {
+    const stmt = origPrepare.call(this, sql);
+    const truncated = sql.length > MAX_QUERY_LENGTH ? sql.substring(0, MAX_QUERY_LENGTH) + '...' : sql;
+
+    // Patch run, get, all methods on the statement
+    for (const method of ['run', 'get', 'all'] as const) {
+      const origMethod = stmt[method];
+      if (!origMethod) continue;
+      stmt[method] = function (...args: any[]): any {
+        const startTime = performance.now();
+        try {
+          const result = origMethod.apply(this, args);
+          const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+          const rowCount = method === 'all' ? (Array.isArray(result) ? result.length : 0)
+            : method === 'get' ? (result ? 1 : 0)
+            : (result?.changes || 0);
+          writeQuery({
+            kind: 'query', query: truncated, durationMs, rowCount, timestamp: Date.now(),
+          });
+          return result;
+        } catch (err: any) {
+          writeQuery({
+            kind: 'query', query: truncated,
+            durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+            rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+          });
+          throw err;
+        }
+      };
+    }
+    return stmt;
+  };
+  (dbConstructor.prototype.prepare as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] SQLite query tracing enabled');
+}
+
+/**
+ * Patch ioredis to capture Redis commands.
+ * Called from observe-register when ioredis is required.
+ */
+export function patchIoredis(ioredisModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const RedisClass = ioredisModule.default || ioredisModule;
+  const proto = RedisClass.prototype;
+  if (!proto || (proto.sendCommand as any)?.__trickle_patched) return;
+
+  const origSendCommand = proto.sendCommand;
+  if (!origSendCommand) return;
+
+  proto.sendCommand = function patchedSendCommand(command: any, ...rest: any[]): any {
+    const cmdName = command?.name || 'UNKNOWN';
+    const cmdArgs = (command?.args || []).slice(0, 3).map((a: any) =>
+      typeof a === 'string' ? (a.length > 50 ? a.substring(0, 50) + '...' : a) : String(a).substring(0, 50)
+    );
+    const queryStr = `${cmdName.toUpperCase()} ${cmdArgs.join(' ')}`.trim();
+
+    const startTime = performance.now();
+    const result = origSendCommand.call(this, command, ...rest);
+
+    // ioredis returns a Promise
+    if (result && typeof result.then === 'function') {
+      result.then(
+        () => {
+          writeQuery({
+            kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+            durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+            rowCount: 1, timestamp: Date.now(),
+          });
+        },
+        (err: any) => {
+          writeQuery({
+            kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+            durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+            rowCount: 0, error: err?.message?.substring(0, 200), timestamp: Date.now(),
+          });
+        }
+      );
+    }
+    return result;
+  };
+  (proto.sendCommand as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] Redis (ioredis) query tracing enabled');
+}
+
+/**
+ * Patch mongoose to capture MongoDB operations.
+ * Called from observe-register when mongoose is required.
+ */
+export function patchMongoose(mongooseModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const Model = mongooseModule.Model;
+  if (!Model || (Model as any).__trickle_patched) return;
+
+  const methodsToWrap = [
+    'find', 'findOne', 'findById', 'findOneAndUpdate', 'findOneAndDelete',
+    'create', 'insertMany', 'updateOne', 'updateMany',
+    'deleteOne', 'deleteMany', 'countDocuments', 'aggregate',
+  ];
+
+  for (const method of methodsToWrap) {
+    const orig = Model[method];
+    if (!orig || (orig as any).__trickle_patched) continue;
+
+    Model[method] = function patchedMethod(this: any, ...args: any[]): any {
+      const collName = this.modelName || this.collection?.name || '?';
+      let filterStr = '';
+      if (args[0] && typeof args[0] === 'object') {
+        try { filterStr = ' ' + JSON.stringify(args[0]).substring(0, 200); } catch {}
+      }
+      const queryStr = `db.${collName}.${method}(${filterStr.trim()})`;
+
+      const startTime = performance.now();
+      const result = orig.apply(this, args);
+
+      // Mongoose methods return Query objects (thenables) or Promises
+      if (result && typeof result.then === 'function') {
+        result.then(
+          (res: any) => {
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            const rowCount = Array.isArray(res) ? res.length : (res ? 1 : 0);
+            writeQuery({
+              kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+              durationMs, rowCount, timestamp: Date.now(),
+            });
+          },
+          (err: any) => {
+            writeQuery({
+              kind: 'query', query: queryStr.substring(0, MAX_QUERY_LENGTH),
+              durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+              rowCount: 0, error: err?.message?.substring(0, 200), timestamp: Date.now(),
+            });
+          }
+        );
+      }
+      return result;
+    };
+    (Model[method] as any).__trickle_patched = true;
+  }
+  (Model as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] MongoDB (mongoose) query tracing enabled');
+}

package/src/observe-register.ts

@@ -1113,13 +1113,45 @@ if (enabled) {
       } catch { /* fall through to normal processing */ }
     }
 
-    // ── PostgreSQL auto-detection: patch pg to capture SQL queries ──
+    // ── Database auto-detection: patch database drivers to capture SQL queries ──
     if (request === 'pg' && !expressPatched.has('pg')) {
       expressPatched.add('pg');
       try {
         const { patchPg } = require(path.join(__dirname, 'db-observer.js'));
         patchPg(exports, debug);
-      } catch { /* pg observer not critical */ }
+      } catch { /* not critical */ }
+    }
+    if ((request === 'mysql2' || request === 'mysql2/promise') && !expressPatched.has('mysql2')) {
+      expressPatched.add('mysql2');
+      try {
+        const { patchMysql2 } = require(path.join(__dirname, 'db-observer.js'));
+        patchMysql2(exports, debug);
+      } catch { /* not critical */ }
+    }
+    if (request === 'better-sqlite3' && !expressPatched.has('better-sqlite3')) {
+      expressPatched.add('better-sqlite3');
+      try {
+        const { patchBetterSqlite3 } = require(path.join(__dirname, 'db-observer.js'));
+        patchBetterSqlite3(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Redis (ioredis)
+    if (request === 'ioredis' && !expressPatched.has('ioredis')) {
+      expressPatched.add('ioredis');
+      try {
+        const { patchIoredis } = require(path.join(__dirname, 'db-observer.js'));
+        patchIoredis(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // MongoDB (mongoose)
+    if (request === 'mongoose' && !expressPatched.has('mongoose')) {
+      expressPatched.add('mongoose');
+      try {
+        const { patchMongoose } = require(path.join(__dirname, 'db-observer.js'));
+        patchMongoose(exports, debug);
+      } catch { /* not critical */ }
     }
 
     // Resolve to absolute path for dedup — do this FIRST since bundlers like