@opensip-cli/checks-typescript 0.1.0

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

@@ -0,0 +1,435 @@
+/**
+ * @fileoverview Context leakage detection — flags request-scoped state stored
+ * in module or class scope that can leak between concurrent requests.
+ */
+import { logger } from '@opensip-cli/core';
+import { defineCheck, isTestFile } from '@opensip-cli/fitness';
+import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+// =============================================================================
+// REQUEST CONTEXT LEAKAGE (AST-based)
+// =============================================================================
+/**
+ * Names that look like a request-scoped context variable.
+ * Matches whole-word boundaries (case-insensitive): "ctx", "context", "request"
+ * but excludes generic suffixes that aren't request state (e.g. `parserContext`
+ * is still flagged, but that is fine — it's evaluated together with the type).
+ */
+function variableNameLooksContextual(name) {
+    const lower = name.toLowerCase();
+    // Whole-word: ends with "context"/"ctx" or starts with "request"/"req"
+    return (lower.endsWith('context') ||
+        lower.endsWith('ctx') ||
+        lower === 'request' ||
+        lower === 'req' ||
+        lower.startsWith('request') ||
+        (lower.startsWith('req') && lower.length <= 12));
+}
+/**
+ * Type-name suffixes that indicate a request-scoped context type.
+ * Matches identifier types whose name ends with "Context" or "Ctx".
+ * Excludes well-known process-scoped wrappers (`Injector<…>`, `SyncStrategy<…>`,
+ * `Promise<…>`) — those are detected by inspecting the OUTER type identifier
+ * and refusing to recurse into its generic arguments.
+ */
+function isContextTypeName(name) {
+    return /(?:Context|Ctx)$/.test(name);
+}
+/**
+ * Type identifiers that, regardless of generic arguments, are NOT request
+ * state. If the outer type is one of these, we ignore generic args entirely.
+ */
+const PROCESS_SCOPED_WRAPPER_TYPES = new Set([
+    'Injector',
+    'SyncStrategy',
+    'Promise',
+    'PromiseLike',
+    'Awaited',
+    'Array',
+    'ReadonlyArray',
+    'Map',
+    'ReadonlyMap',
+    'Set',
+    'ReadonlySet',
+    'Record',
+    'Partial',
+    'Required',
+    'Readonly',
+    'Pick',
+    'Omit',
+    'Result',
+    'Either',
+    'Observable',
+    'AsyncIterable',
+    'Iterable',
+    'WeakMap',
+    'WeakSet',
+]);
+/**
+ * OTel and project metric instrument type names. A module-level
+ * `let counter: Counter | null = null` lazy-init pattern with one of these
+ * as the declared type is process-scoped per-instrument state, not request state.
+ */
+const METRIC_INSTRUMENT_TYPES = new Set([
+    'Counter',
+    'Histogram',
+    'UpDownCounter',
+    'Gauge',
+    'ObservableCounter',
+    'ObservableGauge',
+    'ObservableUpDownCounter',
+    'Meter',
+    'Tracer',
+    'TracerProvider',
+    'MeterProvider',
+]);
+/**
+ * Path patterns where the check is structurally inappropriate.
+ * - DBOS steps register process-scoped DI via `static ctx`; that's the framework's
+ *   contract, not request leakage.
+ */
+const SKIP_PATH_PATTERNS = [/[/\\]dbos[/\\]steps[/\\]/];
+function isSkippedPath(filePath) {
+    return SKIP_PATH_PATTERNS.some((p) => p.test(filePath));
+}
+/**
+ * Walk a TypeNode and decide whether it references a request-scoped context
+ * type *as the outer / value-shape* (not as an inner generic argument of a
+ * process-scoped wrapper like `Injector<AuditContext>`).
+ */
+/** Get the simple name of a type reference's `typeName` (handles qualified names). */
+function getTypeRefName(typeName) {
+    if (ts.isIdentifier(typeName))
+        return typeName.text;
+    if (ts.isQualifiedName(typeName))
+        return typeName.right.text;
+    return '';
+}
+/** Outer type-reference name(s) of a TypeNode, including each union branch. */
+function typeRefNames(type) {
+    if (!type)
+        return [];
+    if (ts.isUnionTypeNode(type))
+        return type.types.flatMap((t) => typeRefNames(t));
+    if (ts.isTypeReferenceNode(type))
+        return [getTypeRefName(type.typeName)];
+    return [];
+}
+/**
+ * Collect names imported from `@opentelemetry/*` packages. OTel's `Context`
+ * (the W3C trace-propagation context) and its siblings are process-scoped SDK
+ * types — a module-level `let parentContext: Context` holding propagation
+ * state is NOT the per-request tenant context this check targets. Inspecting
+ * the import source (rather than the bare `Context`/`Ctx` name) keeps the
+ * exclusion sound: only OTel's own types are spared, not every type ending
+ * in "Context".
+ */
+function isOtelImport(stmt) {
+    return (ts.isImportDeclaration(stmt) &&
+        ts.isStringLiteral(stmt.moduleSpecifier) &&
+        stmt.moduleSpecifier.text.startsWith('@opentelemetry/'));
+}
+/** Names bound by an import clause (default + named bindings). */
+function importClauseNames(clause) {
+    const names = [];
+    if (clause.name)
+        names.push(clause.name.text);
+    const bindings = clause.namedBindings;
+    if (bindings && ts.isNamedImports(bindings)) {
+        for (const el of bindings.elements)
+            names.push(el.name.text);
+    }
+    return names;
+}
+function collectOtelImportedNames(sourceFile) {
+    const names = new Set();
+    for (const stmt of sourceFile.statements) {
+        if (!isOtelImport(stmt) || !stmt.importClause)
+            continue;
+        for (const name of importClauseNames(stmt.importClause))
+            names.add(name);
+    }
+    return names;
+}
+function typeLooksLikeRequestContext(type) {
+    if (!type)
+        return false;
+    // Union: any branch that looks like context counts (excluding `null`/`undefined`)
+    if (ts.isUnionTypeNode(type)) {
+        return type.types.some((t) => typeLooksLikeRequestContext(t));
+    }
+    if (ts.isTypeReferenceNode(type)) {
+        const name = getTypeRefName(type.typeName);
+        // @fitness-ignore-next-line silent-early-returns -- boolean predicate function: `false` IS the contract value meaning "this wrapper is process-scoped, not request-scoped"; the caller branches on it.
+        if (PROCESS_SCOPED_WRAPPER_TYPES.has(name)) {
+            // The outer wrapper is process-scoped; ignore its generic arguments.
+            return false;
+        }
+        return isContextTypeName(name);
+    }
+    // Other shapes (TypeLiteral, intersection of inline shapes, etc.) — be lenient
+    // and don't flag. Inline-typed module-level state would still be caught if
+    // the variable name itself is contextual (handled separately).
+    return false;
+}
+/**
+ * Detect the `let foo: <MetricType> | null = null` lazy-init shape that is
+ * common for OTel instruments. These declarations are process-scoped per
+ * metric, not request state, so we skip them.
+ */
+function isMetricLazyInit(decl) {
+    const t = decl.type;
+    if (!t)
+        return false;
+    if (decl.initializer?.kind !== ts.SyntaxKind.NullKeyword)
+        return false;
+    // Require a `<Something> | null` (or `<Something> | undefined`) shape.
+    const candidates = ts.isUnionTypeNode(t) ? [...t.types] : [t];
+    const hasNullBranch = candidates.some((c) => c.kind === ts.SyntaxKind.NullKeyword ||
+        c.kind === ts.SyntaxKind.UndefinedKeyword ||
+        (ts.isLiteralTypeNode(c) && c.literal.kind === ts.SyntaxKind.NullKeyword));
+    if (!hasNullBranch)
+        return false;
+    return candidates.some((c) => {
+        if (!ts.isTypeReferenceNode(c))
+            return false;
+        return METRIC_INSTRUMENT_TYPES.has(getTypeRefName(c.typeName));
+    });
+}
+/**
+ * Detect AsyncLocalStorage-typed declarations; these are the *correct* way to
+ * store request-scoped state and should never be flagged.
+ */
+function isAsyncLocalStorageType(type) {
+    if (!type)
+        return false;
+    if (ts.isTypeReferenceNode(type)) {
+        return getTypeRefName(type.typeName) === 'AsyncLocalStorage';
+    }
+    if (ts.isUnionTypeNode(type)) {
+        return type.types.some(isAsyncLocalStorageType);
+    }
+    return false;
+}
+/**
+ * A class is "request-scoped" if any of its public methods take a `tenantId`
+ * parameter (typed or named), or it has a `requestId` field. This is a heuristic
+ * — process-scoped DI classes (composition roots, providers) typically don't
+ * pass tenantId around as a method param; request handlers do.
+ */
+function classLooksRequestScoped(cls) {
+    for (const member of cls.members) {
+        // Field named requestId / correlationId
+        if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
+            const fieldName = member.name.text;
+            if (fieldName === 'requestId' || fieldName === 'correlationId')
+                return true;
+        }
+        // Method with `tenantId` parameter
+        if ((ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member)) &&
+            member.parameters.some((p) => ts.isIdentifier(p.name) && (p.name.text === 'tenantId' || p.name.text === 'tenant_id'))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * A class declaration is a DBOS step host if any member carries a `@DBOS.step()`
+ * decorator (or `@DBOS.workflow()`). These are process-scoped DI containers.
+ */
+function classIsDbosStepHost(cls) {
+    const checkDecorators = (mods) => {
+        if (!mods)
+            return false;
+        for (const m of mods) {
+            if (!ts.isDecorator(m))
+                continue;
+            const exprText = m.expression.getText();
+            if (exprText.startsWith('DBOS.step') || exprText.startsWith('DBOS.workflow'))
+                return true;
+        }
+        return false;
+    };
+    if (checkDecorators(ts.getModifiers(cls)))
+        return true;
+    for (const member of cls.members) {
+        if (ts.canHaveDecorators(member) && checkDecorators(ts.getDecorators(member))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Walk top-level statements and class declarations of a SourceFile and collect
+ * findings for genuine module-level / request-scoped class-level leakage.
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity -- module/class-level walk; branches map to AST node kinds and are easier to read inline than as a fragmented dispatcher
+function collectContextLeakage(sourceFile) {
+    const findings = [];
+    const otelImportedNames = collectOtelImportedNames(sourceFile);
+    // 1. Module-level `let`/`var` declarations
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        const flags = stmt.declarationList.flags;
+        // Skip `const` — request-scoped state cannot be assigned more than once
+        // anyway. The leakage shape requires a re-assignable binding.
+        if (flags & ts.NodeFlags.Const)
+            continue;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name))
+                continue;
+            const varName = decl.name.text;
+            // AsyncLocalStorage — the correct request-scoping primitive
+            if (isAsyncLocalStorageType(decl.type))
+                continue;
+            // Lazy-init metric instrument: process-scoped per metric, not per request
+            if (isMetricLazyInit(decl))
+                continue;
+            // OTel SDK types (Context, Span, …) are process/propagation scoped.
+            if (typeRefNames(decl.type).some((n) => otelImportedNames.has(n)))
+                continue;
+            const typeIsContextual = typeLooksLikeRequestContext(decl.type);
+            const nameIsContextual = variableNameLooksContextual(varName);
+            // Require BOTH name AND type to point at request context (or at least the
+            // type — the regex check used to flag "request" in metric names; we now
+            // require an explicit type-shape signal).
+            if (!typeIsContextual && !nameIsContextual)
+                continue;
+            // If the variable has a non-null initializer that's an object literal /
+            // function call producing a known process-scoped value (e.g. `new Map()`),
+            // and the type isn't contextual, skip.
+            if (!typeIsContextual && nameIsContextual) {
+                // Name-only signal is too weak by itself — require initializer to be `null`
+                // and a contextual-looking type. If the user wrote `let req = …` without a
+                // type, modern TS will infer it; we don't have type info here, so we punt.
+                continue;
+            }
+            const start = decl.getStart(sourceFile);
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+            findings.push({
+                line: line + 1,
+                column: character + 1,
+                match: `let ${varName}: <Context>`,
+            });
+        }
+    }
+    // 2. Class fields — non-readonly, non-static `PropertyDeclaration` whose
+    //    type is a request-scoped context AND the class itself is request-scoped.
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isClassDeclaration(stmt))
+            continue;
+        if (classIsDbosStepHost(stmt))
+            continue;
+        if (!classLooksRequestScoped(stmt))
+            continue;
+        for (const member of stmt.members) {
+            if (!ts.isPropertyDeclaration(member))
+                continue;
+            if (!ts.isIdentifier(member.name))
+                continue;
+            const mods = ts.getModifiers(member);
+            const isReadonly = mods?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+            const isStatic = mods?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
+            if (isReadonly || isStatic)
+                continue;
+            // OTel SDK types are process/propagation scoped, not request state.
+            if (typeRefNames(member.type).some((n) => otelImportedNames.has(n)))
+                continue;
+            if (!typeLooksLikeRequestContext(member.type))
+                continue;
+            const start = member.getStart(sourceFile);
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+            findings.push({
+                line: line + 1,
+                column: character + 1,
+                match: `private ${member.name.text}: <Context>`,
+            });
+        }
+    }
+    return findings;
+}
+/**
+ * Check: resilience/context-leakage
+ *
+ * Detects request context stored in module or class scope, which could cause
+ * cross-request pollution in multi-tenant / concurrent server environments.
+ *
+ * Implemented as a TypeScript AST walk. The previous regex implementation flagged:
+ * - type-only references (`SyncStrategy<InitialSyncContext>`),
+ * - method-parameter types (`(ctx: SomeContext) => …`),
+ * - module-level lazy-init metric instruments (`let counter: Counter | null = null`).
+ * The AST rewrite eliminates those false positives by inspecting the actual
+ * declaration shape rather than line text.
+ */
+export const contextLeakage = defineCheck({
+    id: '037b58ef-7b7d-404c-896b-2d40efe02a95',
+    slug: 'context-leakage',
+    scope: { languages: ['typescript'], concerns: ['backend', 'frontend', 'cli'] },
+    description: 'Detect potential request context leakage',
+    longDescription: `**Purpose:** Detects request context stored in module or class scope, which can leak between concurrent requests.
+
+**Detects (AST-based):**
+- Module-level mutable bindings (\`let\`/\`var\`) whose declared type ends in \`Context\` or \`Ctx\` (e.g. \`let activeContext: RequestContext | null = null\`).
+- Class \`PropertyDeclaration\` (non-\`readonly\`, non-\`static\`) whose type ends in \`Context\` or \`Ctx\` AND whose enclosing class is heuristically request-scoped (a method takes a \`tenantId\` parameter, or the class declares a \`requestId\` field).
+
+**Explicitly excluded:**
+- Type-only generic-argument references (\`SyncStrategy<InitialSyncContext>\`, \`Injector<AuditContext>\`, \`Promise<Foo>\`) — the outer wrapper identifier suppresses recursion into generics.
+- Method-parameter types (\`(ctx: SomeContext) => …\`) — parameters are never module-level declarations.
+- Function-local bindings — only top-level \`SourceFile.statements\` are walked.
+- DBOS step \`static ctx\` slots — files under \`**/dbos/steps/**\` are skipped, and classes whose members carry \`@DBOS.step()\` / \`@DBOS.workflow()\` decorators are skipped.
+- Module-level OTel lazy-init shape: \`let <name>: <MetricType> | null = null\` where \`<MetricType>\` is one of \`Counter\`, \`Histogram\`, \`UpDownCounter\`, \`Gauge\`, \`Observable*\`, \`Meter\`, \`Tracer\`, \`TracerProvider\`, \`MeterProvider\` — these are process-scoped per-instrument caches, not per-request state.
+- \`AsyncLocalStorage\`-typed declarations — the correct request-scoping primitive.
+
+**Why it matters:** Storing per-request context in shared scope causes cross-request pollution in multi-tenant or concurrent server environments.
+
+**Known limitations:**
+- The "class is request-scoped" check is a syntactic heuristic — it does not consult the type checker. A request handler that doesn't take \`tenantId\` directly (e.g. takes a \`FastifyRequest\` and reads tenant from inside) will not match. Prefer adding a \`requestId\` field on such classes if you want them in scope.
+- Inline-typed module bindings (\`let foo = someValue\` with no annotation) are not flagged — the AST has no type information without the type checker. If you want stricter detection, declare the type explicitly.
+
+**Scope:** General best practice. Analyzes each file individually via a single AST walk.`,
+    tags: ['resilience', 'context', 'security'],
+    fileTypes: ['ts', 'tsx'],
+    analyze: analyzeContextLeakage,
+});
+/**
+ * Analyze a file for request-context leakage. Exported for the FP-regression
+ * suite (see `__tests__/context-leakage-fp.test.ts`).
+ */
+export function analyzeContextLeakage(content, filePath) {
+    if (isTestFile(filePath))
+        return [];
+    if (isSkippedPath(filePath))
+        return [];
+    logger.debug({
+        evt: 'fitness.checks.context_leakage.context_leakage_analyze',
+        msg: 'Analyzing file for request context leakage (AST)',
+    });
+    // Quick text bail-out: if the file mentions neither "context" nor "ctx",
+    // there is nothing to find. Saves the parse-cache hit.
+    const lower = content.toLowerCase();
+    if (!lower.includes('context') && !lower.includes('ctx'))
+        return [];
+    let sourceFile;
+    try {
+        sourceFile = getSharedSourceFile(filePath, content);
+    }
+    catch {
+        // @swallow-ok Skip files that fail to parse — no signal to emit.
+        return [];
+    }
+    if (!sourceFile)
+        return [];
+    const findings = collectContextLeakage(sourceFile);
+    return findings.map((f) => ({
+        line: f.line,
+        column: f.column,
+        message: 'Request context stored in module/class scope may leak between requests',
+        severity: 'warning',
+        suggestion: 'Use AsyncLocalStorage for request-scoped context or pass context as a parameter. Storing context in module/class scope can cause cross-request pollution.',
+        match: f.match,
+        type: 'context-leakage',
+        filePath,
+    }));
+}
+//# sourceMappingURL=context-leakage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-leakage.js","sourceRoot":"","sources":["../../../src/checks/resilience/context-leakage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,UAAU,EAAuB,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,gFAAgF;AAChF,sCAAsC;AACtC,gFAAgF;AAEhF;;;;;GAKG;AACH,SAAS,2BAA2B,CAAC,IAAY;IAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,uEAAuE;IACvE,OAAO,CACL,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzB,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;QACrB,KAAK,KAAK,SAAS;QACnB,KAAK,KAAK,KAAK;QACf,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC;QAC3B,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAChD,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,IAAY;IACrC,OAAO,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED;;;GAGG;AACH,MAAM,4BAA4B,GAAG,IAAI,GAAG,CAAC;IAC3C,UAAU;IACV,cAAc;IACd,SAAS;IACT,aAAa;IACb,SAAS;IACT,OAAO;IACP,eAAe;IACf,KAAK;IACL,aAAa;IACb,KAAK;IACL,aAAa;IACb,QAAQ;IACR,SAAS;IACT,UAAU;IACV,UAAU;IACV,MAAM;IACN,MAAM;IACN,QAAQ;IACR,QAAQ;IACR,YAAY;IACZ,eAAe;IACf,UAAU;IACV,SAAS;IACT,SAAS;CACV,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC;IACtC,SAAS;IACT,WAAW;IACX,eAAe;IACf,OAAO;IACP,mBAAmB;IACnB,iBAAiB;IACjB,yBAAyB;IACzB,OAAO;IACP,QAAQ;IACR,gBAAgB;IAChB,eAAe;CAChB,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,kBAAkB,GAAa,CAAC,0BAA0B,CAAC,CAAC;AAElE,SAAS,aAAa,CAAC,QAAgB;IACrC,OAAO,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,sFAAsF;AACtF,SAAS,cAAc,CAAC,QAAuB;IAC7C,IAAI,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAC,IAAI,CAAC;IACpD,IAAI,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC;IAC7D,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,+EAA+E;AAC/E,SAAS,YAAY,CAAC,IAA6B;IACjD,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAChF,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzE,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAC,IAAkB;IACtC,OAAO,CACL,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;QAC5B,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC;QACxC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,CACxD,CAAC;AACJ,CAAC;AAED,kEAAkE;AAClE,SAAS,iBAAiB,CAAC,MAAuB;IAChD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,MAAM,CAAC,IAAI;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9C,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,CAAC;IACtC,IAAI,QAAQ,IAAI,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5C,KAAK,MAAM,EAAE,IAAI,QAAQ,CAAC,QAAQ;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,wBAAwB,CAAC,UAAyB;IACzD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;QACzC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,SAAS;QACxD,KAAK,MAAM,IAAI,IAAI,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC;YAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,2BAA2B,CAAC,IAA6B;IAChE,IAAI,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IAExB,kFAAkF;IAClF,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3C,uMAAuM;QACvM,IAAI,4BAA4B,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3C,qEAAqE;YACrE,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,+EAA+E;IAC/E,2EAA2E;IAC3E,+DAA+D;IAC/D,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,IAA4B;IACpD,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;IACpB,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACrB,IAAI,IAAI,CAAC,WAAW,EAAE,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAEvE,uEAAuE;IACvE,MAAM,UAAU,GAAkB,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7E,MAAM,aAAa,GAAG,UAAU,CAAC,IAAI,CACnC,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;QACpC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;QACzC,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAC5E,CAAC;IACF,IAAI,CAAC,aAAa;QAAE,OAAO,KAAK,CAAC;IAEjC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QAC3B,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QAC7C,OAAO,uBAAuB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,SAAS,uBAAuB,CAAC,IAA6B;IAC5D,IAAI,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,OAAO,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,mBAAmB,CAAC;IAC/D,CAAC;IACD,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,uBAAuB,CAAC,GAAwB;IACvD,KAAK,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QACjC,wCAAwC;QACxC,IAAI,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YACrE,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;YACnC,IAAI,SAAS,KAAK,WAAW,IAAI,SAAS,KAAK,eAAe;gBAAE,OAAO,IAAI,CAAC;QAC9E,CAAC;QACD,mCAAmC;QACnC,IACE,CAAC,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;YACvE,MAAM,CAAC,UAAU,CAAC,IAAI,CACpB,CAAC,CAAC,EAAE,EAAE,CACJ,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,WAAW,CAAC,CACzF,EACD,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,mBAAmB,CAAC,GAAwB;IACnD,MAAM,eAAe,GAAG,CAAC,IAA4C,EAAW,EAAE;QAChF,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;YACrB,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;gBAAE,SAAS;YACjC,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACxC,IAAI,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC;gBAAE,OAAO,IAAI,CAAC;QAC5F,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,IAAI,eAAe,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACvD,KAAK,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YAC9E,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAQD;;;GAGG;AACH,iLAAiL;AACjL,SAAS,qBAAqB,CAAC,UAAyB;IACtD,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,MAAM,iBAAiB,GAAG,wBAAwB,CAAC,UAAU,CAAC,CAAC;IAE/D,2CAA2C;IAC3C,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;QACzC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAAE,SAAS;QAE5C,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC;QACzC,wEAAwE;QACxE,8DAA8D;QAC9D,IAAI,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,KAAK;YAAE,SAAS;QAEzC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;YACrD,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,SAAS;YAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YAE/B,4DAA4D;YAC5D,IAAI,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,SAAS;YAEjD,0EAA0E;YAC1E,IAAI,gBAAgB,CAAC,IAAI,CAAC;gBAAE,SAAS;YAErC,oEAAoE;YACpE,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAAE,SAAS;YAE5E,MAAM,gBAAgB,GAAG,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChE,MAAM,gBAAgB,GAAG,2BAA2B,CAAC,OAAO,CAAC,CAAC;YAE9D,0EAA0E;YAC1E,wEAAwE;YACxE,0CAA0C;YAC1C,IAAI,CAAC,gBAAgB,IAAI,CAAC,gBAAgB;gBAAE,SAAS;YAErD,wEAAwE;YACxE,2EAA2E;YAC3E,uCAAuC;YACvC,IAAI,CAAC,gBAAgB,IAAI,gBAAgB,EAAE,CAAC;gBAC1C,4EAA4E;gBAC5E,2EAA2E;gBAC3E,2EAA2E;gBAC3E,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YACxC,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,UAAU,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;YAC5E,QAAQ,CAAC,IAAI,CAAC;gBACZ,IAAI,EAAE,IAAI,GAAG,CAAC;gBACd,MAAM,EAAE,SAAS,GAAG,CAAC;gBACrB,KAAK,EAAE,OAAO,OAAO,aAAa;aACnC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,yEAAyE;IACzE,8EAA8E;IAC9E,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;QACzC,IAAI,CAAC,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC;YAAE,SAAS;QAC3C,IAAI,mBAAmB,CAAC,IAAI,CAAC;YAAE,SAAS;QACxC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC;YAAE,SAAS;QAE7C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC;gBAAE,SAAS;YAChD,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,SAAS;YAE5C,MAAM,IAAI,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC;YACxF,MAAM,QAAQ,GAAG,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC;YACpF,IAAI,UAAU,IAAI,QAAQ;gBAAE,SAAS;YAErC,oEAAoE;YACpE,IAAI,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAAE,SAAS;YAE9E,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,SAAS;YAExD,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,UAAU,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;YAC5E,QAAQ,CAAC,IAAI,CAAC;gBACZ,IAAI,EAAE,IAAI,GAAG,CAAC;gBACd,MAAM,EAAE,SAAS,GAAG,CAAC;gBACrB,KAAK,EAAE,WAAW,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa;aAChD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,WAAW,CAAC;IACxC,EAAE,EAAE,sCAAsC;IAC1C,IAAI,EAAE,iBAAiB;IACvB,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE;IAC9E,WAAW,EAAE,0CAA0C;IACvD,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;yFAoBsE;IACvF,IAAI,EAAE,CAAC,YAAY,EAAE,SAAS,EAAE,UAAU,CAAC;IAC3C,SAAS,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;IAExB,OAAO,EAAE,qBAAqB;CAC/B,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe,EAAE,QAAgB;IACrE,IAAI,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,CAAC;IACpC,IAAI,aAAa,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,CAAC;IAEvC,MAAM,CAAC,KAAK,CAAC;QACX,GAAG,EAAE,wDAAwD;QAC7D,GAAG,EAAE,kDAAkD;KACxD,CAAC,CAAC;IAEH,yEAAyE;IACzE,uDAAuD;IACvD,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACpC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEpE,IAAI,UAAgC,CAAC;IACrC,IAAI,CAAC;QACH,UAAU,GAAG,mBAAmB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;QACjE,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,CAAC,UAAU;QAAE,OAAO,EAAE,CAAC;IAE3B,MAAM,QAAQ,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACnD,OAAO,QAAQ,CAAC,GAAG,CAAiB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1C,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,OAAO,EAAE,wEAAwE;QACjF,QAAQ,EAAE,SAAS;QACnB,UAAU,EACR,2JAA2J;QAC7J,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,IAAI,EAAE,iBAAiB;QACvB,QAAQ;KACT,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/checks/resilience/context-mutation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Context mutation safety check — flags direct mutation of
+ * request/execution context objects, which causes side effects across
+ * middleware in concurrent server environments.
+ */
+import { type CheckViolation } from '@opensip-cli/fitness';
+/**
+ * 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 declare function analyzeContextMutation(content: string, filePath: string): CheckViolation[];
+/**
+ * Check: resilience/context-mutation
+ *
+ * Detects potentially unsafe mutations of request/execution context objects.
+ * Context should be immutable to prevent side effects across middleware.
+ */
+export declare const contextMutationCheck: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=context-mutation.d.ts.map

package/dist/checks/resilience/context-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-mutation.d.ts","sourceRoot":"","sources":["../../../src/checks/resilience/context-mutation.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAGH,OAAO,EAA8B,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AA8SvF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAwC1F;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,sCA0B/B,CAAC"}