mnehmos.trace.mcp 1.0.0

package/dist/patterns/rest/middleware.js

@@ -0,0 +1,219 @@
+/**
+ * Middleware Detection
+ *
+ * Detects validation middleware in Express route handlers.
+ *
+ * @module patterns/rest/middleware
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+import { Node } from 'ts-morph';
+/**
+ * Known validation middleware patterns for different libraries
+ */
+const MIDDLEWARE_PATTERNS = [
+    // Zod-based validation
+    {
+        names: ['validateBody', 'zodValidate', 'zValidator'],
+        library: 'zod',
+        defaultTarget: 'body',
+        targetExtractor: extractTargetFromName,
+    },
+    {
+        names: ['validateQuery'],
+        library: 'zod',
+        defaultTarget: 'query',
+    },
+    {
+        names: ['validateParams'],
+        library: 'zod',
+        defaultTarget: 'params',
+    },
+    // Celebrate/Joi patterns
+    {
+        names: ['celebrate'],
+        library: 'celebrate',
+        defaultTarget: 'body',
+        targetExtractor: extractCelebrateTarget,
+    },
+    {
+        names: ['joiValidate', 'validateJoi'],
+        library: 'joi',
+        defaultTarget: 'body',
+        targetExtractor: extractTargetFromName,
+    },
+    // Express-validator
+    {
+        names: ['body', 'check'],
+        library: 'express-validator',
+        defaultTarget: 'body',
+    },
+    {
+        names: ['query'],
+        library: 'express-validator',
+        defaultTarget: 'query',
+    },
+    {
+        names: ['param'],
+        library: 'express-validator',
+        defaultTarget: 'params',
+    },
+    // Yup validation
+    {
+        names: ['yupValidate', 'validateYup'],
+        library: 'yup',
+        defaultTarget: 'body',
+        targetExtractor: extractTargetFromName,
+    },
+];
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 🔍 Public API
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Detect validation middleware from a list of route handler arguments.
+ *
+ * @param args - Array of AST nodes representing route handler arguments
+ * @returns Array of detected validation middleware
+ *
+ * @example
+ * ```typescript
+ * // For: app.post('/users', validateBody(CreateUserSchema), handler)
+ * const middleware = detectExpressMiddleware(args);
+ * // [{ library: 'zod', target: 'body', schemaNode: <node>, middlewareIndex: 1 }]
+ * ```
+ */
+export function detectExpressMiddleware(args) {
+    const middleware = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // Skip if not a call expression or identifier reference
+        if (!arg)
+            continue;
+        // Try to detect middleware from this argument
+        const detected = detectMiddlewareFromNode(arg, i);
+        if (detected) {
+            middleware.push(detected);
+        }
+    }
+    return middleware;
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 🔧 Detection Helpers
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Detect middleware from a single node.
+ *
+ * @param node - AST node to analyze
+ * @param index - Position in middleware chain
+ * @returns Detected middleware or null
+ */
+function detectMiddlewareFromNode(node, index) {
+    // Check for call expression: validateBody(schema)
+    if (Node.isCallExpression(node)) {
+        return detectFromCallExpression(node, index);
+    }
+    // Check for identifier that might be a pre-configured middleware
+    if (Node.isIdentifier(node)) {
+        // Could be a variable holding middleware, but we can't easily detect the library
+        return null;
+    }
+    return null;
+}
+/**
+ * Detect middleware from a call expression
+ */
+function detectFromCallExpression(call, index) {
+    const expression = call.getExpression();
+    // Get the function name
+    let functionName;
+    if (Node.isIdentifier(expression)) {
+        functionName = expression.getText();
+    }
+    else if (Node.isPropertyAccessExpression(expression)) {
+        // For patterns like validators.body() or z.validate()
+        functionName = expression.getName();
+    }
+    if (!functionName) {
+        return null;
+    }
+    // Find matching pattern
+    for (const pattern of MIDDLEWARE_PATTERNS) {
+        if (pattern.names.some(name => functionName?.toLowerCase().includes(name.toLowerCase()) ||
+            name.toLowerCase() === functionName?.toLowerCase())) {
+            // Extract target using pattern-specific extractor or use default
+            let target = pattern.defaultTarget;
+            if (pattern.targetExtractor) {
+                const extracted = pattern.targetExtractor(call);
+                if (extracted) {
+                    target = extracted;
+                }
+            }
+            // Get the schema node (usually the first argument)
+            const schemaArg = call.getArguments()[0];
+            if (schemaArg) {
+                return {
+                    library: pattern.library,
+                    target,
+                    schemaNode: schemaArg,
+                    middlewareIndex: index,
+                };
+            }
+        }
+    }
+    // Check for inline zod schema detection (z.object())
+    const text = call.getText();
+    if (text.includes('z.object') || text.includes('z.array') || text.includes('z.string')) {
+        return {
+            library: 'zod',
+            target: 'body', // Default, would need context to determine
+            schemaNode: call,
+            middlewareIndex: index,
+        };
+    }
+    return null;
+}
+/**
+ * Extract target from function name suffix
+ * e.g., validateBody -> body, validateQuery -> query
+ */
+function extractTargetFromName(call) {
+    const expression = call.getExpression();
+    const name = Node.isIdentifier(expression)
+        ? expression.getText().toLowerCase()
+        : Node.isPropertyAccessExpression(expression)
+            ? expression.getName().toLowerCase()
+            : '';
+    if (name.includes('body'))
+        return 'body';
+    if (name.includes('query'))
+        return 'query';
+    if (name.includes('param'))
+        return 'params';
+    if (name.includes('header'))
+        return 'headers';
+    return undefined;
+}
+/**
+ * Extract target from celebrate() configuration
+ * celebrate({ [Segments.BODY]: schema, [Segments.QUERY]: schema })
+ */
+function extractCelebrateTarget(call) {
+    const args = call.getArguments();
+    if (args.length === 0)
+        return undefined;
+    const configArg = args[0];
+    if (!Node.isObjectLiteralExpression(configArg))
+        return undefined;
+    // Check which segment is being validated
+    const text = configArg.getText();
+    // Look for Segments enum usage
+    if (text.includes('BODY') || text.includes('body'))
+        return 'body';
+    if (text.includes('QUERY') || text.includes('query'))
+        return 'query';
+    if (text.includes('PARAMS') || text.includes('params'))
+        return 'params';
+    if (text.includes('HEADERS') || text.includes('headers'))
+        return 'headers';
+    return 'body'; // Default to body for celebrate
+}
+//# sourceMappingURL=middleware.js.map

