@aimeloic/monkey-tester 5.0.2 → 5.0.4

package/htmlTemplate.js

@@ -17,7 +17,15 @@ function encodePayload(obj) {
 // The reciprocal decode runs inside each HTML template (see _decode below).
 // It is injected as a one-liner so every template is self-contained.
 
-const _decode = `function _decode(b64){return JSON.parse(decodeURIComponent(escape(atob(b64.replace(/\s+/g,'')))));}`;
+// Replace line 18 with this version:
+const _decode = `function _decode(b64) {
+  const binStr = atob(b64.replace(/\\s+/g, ''));
+  const bytes = new Uint8Array(binStr.length);
+  for (let i = 0; i < binStr.length; i++) {
+    bytes[i] = binStr.charCodeAt(i);
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
+}`;
 
 // ─── Runtime sandbox (injected into tester page) ─────────────────────────────
 function runtimeClientSandbox() {
@@ -33,8 +41,8 @@ function runtimeClientSandbox() {
 }
 
   const ENDPOINTS = _decode(
-    document.getElementById('__monkey_data__').getAttribute('data-payload')
-  );
+  document.getElementById('__monkey_data__').textContent.trim()
+);
 
   let currentKey = null;
 
@@ -454,8 +462,14 @@ async function handleRegister() {
 
 <script>
 // ── Unicode-safe decode ──────────────────────────────────────────────────────
+// Replace the old _decode function inside UI.dashboard with this:
 function _decode(b64) {
-  return JSON.parse(decodeURIComponent(escape(atob(b64.replace(/\s+/g, '')))));
+  const binStr = atob(b64.replace(/\s+/g, ''));
+  const bytes = new Uint8Array(binStr.length);
+  for (let i = 0; i < binStr.length; i++) {
+    bytes[i] = binStr.charCodeAt(i);
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
 }
 
 // BEFORE (Broken)

package/monkey.js

@@ -1,75 +1,129 @@
 'use strict';
 
-import { UI } from './htmlTemplate.js';
+import { UI, encodePayload } from './htmlTemplate.js';
 
 function inferType(name) {
   const n = name.toLowerCase();
-  if (n.includes('email')) return 'email';
-  if (n.includes('password') || n.includes('pass')) return 'password';
-  if (n.includes('date')) return 'date';
-  if (n.includes('age') || n.includes('price') || n.includes('quantity') || n.includes('stock') || n === 'id' || n.endsWith('id')) return 'number';
+  if (n.includes('email'))                               return 'email';
+  if (n.includes('password') || n.includes('pass'))      return 'password';
+  if (n.includes('date') || n.includes('birth'))         return 'date';
+  if (n.includes('phone') || n.includes('tel'))          return 'tel';
+  if (n.includes('url') || n.includes('website') || n.includes('link')) return 'url';
+  if (
+    n.includes('age')   || n.includes('price')  || n.includes('amount') ||
+    n.includes('count') || n.includes('qty')    || n.includes('quantity') ||
+    n.includes('stock') || n.includes('salary') || n.includes('total')   ||
+    (n === 'id')        || n.endsWith('_id')    || n.endsWith('Id')
+  )                                                     return 'number';
   return 'text';
 }
 
 function buildField(name) {
-  return { name, label: name.charAt(0).toUpperCase() + name.slice(1).replace(/([A-Z])/g, ' $1'), type: inferType(name), placeholder: `Enter ${name}` };
+  return {
+    name,
+    label: name.charAt(0).toUpperCase() + name.slice(1).replace(/([A-Z])/g, ' $1'),
+    type: inferType(name),
+    placeholder: 'Enter ' + name
+  };
 }
 
 function extractBodyFields(handler) {
   try {
     const source = handler.toString();
     if (!source || source.includes('[native code]')) return [];
+
     const seen = new Map();
     const destructRe = /(?:const|let|var)\s*\{\s*([^}]+)\s*\}\s*=\s*req\.body/g;
     let m;
     while ((m = destructRe.exec(source)) !== null) {
-      m[1].split(',').forEach(part => {
+      m[1].split(',').forEach(function(part) {
         const name = part.split(':')[0].split('=')[0].trim();
-        if (name && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) && !seen.has(name)) seen.set(name, buildField(name));
+        if (name && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) && !seen.has(name)) {
+          seen.set(name, buildField(name));
+        }
       });
     }
-    const accessRe = /req\.body\.([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+
+    const accessRe = /req\.body\.([a-zA-Z_$][a-zA-Z0-9_$]*)|req\.body\[['"]([a-zA-Z_$][a-zA-Z0-9_$]*)['"]]/g;
     while ((m = accessRe.exec(source)) !== null) {
-      const name = m[1]; if (name && !seen.has(name)) seen.set(name, buildField(name));
+      const name = m[1] || m[2];
+      if (name && !seen.has(name)) seen.set(name, buildField(name));
     }
+
     return Array.from(seen.values());
-  } catch { return []; }
+  } catch {
+    return [];
+  }
+}
+
+function fallbackFields(path) {
+  const p = path.toLowerCase();
+  if (p.includes('login') || p.includes('signin') || p.includes('auth/login'))    return ['email', 'password'].map(buildField);
+  if (p.includes('register') || p.includes('signup') || p.includes('auth/register')) return ['username', 'email', 'password'].map(buildField);
+  if (p.includes('user'))    return ['username', 'email', 'password'].map(buildField);
+  if (p.includes('product')) return ['name', 'price', 'stock'].map(buildField);
+  if (p.includes('order'))   return ['productId', 'quantity', 'address'].map(buildField);
+  return [];
 }
 
 function extractRouterPrefix(layer) {
   if (!layer.regexp) return '';
-  const m = [/^\^\\\/([^\\?$]+)/, /^\^\\\/([a-zA-Z0-9_/-]+)/].reduce((acc, re) => acc || re.exec(layer.regexp.source), null);
-  return m && m[1] ? '/' + m[1].replace(/\\\//g, '/').replace(/\\/g, '') : '';
+  const src = layer.regexp.source;
+  const patterns = [/^\^\\\/([^\\?$]+)/, /^\^\\\/([a-zA-Z0-9_/-]+)/];
+  for (var i = 0; i < patterns.length; i++) {
+    const m = patterns[i].exec(src);
+    if (m && m[1]) return '/' + m[1].replace(/\\\//g, '/').replace(/\\/g, '');
+  }
+  return '';
 }
 
-function parseStack(stack, detectedEndpoints, prefix = '') {
+function parseStack(stack, detectedEndpoints, prefix) {
   if (!Array.isArray(stack)) return;
-  for (const layer of stack) {
+
+  for (var i = 0; i < stack.length; i++) {
+    var layer = stack[i];
     if (layer.route) {
-      const rawPath = typeof layer.route.path === 'string' ? layer.route.path : (layer.route.path ? String(layer.route.path) : '');
-      const fullPath = (prefix + rawPath).replace(/\/+/g, '/') || '/';
+      var rawPath  = typeof layer.route.path === 'string' ? layer.route.path : (layer.route.path ? String(layer.route.path) : '');
+      var fullPath = (prefix + rawPath).replace(/\/+/g, '/') || '/';
+
       if (fullPath.startsWith('/api/tester')) continue;
 
-      const methods = Object.keys(layer.route.methods || {});
-      for (const method of methods) {
-        const httpMethod = method.toUpperCase();
-        const key = `${httpMethod}::${fullPath}`;
-        const pathParams = [];
-        const paramRe = /:([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
-        let pm;
-        while ((pm = paramRe.exec(fullPath)) !== null) {
-          pathParams.push({ name: pm[1], label: pm[1].charAt(0).toUpperCase() + pm[1].slice(1), placeholder: 'value' });
-        }
+      var methods    = Object.keys(layer.route.methods || {});
+      var pathParams = [];
+      var paramRe    = /:([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+      var pm;
+      while ((pm = paramRe.exec(fullPath)) !== null) {
+        pathParams.push({ name: pm[1], label: pm[1].charAt(0).toUpperCase() + pm[1].slice(1), placeholder: 'value' });
+      }
 
-        let bodyFields = [];
-        if (['POST', 'PUT', 'PATCH'].includes(httpMethod)) {
-          const handlers = (layer.route.stack || []).map(sl => sl.handle).filter(Boolean);
-          for (const handler of handlers) bodyFields.push(...extractBodyFields(handler));
-          const seen = new Map();
-          bodyFields = bodyFields.filter(f => !seen.has(f.name) && seen.set(f.name, true));
+      var bodyFields = [];
+      if (methods.some(function(m) { return ['POST', 'PUT', 'PATCH'].indexOf(m.toUpperCase()) !== -1; })) {
+        var handlers = (layer.route.stack || []).map(function(sl) { return sl.handle; }).filter(Boolean);
+        for (var j = 0; j < handlers.length; j++) {
+          bodyFields.push.apply(bodyFields, extractBodyFields(handlers[j]));
         }
+        var seen2 = new Map();
+        bodyFields = bodyFields.filter(function(f) {
+          if (seen2.has(f.name)) return false;
+          seen2.set(f.name, true);
+          return true;
+        });
+        if (bodyFields.length === 0 && pathParams.length === 0) {
+          bodyFields = fallbackFields(fullPath);
+        }
+      }
 
-        detectedEndpoints[key] = { method: httpMethod, path: fullPath, title: `${httpMethod} ${fullPath}`, desc: `Auto-discovered endpoint - ${fullPath}`, params: pathParams, fields: bodyFields };
+      for (var k = 0; k < methods.length; k++) {
+        var httpMethod = methods[k].toUpperCase();
+        var key        = httpMethod + '::' + fullPath;
+        detectedEndpoints[key] = {
+          method: httpMethod,
+          path:   fullPath,
+          title:  httpMethod + ' ' + fullPath,
+          desc:   'Auto-discovered endpoint — ' + fullPath,
+          params: pathParams,
+          fields: bodyFields
+        };
       }
     } else if (layer.name === 'router' && layer.handle && layer.handle.stack) {
       parseStack(layer.handle.stack, detectedEndpoints, prefix + extractRouterPrefix(layer));
@@ -79,26 +133,40 @@ function parseStack(stack, detectedEndpoints, prefix = '') {
 
 export function endtesterExpress() {
   return function monkeyTesterMiddleware(req, res, next) {
-    const route = req.path.toLowerCase().replace(/\/$/, '');
-
-    // 1. Serve Standalone Frontend Templates Interceptions
-    if (route === '/login') return res.send(UI.login());
-    if (route === '/signup') return res.send(UI.signup());
-    if (route === '/dashboard') return res.send(UI.dashboard());
-
-    // 2. Serve the main Tester UI environment
-    if (route === '/api/tester') {
-      const app = req.app;
-      const detectedEndpoints = {};
-      const rootStack = (app._router && app._router.stack) || (app.router && app.router.stack) || [];
-      parseStack(rootStack, detectedEndpoints);
-      const b64 = Buffer.from(JSON.stringify(detectedEndpoints)).toString('base64');
+    var normalized = req.path.replace(/\/+$/, '');
+
+    // Tester sandbox — must be checked before static pages so query strings don't collide
+    if (normalized.startsWith('/api/tester')) {
+      var app  = req.app;
+      var eps  = app.__monkey_endpoints_cache__ || {};
+      if (!app.__monkey_endpoints_cache__) {
+        eps  = {};
+        var raw = (app._router && app._router.stack) || (app.router && app.router.stack) || [];
+        parseStack(raw, eps);
+        app.__monkey_endpoints_cache__ = eps;
+      }
+      var b64 = encodePayload(eps);
       res.setHeader('Content-Type', 'text/html; charset=utf-8');
       return res.send(UI.tester(b64));
     }
 
+    // Standalone HTML pages — resolved dynamically against discovered routes
+    if (normalized === '/login')    return res.send(UI.login());
+    if (normalized === '/signup')   return res.send(UI.signup());
+   if (normalized === '/dashboard') {
+  if (!app.__monkey_endpoints_cache__) {
+    var eps2 = {};
+    var raw2 = (app._router && app._router.stack) || (app.router && app.router.stack) || [];
+    parseStack(raw2, eps2);
+    app.__monkey_endpoints_cache__ = eps2;
+  }
+  var b64dash = encodePayload(app.__monkey_endpoints_cache__);
+  res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  return res.send(UI.dashboard(b64dash));
+}
+
     next();
   };
 }
 
-export default { endtesterExpress };
+export default { endtesterExpress };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aimeloic/monkey-tester",
-  "version": "5.0.2",
+  "version": "5.0.4",
   "description": "Auto route scanning visual runner dashboard.",
   "main": "index.js",
   "type": "module",