@opensip-cli/checks-typescript 0.1.0

package/dist/checks/resilience/context-mutation.js

@@ -0,0 +1,368 @@
+// @fitness-ignore-file unused-config-options -- Config options reserved for future use or environment-specific
+// @fitness-ignore-file context-mutation -- Local array/object mutations are safe within function scope; not shared context
+// @fitness-ignore-file silent-early-returns -- Guard clauses in pattern matching function return false for non-matching patterns
+/**
+ * @fileoverview Context mutation safety check — flags direct mutation of
+ * request/execution context objects, which causes side effects across
+ * middleware in concurrent server environments.
+ */
+import { logger } from '@opensip-cli/core';
+import { defineCheck, isCommentLine } from '@opensip-cli/fitness';
+// =============================================================================
+// CONTEXT MUTATION CHECK
+// =============================================================================
+/**
+ * Safe string patterns for checking context objects.
+ * Using string includes for safe, linear-time matching.
+ */
+const CONTEXT_STRING_PATTERNS = [
+    'request.context',
+    'request.ctx',
+    'req.context',
+    'req.ctx',
+    'ctx.',
+    'context.',
+    'RequestContext',
+    'ExecutionContext',
+];
+/**
+ * Checks if content uses context patterns.
+ * @param content - The content to check
+ * @returns True if content contains context patterns
+ */
+function usesContextPattern(content) {
+    return CONTEXT_STRING_PATTERNS.some((pattern) => content.includes(pattern));
+}
+/**
+ * Detects local declarations of `ctx` or `context` as a function-scoped
+ * variable — `const ctx = {...}`, `const ctx: T = {...}`, `let ctx`,
+ * `var ctx`. When such a declaration exists in the file, every
+ * subsequent `ctx.X =` mutation is a local-object-construction
+ * pattern, NOT a mutation of a shared request context. Skipping those
+ * lines eliminates the canonical false-positive where a function
+ * builds a return object named `ctx` and the check flags it as
+ * request-context mutation.
+ *
+ * Whole-word matching prevents collisions with `myCtx`, `subContext`,
+ * etc. Returns the set of identifier names that are locally declared
+ * — callers consult it before flagging a mutation rooted at that
+ * identifier.
+ */
+const LOCAL_DECLARATION_PATTERNS = [
+    ['ctx', /\b(?:const|let|var)\s+ctx\b(?!\s*\.)/],
+    ['context', /\b(?:const|let|var)\s+context\b(?!\s*\.)/],
+];
+function findLocallyDeclaredNames(content) {
+    const declared = new Set();
+    for (const [name, pattern] of LOCAL_DECLARATION_PATTERNS) {
+        if (pattern.test(content))
+            declared.add(name);
+    }
+    return declared;
+}
+/**
+ * Finds the end index of a word (consecutive word characters) in a string.
+ * @param str - The string to search
+ * @returns The index after the last word character, or 0 if no word characters found
+ */
+function findWordEndIndex(str) {
+    logger.debug({
+        evt: 'fitness.checks.context_mutation.find_word_end_index',
+        msg: 'Finding end index of word characters in string',
+    });
+    let wordEnd = 0;
+    // eslint-disable-next-line unicorn/no-for-loop -- offset-bearing scan: returns the UTF-16 index after the last word char
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === undefined || !/\w/.test(char)) {
+            return wordEnd;
+        }
+        wordEnd = i + 1;
+    }
+    return wordEnd;
+}
+/**
+ * Creates a safe mutation detector using string matching.
+ * Detects patterns like: ctx.property = or context.field =
+ * Does NOT match comparison operators (==, ===, !=, !==)
+ * @param prefix - The prefix to match (e.g., 'ctx.')
+ * @returns A detector that checks for assignment after prefix and word
+ */
+function createAssignmentDetector(prefix) {
+    return {
+        test: (line) => {
+            logger.debug({
+                evt: 'fitness.checks.context_mutation.assignment_detector_test',
+                msg: 'Testing line for context assignment mutation',
+            });
+            const idx = line.indexOf(prefix);
+            if (idx === -1)
+                return false;
+            // Find next non-word character after prefix
+            const afterPrefix = line.slice(Math.max(0, idx + prefix.length));
+            // Must have at least one word character
+            const wordEnd = findWordEndIndex(afterPrefix);
+            if (wordEnd === 0)
+                return false;
+            const afterWord = afterPrefix.slice(Math.max(0, wordEnd)).trimStart();
+            // Check for assignment (but NOT comparison operators)
+            if (!afterWord.startsWith('='))
+                return false;
+            // Exclude === and == (comparison) and !=, !==
+            const secondChar = afterWord.charAt(1);
+            if (secondChar === '=' || secondChar === '!')
+                return false;
+            return true;
+        },
+        patternName: `${prefix}*=`,
+    };
+}
+/**
+ * Creates a simple string contains detector.
+ * @param pattern - The string pattern to match
+ * @returns A detector that checks for pattern inclusion
+ */
+function createContainsDetector(pattern) {
+    return {
+        test: (line) => line.includes(pattern),
+        patternName: pattern,
+    };
+}
+/**
+ * Creates a detector for array mutation methods on context objects.
+ * Only matches patterns like ctx.array.push() or context.items.splice()
+ * Does NOT match local variables like myArray.push()
+ * @param method - The method name (e.g., 'push', 'splice')
+ * @returns A detector that checks for context-prefixed array mutations
+ */
+function createContextArrayMutationDetector(method) {
+    const contextPrefixes = [
+        'ctx.',
+        'context.',
+        'req.context.',
+        'request.context.',
+        'req.',
+        'request.',
+    ];
+    return {
+        test: (line) => {
+            logger.debug({
+                evt: 'fitness.checks.context_mutation.array_mutation_detector_test',
+                msg: 'Testing line for context array mutation pattern',
+            });
+            // Must contain the method call
+            if (!line.includes(`.${method}(`))
+                return false;
+            // Check if it's prefixed by a context variable
+            for (const prefix of contextPrefixes) {
+                const prefixIdx = line.indexOf(prefix);
+                if (prefixIdx !== -1) {
+                    // Check if the method call is after the context prefix
+                    const methodIdx = line.indexOf(`.${method}(`, prefixIdx);
+                    if (methodIdx > prefixIdx) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        },
+        patternName: `ctx/*.${method}()`,
+    };
+}
+/**
+ * Safe mutation detectors using string-based matching.
+ * Only flags mutations on actual context objects, not local variables.
+ */
+const MUTATION_DETECTORS = [
+    createAssignmentDetector('ctx.'),
+    createAssignmentDetector('context.'),
+    createAssignmentDetector('req.context.'),
+    createAssignmentDetector('request.context.'),
+    createContainsDetector('Object.assign(ctx'),
+    createContainsDetector('Object.assign( ctx'),
+    createContainsDetector('Object.assign(context'),
+    createContainsDetector('Object.assign( context'),
+    // Only flag array mutations when prefixed by context objects
+    createContextArrayMutationDetector('push'),
+    createContextArrayMutationDetector('splice'),
+    createContextArrayMutationDetector('pop'),
+    createContextArrayMutationDetector('shift'),
+    createContextArrayMutationDetector('unshift'),
+    createContainsDetector('delete ctx.'),
+    createContainsDetector('delete context.'),
+];
+/**
+ * Safe keywords (allowed mutations).
+ * These are common fields that are either:
+ * - Standard context setup fields that are expected to be set
+ * - Fields that indicate local object construction, not request context mutation
+ */
+const SAFE_KEYWORDS = [
+    'correlationId',
+    'requestId',
+    'traceId',
+    'spanId',
+    'logger',
+    'startTime',
+    // Common local context construction patterns
+    'userId', // User ID setup in local context objects
+    'timestamp', // Timestamp field in local context
+    'details', // Details field in error/result context
+    'metadata', // Metadata field in local context
+    'statusCode', // Status code in error context
+    'code', // Error code in error context
+    // Recovery/retry execution context fields
+    'fallbackAttempts', // Used in recovery/retry execution contexts
+    'lastError', // Used in retry execution contexts
+    'strategy', // Used in retry execution contexts
+    'retryAttempts', // Used in retry execution contexts
+    // Validation context fields
+    'schemaName', // Used in validation contexts
+    // Ticket/build context fields
+    'git', // Used in ticket/build context
+    'environment', // Used in ticket/build context
+    // Search relevance context fields
+    'userPreferences', // Used in search relevance context
+    'boosts', // Used in search relevance context
+    // Fitness check analysis context fields
+    'violations', // Used in fitness check analysis contexts
+];
+/**
+ * Safe context prefixes that indicate non-request context objects.
+ * These are local/scoped context objects, not shared request contexts.
+ */
+const SAFE_CONTEXT_PREFIXES = [
+    'entry.context', // Log entry context (per-entry metadata)
+    'logEntry.context', // Log entry context
+    'this.context', // Builder pattern on class instances
+    'result.context', // Result/response context
+    'error.context', // Error context builder
+    'config.context', // Configuration context
+    'options.context', // Options object context
+    'params.context', // Parameters context
+    'state.context', // Local state context
+    'item.context', // Item/element context
+    'record.context', // Record context
+    'event.context', // Event context
+];
+/**
+ * Checks if a line contains safe mutation patterns.
+ * @param line - The line to check
+ * @returns True if line contains safe patterns
+ */
+function isSafeMutation(line) {
+    logger.debug({
+        evt: 'fitness.checks.context_mutation.is_safe_mutation',
+        msg: 'Checking if line contains safe mutation patterns',
+    });
+    // Check for safe keywords
+    if (SAFE_KEYWORDS.some((keyword) => line.includes(keyword))) {
+        return true;
+    }
+    // Check for safe context prefixes (non-request context objects)
+    if (SAFE_CONTEXT_PREFIXES.some((prefix) => line.includes(prefix))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Find a mutation detector that matches the line.
+ * @param line - The line to check.
+ * @returns The matching detector and whether it's a safe mutation, or null if no match.
+ */
+function findMutationMatch(line) {
+    for (const detector of MUTATION_DETECTORS) {
+        if (detector.test(line)) {
+            return { detector, isSafe: isSafeMutation(line) };
+        }
+    }
+    return null;
+}
+/**
+ * Check if the mutation is defensive (inside a try block).
+ * @param lines - All lines of the file.
+ * @param index - Current line index.
+ * @returns True if the mutation is in a try block.
+ */
+function isDefensiveMutation(lines, index) {
+    if (!Array.isArray(lines)) {
+        return false;
+    }
+    const contextBefore = lines.slice(Math.max(0, index - 5), index).join('\n');
+    return contextBefore.includes('try');
+}
+/**
+ * Pure analysis function. Exported so unit tests can exercise the
+ * detection logic without standing up the full Check framework
+ * (defineCheck wraps `analyze` into an `execute` closure that requires
+ * an ExecutionContext to invoke).
+ */
+export function analyzeContextMutation(content, filePath) {
+    logger.debug({
+        evt: 'fitness.checks.context_mutation.context_mutation_check_analyze',
+        msg: 'Analyzing file for unsafe context mutations',
+    });
+    const violations = [];
+    if (!usesContextPattern(content))
+        return violations;
+    const locallyDeclared = findLocallyDeclaredNames(content);
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined || !line)
+            continue;
+        if (isCommentLine(line))
+            continue;
+        const match = findMutationMatch(line);
+        if (!match || match.isSafe)
+            continue;
+        const rootName = match.detector.patternName.split('.')[0];
+        if (locallyDeclared.has(rootName))
+            continue;
+        const isDefensive = isDefensiveMutation(lines, i);
+        const lineNumber = i + 1;
+        violations.push({
+            line: lineNumber,
+            column: 0,
+            message: 'Mutation of context object may cause side effects',
+            severity: isDefensive ? 'warning' : 'error',
+            suggestion: 'Create a new context object instead of mutating. Use spread operator: const newCtx = { ...ctx, property: newValue }; or Object.freeze() for immutability.',
+            match: match.detector.patternName,
+            type: 'context-mutation',
+            filePath,
+        });
+    }
+    return violations;
+}
+/**
+ * Check: resilience/context-mutation
+ *
+ * Detects potentially unsafe mutations of request/execution context objects.
+ * Context should be immutable to prevent side effects across middleware.
+ */
+export const contextMutationCheck = defineCheck({
+    id: 'abed5b29-960b-486f-bb0d-5b9e1744241d',
+    slug: 'context-mutation',
+    scope: { languages: ['typescript'], concerns: ['backend', 'frontend', 'cli'] },
+    contentFilter: 'strip-strings',
+    confidence: 'medium',
+    description: 'Detect unsafe mutations of request/execution context',
+    longDescription: `**Purpose:** Prevents direct mutation of request/execution context objects, which can cause side effects across middleware and handlers.
+
+**Detects:**
+- Assignment to context properties: \`ctx.prop =\`, \`context.prop =\`, \`req.context.prop =\`, \`request.context.prop =\` (excluding \`==\`/\`===\` comparisons)
+- \`Object.assign(ctx, ...)\` and \`Object.assign(context, ...)\`
+- Array mutation methods on context objects: \`.push()\`, \`.splice()\`, \`.pop()\`, \`.shift()\`, \`.unshift()\`
+- \`delete ctx.\` / \`delete context.\` expressions
+- Allows safe fields like \`correlationId\`, \`requestId\`, \`logger\`, and non-request context prefixes like \`error.context\`, \`this.context\`
+
+**Why it matters:** Mutating shared request context causes unpredictable cross-request data leakage in concurrent server environments.
+
+**Scope:** General best practice. Analyzes each file individually via string matching.`,
+    tags: ['resilience', 'context', 'immutability'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        return analyzeContextMutation(content, filePath);
+    },
+});
+//# sourceMappingURL=context-mutation.js.map

package/dist/checks/resilience/context-mutation.js.map

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

package/dist/checks/resilience/detached-promises.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Detached promise detection — flags un-awaited promise-returning
+ * calls inside async contexts.
+ *
+ * The defaults here cover **generic JS/TS sync APIs only** (Array, String,
+ * Object, Math, JSON, `console.*`, the Node `*Sync` family, timer
+ * scheduling, and EventEmitter). Framework-specific helpers (Fastify
+ * decorators, Pyroscope SDK, OTel propagation, DBOS `.init`, Vitest /
+ * Drizzle helpers, etc.) belong in a recipe's
+ * `checks.config['detached-promises']` block — see
+ * {@link DetachedPromisesConfig}. The check reads that block via
+ * `getCheckConfig` and merges it into the effective sync-call sets.
+ */
+/**
+ * Recipe-config shape for the detached-promises check. Each field augments the
+ * built-in defaults; nothing here is required. Project-specific helper names
+ * (e.g. opensip's `attachDomainContext`, `sendError`) belong in a recipe's
+ * `checks.config['detached-promises']` block, not in built-in defaults.
+ */
+export interface DetachedPromisesConfig extends Record<string, unknown> {
+    /** Method/function names that are synchronous (no await needed). */
+    additionalSyncFunctions?: readonly string[];
+    /** Receiver identifiers (the part before the dot) that are synchronous. */
+    additionalSyncReceivers?: readonly string[];
+    /** Method-name prefixes that mark a call as synchronous (e.g. `'wire'`). */
+    additionalSyncPrefixes?: readonly string[];
+}
+/**
+ * Check: resilience/detached-promises
+ *
+ * Detects promises that are not awaited or handled.
+ * Missing await can cause silent failures.
+ *
+ * Uses AST analysis to:
+ * - Only flag calls inside async functions/methods
+ * - Skip known synchronous functions (logger.*, ensureCorrelationIdFor, etc.)
+ * - Skip fire-and-forget patterns (process.nextTick, setImmediate, etc.)
+ */
+export declare const detachedPromises: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=detached-promises.d.ts.map

package/dist/checks/resilience/detached-promises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detached-promises.d.ts","sourceRoot":"","sources":["../../../src/checks/resilience/detached-promises.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAMH;;;;;GAKG;AACH,MAAM,WAAW,sBAAuB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE,oEAAoE;IACpE,uBAAuB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,2EAA2E;IAC3E,uBAAuB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,4EAA4E;IAC5E,sBAAsB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C;AAmoBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,sCA0B3B,CAAC"}