package/dist/patterns/rest/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../../src/patterns/rest/middleware.ts"],"names":[],"mappings":"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"}

package/dist/patterns/rest/path-parser.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Path Parser
+ *
+ * Parses Express/Fastify route paths and extracts path parameters.
+ *
+ * @module patterns/rest/path-parser
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+import type { PropertyDef } from '../../core/types.js';
+import type { PathParameter } from './types.js';
+/**
+ * Parse a route path and extract all path parameters.
+ *
+ * @param path - Route path like '/users/:id' or '/users/:userId/posts/:postId'
+ * @returns Array of parsed path parameters
+ *
+ * @example
+ * ```typescript
+ * parsePath('/users/:id');
+ * // [{ name: 'id', position: 1, optional: false, inferredType: 'string' }]
+ *
+ * parsePath('/users/:id(\\d+)?');
+ * // [{ name: 'id', position: 1, optional: true, pattern: '\\d+', inferredType: 'number' }]
+ * ```
+ */
+export declare function parsePath(path: string): PathParameter[];
+/**
+ * Convert path parameters to a schema properties object.
+ *
+ * @param params - Array of path parameters
+ * @returns Record of property definitions suitable for NormalizedSchema
+ *
+ * @example
+ * ```typescript
+ * const params = parsePath('/users/:id(\\d+)');
+ * const properties = pathParametersToSchema(params);
+ * // {
+ * //   id: {
+ * //     type: { kind: 'primitive', value: 'number' },
+ * //     optional: false,
+ * //     nullable: false,
+ * //     readonly: false,
+ * //     deprecated: false,
+ * //     constraints: { pattern: '\\d+' }
+ * //   }
+ * // }
+ * ```
+ */
+export declare function pathParametersToSchema(params: PathParameter[]): Record<string, PropertyDef>;
+//# sourceMappingURL=path-parser.d.ts.map

package/dist/patterns/rest/path-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-parser.d.ts","sourceRoot":"","sources":["../../../src/patterns/rest/path-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAqBhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CA6BvD;AAmCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CA4B7B"}

package/dist/patterns/rest/path-parser.js

