trickle-observe 0.2.66 → 0.2.68

package/dist/observe-register.js

@@ -418,6 +418,48 @@ function transformCjsSource(source, filename, moduleName, env) {
             continue;
         insertions.push({ position: closeBrace + 1, name, paramNames });
     }
+    // Find class declarations and wrap their methods
+    const classRegex = /^[ \t]*class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:extends\s+[a-zA-Z_$.]+\s*)?\{/gm;
+    const classInsertions = [];
+    let classMatch;
+    while ((classMatch = classRegex.exec(source)) !== null) {
+        const className = classMatch[1];
+        const classOpenBrace = source.indexOf('{', classMatch.index + classMatch[0].length - 1);
+        if (classOpenBrace === -1)
+            continue;
+        const classCloseBrace = findClosingBrace(source, classOpenBrace);
+        if (classCloseBrace === -1)
+            continue;
+        // Extract methods from the class body
+        const classBody = source.slice(classOpenBrace + 1, classCloseBrace);
+        // Match: methodName(params) { or async methodName(params) { or static methodName(params) {
+        const methodRegex = /^[ \t]*(static\s+)?(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(([^)]*)\)\s*\{/gm;
+        let methodMatch;
+        while ((methodMatch = methodRegex.exec(classBody)) !== null) {
+            const isStatic = !!methodMatch[1];
+            const methodName = methodMatch[2];
+            // Skip constructor and private methods
+            if (methodName === 'constructor' || methodName.startsWith('_'))
+                continue;
+            // Extract param names
+            const mParamStr = methodMatch[3].trim();
+            const mParamNames = mParamStr
+                ? mParamStr.split(',').map((p) => {
+                    const trimmed = p.trim().split('=')[0].trim().split(':')[0].trim();
+                    if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('...'))
+                        return '';
+                    return trimmed;
+                }).filter(Boolean)
+                : [];
+            const target = isStatic ? className : `${className}.prototype`;
+            const obsName = `${className}.${methodName}`;
+            const paramNamesArg = mParamNames.length > 0 ? JSON.stringify(mParamNames) : 'null';
+            classInsertions.push({
+                position: classCloseBrace + 1,
+                code: `\ntry{${target}.${methodName}=__trickle_wrap(${target}.${methodName},'${obsName}',${paramNamesArg})}catch(__e){}\n`,
+            });
+        }
+    }
     // Also find variable declarations for tracing
     const varTraceEnabled = process.env.TRICKLE_TRACE_VARS !== '0';
     // For TypeScript files (compiled by ts-node/tsc), type declarations (interfaces, type aliases)
@@ -496,7 +538,7 @@ function transformCjsSource(source, filename, moduleName, env) {
             destructInsertions = findDestructuredDeclarations(source);
         }
     }
-    if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0)
+    if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && classInsertions.length === 0)
         return source;
     // Resolve the path to the wrap helper (compiled JS)
     const wrapHelperPath = path_1.default.join(__dirname, 'wrap.js');
@@ -546,6 +588,10 @@ function transformCjsSource(source, filename, moduleName, env) {
             code: `\n;try{${calls}}catch(__e){}\n`,
         });
     }
+    // Add class method wrappings
+    for (const ci of classInsertions) {
+        allInsertions.push(ci);
+    }
     // Sort by position descending (insert from end to preserve earlier positions)
     allInsertions.sort((a, b) => b.position - a.position);
     let result = source;

package/observe-esm-hooks.mjs

