trickle-observe 0.2.107 → 0.2.108

package/dist/db-observer.d.ts

@@ -43,6 +43,17 @@ export declare function patchDrizzle(drizzleModule: any, debug: boolean): void;
  * 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

@@ -50,6 +50,8 @@ 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"));
@@ -523,6 +525,154 @@ function patchKnex(knexModule, debug) {
     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

@@ -1230,6 +1230,24 @@ if (enabled) {
             }
             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.107",
+  "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

@@ -533,6 +533,166 @@ export function patchKnex(knexModule: any, debug: boolean): void {
   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

@@ -1215,6 +1215,24 @@ if (enabled) {
       } 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');