@@ -0,0 +1,137 @@
+/**
+ * Path Parser
+ *
+ * Parses Express/Fastify route paths and extracts path parameters.
+ *
+ * @module patterns/rest/path-parser
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 📋 Constants
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Regular expression to match path parameters.
+ *
+ * Matches:
+ * - `:id` - simple parameter
+ * - `:id?` - optional parameter
+ * - `:id(\d+)` - regex constrained parameter
+ * - `:id(\d+)?` - optional regex constrained parameter
+ */
+const PATH_PARAM_REGEX = /:([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]+)\))?(\?)?/g;
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 🔍 Public API
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Parse a route path and extract all path parameters.
+ *
+ * @param path - Route path like '/users/:id' or '/users/:userId/posts/:postId'
+ * @returns Array of parsed path parameters
+ *
+ * @example
+ * ```typescript
+ * parsePath('/users/:id');
+ * // [{ name: 'id', position: 1, optional: false, inferredType: 'string' }]
+ *
+ * parsePath('/users/:id(\\d+)?');
+ * // [{ name: 'id', position: 1, optional: true, pattern: '\\d+', inferredType: 'number' }]
+ * ```
+ */
+export function parsePath(path) {
+    const params = [];
+    // Split path into segments to determine positions
+    const segments = path.split('/').filter(Boolean);
+    // Reset regex lastIndex
+    PATH_PARAM_REGEX.lastIndex = 0;
+    let match;
+    while ((match = PATH_PARAM_REGEX.exec(path)) !== null) {
+        const [fullMatch, name, pattern, optionalMark] = match;
+        // Find position by looking for the segment that contains this param
+        const position = segments.findIndex(seg => seg.includes(fullMatch) || seg.includes(`:${name}`));
+        // Infer type from pattern
+        const inferredType = inferTypeFromPattern(pattern);
+        params.push({
+            name,
+            position: position >= 0 ? position : params.length,
+            optional: optionalMark === '?',
+            pattern,
+            inferredType,
+        });
+    }
+    return params;
+}
+/**
+ * Infer the JavaScript type from a regex pattern.
+ *
+ * @param pattern - Regex pattern string (e.g., '\\d+', '[0-9]+')
+ * @returns Inferred type
+ */
+function inferTypeFromPattern(pattern) {
+    if (!pattern) {
+        return 'string';
+    }
+    // Patterns that indicate numeric type
+    const numericPatterns = [
+        /^\\d\+?$/, // \d or \d+
+        /^\\d\*$/, // \d*
+        /^\\d\{[\d,]+\}$/, // \d{4} or \d{1,3}
+        /^\[0-9\]\+?$/, // [0-9] or [0-9]+
+        /^\[0-9\]\*$/, // [0-9]*
+        /^\[0-9\]\{[\d,]+\}$/, // [0-9]{4}
+    ];
+    // Normalize the pattern for matching
+    const normalized = pattern.trim();
+    for (const numericPattern of numericPatterns) {
+        if (numericPattern.test(normalized)) {
+            return 'number';
+        }
+    }
+    return 'string';
+}
+/**
+ * Convert path parameters to a schema properties object.
+ *
+ * @param params - Array of path parameters
+ * @returns Record of property definitions suitable for NormalizedSchema
+ *
+ * @example
+ * ```typescript
+ * const params = parsePath('/users/:id(\\d+)');
+ * const properties = pathParametersToSchema(params);
+ * // {
+ * //   id: {
+ * //     type: { kind: 'primitive', value: 'number' },
+ * //     optional: false,
+ * //     nullable: false,
+ * //     readonly: false,
+ * //     deprecated: false,
+ * //     constraints: { pattern: '\\d+' }
+ * //   }
+ * // }
+ * ```
+ */
+export function pathParametersToSchema(params) {
+    const properties = {};
+    for (const param of params) {
+        const type = {
+            kind: 'primitive',
+            value: param.inferredType === 'number' ? 'number' : 'string',
+        };
+        const propDef = {
+            type,
+            optional: param.optional,
+            nullable: false,
+            readonly: false,
+            deprecated: false,
+        };
+        // Add pattern constraint if present
+        if (param.pattern) {
+            propDef.constraints = {
+                pattern: param.pattern,
+            };
+        }
+        properties[param.name] = propDef;
+    }
+    return properties;
+}
+//# sourceMappingURL=path-parser.js.map

package/dist/patterns/rest/path-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-parser.js","sourceRoot":"","sources":["../../../src/patterns/rest/path-parser.ts"],"names":[],"mappings":"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"}

package/dist/patterns/rest/response-inference.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Response Inference
+ *
+ * Infers response schema from handler function implementations.
+ *
+ * @module patterns/rest/response-inference
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+import { Node } from 'ts-morph';
+import type { ResponseInference } from './types.js';
+/**
+ * Infer the response schema from a handler function.
+ *
+ * Uses multiple strategies:
+ * 1. Explicit return type annotation
+ * 2. Generic type parameter on res.json<T>()
+ * 3. Analysis of res.json() argument structure
+ *
+ * @param handler - The handler function AST node
+ * @returns Response inference result with method and optional schema node
+ *
+ * @example
+ * ```typescript
+ * // Handler: (req, res) => res.json<ProfileResponse>({ id: '123', name: 'John' })
+ * const inference = inferResponseSchema(handler);
+ * // { method: 'generic-param', node: <ProfileResponse node> }
+ * ```
+ */
+export declare function inferResponseSchema(handler: Node | undefined): ResponseInference;
+/**
+ * Detect multiple response schemas by status code.
+ *
+ * @param handler - The handler function AST node
+ * @returns Map of status codes to response schema nodes
+ *
+ * @example
+ * ```typescript
+ * // Handler with res.status(200).json(ok) and res.status(400).json(error)
+ * const responses = detectMultipleResponses(handler);
+ * // Map { 200 => <ok node>, 400 => <error node> }
+ * ```
+ */
+export declare function detectMultipleResponses(handler: Node | undefined): Map<number, Node>;
+//# sourceMappingURL=response-inference.d.ts.map

package/dist/patterns/rest/response-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-inference.d.ts","sourceRoot":"","sources":["../../../src/patterns/rest/response-inference.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAA8B,MAAM,UAAU,CAAC;AAE5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,IAAI,GAAG,SAAS,GAAG,iBAAiB,CAwBhF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,IAAI,GAAG,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAmBpF"}