@@ -523,7 +523,21 @@ function transformSource(source, url, originalSource) {
       const paramNames = parenPos >= 0 ? extractParamNamesFromSource(source, parenPos) : [];
       // Remove 'export ' prefix, keep the function
       result.push(line.replace(/^(\s*)export\s+/, '$1'));
-      exportedFunctions.push({ name, paramNames });
+      exportedFunctions.push({ name, paramNames, wrapInPlace: true });
+      continue;
+    }
+
+    // Non-exported function declarations — wrap them too for entry module coverage
+    const plainFuncMatch = trimmed.match(/^(async\s+)?function\s+(\w+)\s*(?:<[^>]*>)?\s*\(/);
+    if (plainFuncMatch && !trimmed.startsWith('export')) {
+      const name = plainFuncMatch[2];
+      if (name !== 'require' && name !== 'exports' && name !== 'module' && !name.startsWith('__trickle')) {
+        const srcOffset = lineOffset(source, i) + (line.length - trimmed.length);
+        const parenPos = source.indexOf('(', srcOffset + plainFuncMatch[0].indexOf('('));
+        const paramNames = parenPos >= 0 ? extractParamNamesFromSource(source, parenPos) : [];
+        exportedFunctions.push({ name, paramNames, wrapInPlace: true, noExport: true });
+      }
+      result.push(line);
       continue;
     }
 
@@ -607,23 +621,58 @@ function transformSource(source, url, originalSource) {
     return source;
   }
 
-  // Add wrapper import and wrapping code at the bottom
+  // Add wrapper import and wrapping code
   const wrapperPathEscaped = config.wrapperPath.replace(/\\/g, '\\\\');
 
-  result.push('');
-  result.push('// [trickle] Auto-observation wrappers');
-  result.push(`import { createRequire as __cr } from 'node:module';`);
-  result.push(`const __require = __cr(import.meta.url);`);
-  result.push(`const { wrapFunction: __tw } = __require('${wrapperPathEscaped}');`);
-  result.push(`const __twOpts = (name, paramNames) => { const o = { functionName: name, module: '${moduleName}', trackArgs: true, trackReturn: true, sampleRate: 1, maxDepth: 5, environment: process.env.TRICKLE_ENV || 'development', enabled: true }; if (paramNames && paramNames.length) o.paramNames = paramNames; return o; };`);
+  // Insert wrapper setup at the top (after imports, before user code)
+  // Using import + createRequire to load CJS wrapper from ESM context
+  const wrapSetup = [
+    '',
+    '// [trickle] Auto-observation wrappers',
+    `import { createRequire as __cr } from 'node:module';`,
+    `const __require = __cr(import.meta.url);`,
+    `const { wrapFunction: __tw } = __require('${wrapperPathEscaped}');`,
+    `const __twOpts = (name, paramNames) => { const o = { functionName: name, module: '${moduleName}', trackArgs: true, trackReturn: true, sampleRate: 1, maxDepth: 5, environment: process.env.TRICKLE_ENV || 'development', enabled: true }; if (paramNames && paramNames.length) o.paramNames = paramNames; return o; };`,
+  ];
+
+  // For in-place wrapping: insert wrapper calls right after each function declaration
+  // This ensures functions are wrapped BEFORE any top-level code calls them
+  const inPlaceWraps = [];
+  for (const fn of exportedFunctions) {
+    if (fn.wrapInPlace) {
+      const pn = fn.paramNames.length > 0 ? JSON.stringify(fn.paramNames) : 'null';
+      inPlaceWraps.push(`try{${fn.name}=__tw(${fn.name},__twOpts('${fn.name}',${pn}))}catch(__e){}`);
+    }
+  }
 
-  // Wrap and re-export named functions
+  // Find the right position to insert the wrap setup + in-place wraps
+  // Insert after the last import/function-declaration block, before top-level code
+  let insertIdx = 0;
+  for (let j = 0; j < result.length; j++) {
+    const t = result[j].trimStart();
+    if (t.startsWith('import ') || t.startsWith('// [trickle]') || t === '' ||
+        t.startsWith('function ') || t.startsWith('async function ') ||
+        t.startsWith('const __trickle_tv') || t.startsWith('const __require_tv') ||
+        t.startsWith('const __tv_mod') || t.startsWith('if (typeof __tv_mod')) {
+      insertIdx = j + 1;
+    }
+  }
+  // But make sure we're after any function body closing braces too
+  // Simple heuristic: find the last line that's just '}' before any assignment/call
+  for (let j = insertIdx; j < result.length; j++) {
+    const t = result[j].trim();
+    if (t === '}') insertIdx = j + 1;
+    else if (t && !t.startsWith('//') && !t.startsWith('function') && !t.startsWith('async function')) break;
+  }
+
+  result.splice(insertIdx, 0, ...wrapSetup, ...inPlaceWraps, '');
+
+  // Re-export wrapped functions (for importers of this module)
   const reExports = [];
-  for (const { name, paramNames } of exportedFunctions) {
-    const wrappedName = `__trickle_${name}`;
-    const pn = paramNames.length > 0 ? JSON.stringify(paramNames) : 'null';
-    result.push(`const ${wrappedName} = typeof ${name} === 'function' ? __tw(${name}, __twOpts('${name}', ${pn})) : ${name};`);
-    reExports.push(`${wrappedName} as ${name}`);
+  for (const fn of exportedFunctions) {
+    if (!fn.noExport) {
+      reExports.push(`${fn.name}`);
+    }
   }
 
   // Handle named exports from export { } statements
@@ -703,10 +752,11 @@ export async function load(url, context, nextLoad) {
     ? source
     : Buffer.from(source).toString('utf-8');
 
-  // Only transform if the module has exports or variable declarations to trace
+  // Only transform if the module has exports, function declarations, or variable declarations to trace
   const varTraceEnabled = process.env.TRICKLE_TRACE_VARS !== '0' && config.traceVarPath;
   const hasVarDecls = varTraceEnabled && /^[ \t]*(?:export\s+)?(?:const|let|var)\s+[a-zA-Z_$]/m.test(sourceStr);
-  if (!sourceStr.includes('export ') && !hasVarDecls) return result;
+  const hasFuncDecls = /^[ \t]*(?:export\s+)?(?:async\s+)?function\s+\w/m.test(sourceStr);
+  if (!sourceStr.includes('export ') && !hasVarDecls && !hasFuncDecls) return result;
 
   try {
     const transformed = transformSource(sourceStr, url);

package/package.json

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

package/src/observe-register.ts

@@ -389,6 +389,46 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     insertions.push({ position: closeBrace + 1, name, paramNames });
   }
 
+  // Find class declarations and wrap their methods
+  const classRegex = /^[ \t]*class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:extends\s+[a-zA-Z_$.]+\s*)?\{/gm;
+  const classInsertions: Array<{ position: number; code: string }> = [];
+  let classMatch;
+  while ((classMatch = classRegex.exec(source)) !== null) {
+    const className = classMatch[1];
+    const classOpenBrace = source.indexOf('{', classMatch.index + classMatch[0].length - 1);
+    if (classOpenBrace === -1) continue;
+    const classCloseBrace = findClosingBrace(source, classOpenBrace);
+    if (classCloseBrace === -1) continue;
+
+    // Extract methods from the class body
+    const classBody = source.slice(classOpenBrace + 1, classCloseBrace);
+    // Match: methodName(params) { or async methodName(params) { or static methodName(params) {
+    const methodRegex = /^[ \t]*(static\s+)?(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(([^)]*)\)\s*\{/gm;
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(classBody)) !== null) {
+      const isStatic = !!methodMatch[1];
+      const methodName = methodMatch[2];
+      // Skip constructor and private methods
+      if (methodName === 'constructor' || methodName.startsWith('_')) continue;
+      // Extract param names
+      const mParamStr = methodMatch[3].trim();
+      const mParamNames = mParamStr
+        ? mParamStr.split(',').map((p: string) => {
+            const trimmed = p.trim().split('=')[0].trim().split(':')[0].trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('...')) return '';
+            return trimmed;
+          }).filter(Boolean)
+        : [];
+      const target = isStatic ? className : `${className}.prototype`;
+      const obsName = `${className}.${methodName}`;
+      const paramNamesArg = mParamNames.length > 0 ? JSON.stringify(mParamNames) : 'null';
+      classInsertions.push({
+        position: classCloseBrace + 1,
+        code: `\ntry{${target}.${methodName}=__trickle_wrap(${target}.${methodName},'${obsName}',${paramNamesArg})}catch(__e){}\n`,
+      });
+    }
+  }
+
   // Also find variable declarations for tracing
   const varTraceEnabled = process.env.TRICKLE_TRACE_VARS !== '0';
 
@@ -468,7 +508,7 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     }
   }
 
-  if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0) return source;
+  if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && classInsertions.length === 0) return source;
 
   // Resolve the path to the wrap helper (compiled JS)
   const wrapHelperPath = path.join(__dirname, 'wrap.js');
@@ -531,6 +571,11 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     });
   }
 
+  // Add class method wrappings
+  for (const ci of classInsertions) {
+    allInsertions.push(ci);
+  }
+
   // Sort by position descending (insert from end to preserve earlier positions)
   allInsertions.sort((a, b) => b.position - a.position);