@opensip-cli/checks-typescript 0.1.0

package/dist/checks/quality/data-integrity/__tests__/null-safety-fp.test.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Regression tests for two `null-safety` FP fixes.
+ *
+ * 1. Cross-line guard: a property access guarded by an enclosing `if` / `&&`
+ *    on a PREVIOUS line (e.g. `if (candidates.length === 1 && candidates[0])
+ *    { … candidates[0].bodyHash … }`) was flagged because the safety scan was
+ *    line-local. The fix walks enclosing conditions.
+ * 2. Immutable combinators: `.merge(...)` chained on a factory result
+ *    (e.g. OTel `detectResources(...).merge(...)`) returns a non-null value
+ *    and is now a known-safe fluent method.
+ *
+ * Genuine unguarded access on a call/element result must still fire.
+ */
+import { describe, expect, it } from 'vitest';
+import { analyzeNullSafety } from '../null-safety.js';
+function analyze(src) {
+    return analyzeNullSafety(src, 'src/svc/sample.ts');
+}
+describe('null-safety — FP regression suite', () => {
+    it('does NOT flag element access guarded by an enclosing if on a previous line', () => {
+        const src = `
+      function pick(candidates: { bodyHash: string }[]) {
+        if (candidates.length === 1 && candidates[0]) {
+          return [candidates[0].bodyHash];
+        }
+        return [];
+      }
+    `;
+        expect(analyze(src)).toHaveLength(0);
+    });
+    it('does NOT flag `.merge(...)` chained on a factory call result', () => {
+        const src = `
+      function build() {
+        const resource = detectResources({ detectors: [envDetector] }).merge(
+          resourceFromAttributes({ name: 'svc' }),
+        );
+        return resource;
+      }
+    `;
+        expect(analyze(src)).toHaveLength(0);
+    });
+    it('STILL flags an unguarded property access on an element-access result', () => {
+        const src = `
+      function firstHash(rows: { bodyHash: string }[]) {
+        return rows[0].bodyHash;
+      }
+    `;
+        expect(analyze(src).length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=null-safety-fp.test.js.map

package/dist/checks/quality/data-integrity/__tests__/null-safety-fp.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-safety-fp.test.js","sourceRoot":"","sources":["../../../../../src/checks/quality/data-integrity/__tests__/null-safety-fp.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,SAAS,OAAO,CAAC,GAAW;IAC1B,OAAO,iBAAiB,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAAC;AACrD,CAAC;AAED,QAAQ,CAAC,mCAAmC,EAAE,GAAG,EAAE;IACjD,EAAE,CAAC,4EAA4E,EAAE,GAAG,EAAE;QACpF,MAAM,GAAG,GAAG;;;;;;;KAOX,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,GAAG,GAAG;;;;;;;KAOX,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sEAAsE,EAAE,GAAG,EAAE;QAC9E,MAAM,GAAG,GAAG;;;;KAIX,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/checks/quality/data-integrity/array-validation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Array Parameter Validation Check
+ *
+ * Detects array parameters without proper validation.
+ * Ensures arrays are validated for length, type, and content before processing.
+ *
+ */
+/**
+ * Check: quality/array-validation
+ *
+ * Detects array parameters without proper validation to prevent
+ * runtime errors from unvalidated array inputs.
+ *
+ */
+export declare const arrayValidation: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=array-validation.d.ts.map

package/dist/checks/quality/data-integrity/array-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-validation.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/array-validation.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAqgBH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sCA4B1B,CAAC"}

package/dist/checks/quality/data-integrity/array-validation.js

@@ -0,0 +1,508 @@
+// @fitness-ignore-file file-length-limit -- cohesive single-check module; splitting risks breaking the detector contract
+/**
+ * @fileoverview Array Parameter Validation Check
+ *
+ * Detects array parameters without proper validation.
+ * Ensures arrays are validated for length, type, and content before processing.
+ *
+ */
+import { defineCheck, isTestFile } from '@opensip-cli/fitness';
+import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+/**
+ * Quick filter keywords for array validation patterns
+ */
+const QUICK_FILTER_KEYWORDS = [
+    '[]',
+    'Array',
+    'array',
+    '.length',
+    '.push',
+    '.pop',
+    '.map(',
+    '.filter(',
+];
+/**
+ * Paths where array validation requirements are relaxed
+ */
+const RELAXED_VALIDATION_PATHS = [
+    /\/internal\//,
+    /\/utils\//,
+    /\/helpers\//,
+    /\/cli\//,
+    /\/scripts\//,
+];
+/**
+ * Type patterns that indicate complex/nested types where validation is harder to detect
+ */
+const COMPLEX_TYPE_PATTERNS = [
+    'Record<',
+    'Map<',
+    '=> ', // Function type
+    ': (', // Function type with parens
+    'Promise<', // Async wrappers
+    'Observable<',
+];
+/**
+ * Check whether a parameter's type is a top-level array type (e.g. `string[]`, `Array<T>`)
+ * as opposed to an object/interface/intersection type that merely _contains_ array-typed
+ * properties (e.g. `{ items: string[] }`, `Foo & { tags: string[] }`).
+ *
+ * This uses the TypeScript AST node kind rather than text matching, eliminating false
+ * positives for object parameters whose nested properties happen to be arrays.
+ */
+function isTopLevelArrayType(typeNode) {
+    // Direct array type: `string[]`, `Foo[]`
+    if (ts.isArrayTypeNode(typeNode)) {
+        return true;
+    }
+    // Generic Array reference: `Array<string>`, `ReadonlyArray<Foo>`
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const typeName = typeNode.typeName;
+        if (ts.isIdentifier(typeName)) {
+            const name = typeName.text;
+            if (name === 'Array' || name === 'ReadonlyArray') {
+                return true;
+            }
+        }
+    }
+    // Union type: check if ALL branches are arrays (e.g. `string[] | number[]`)
+    if (ts.isUnionTypeNode(typeNode)) {
+        return typeNode.types.length > 0 && typeNode.types.every((t) => isTopLevelArrayType(t));
+    }
+    // Parenthesized type: unwrap `(string[])`
+    if (ts.isParenthesizedTypeNode(typeNode)) {
+        return isTopLevelArrayType(typeNode.type);
+    }
+    // Everything else (object literals, intersection types, type references to interfaces,
+    // mapped types, conditional types, etc.) is NOT a top-level array even if the type
+    // text contains `[]` in nested positions.
+    return false;
+}
+/**
+ * Check if a file path is in a relaxed validation context
+ */
+function isRelaxedValidationPath(filePath) {
+    return RELAXED_VALIDATION_PATHS.some((pattern) => pattern.test(filePath));
+}
+/**
+ * Check if a type is a complex nested type where validation detection is unreliable
+ */
+function isComplexNestedType(typeText) {
+    return COMPLEX_TYPE_PATTERNS.some((pattern) => typeText.includes(pattern));
+}
+/**
+ * Check if node is a .length access on the parameter
+ * @param node - The TypeScript AST node to check
+ * @param paramName - The name of the parameter to check for
+ * @param sourceFile - The TypeScript source file for text extraction
+ * @returns True if the node is a .length access on the specified parameter
+ */
+function isLengthAccess(node, paramName, sourceFile) {
+    if (!ts.isPropertyAccessExpression(node))
+        return false;
+    const objName = node.expression.getText(sourceFile);
+    const propName = node.name.getText(sourceFile);
+    return objName === paramName && propName === 'length';
+}
+/**
+ * Check if node is an Array.isArray() call on the parameter
+ * @param node - The TypeScript AST node to check
+ * @param paramName - The name of the parameter to check for
+ * @param sourceFile - The TypeScript source file for text extraction
+ * @returns True if the node is an Array.isArray() call on the specified parameter
+ */
+function isArrayIsArrayCall(node, paramName, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    const callText = node.expression.getText(sourceFile);
+    if (callText !== 'Array.isArray')
+        return false;
+    const arg = node.arguments[0]?.getText(sourceFile);
+    return arg === paramName;
+}
+/**
+ * Check if node is a Zod schema validation call
+ * @param node - The TypeScript AST node to check
+ * @param sourceFile - The TypeScript source file for text extraction
+ * @returns True if the node is a Zod .parse() or .safeParse() call
+ */
+function isZodValidationCall(node, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return false;
+    const methodName = node.expression.name.getText(sourceFile);
+    return methodName === 'parse' || methodName === 'safeParse';
+}
+/**
+ * Check if node is a validation function call
+ * @param node - The TypeScript AST node to check
+ * @returns True if the node is a call to a function with 'validate' or 'check' in its name
+ */
+function isValidationFunctionCall(node) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isIdentifier(node.expression))
+        return false;
+    const funcName = node.expression.text.toLowerCase();
+    return funcName.includes('validate') || funcName.includes('check');
+}
+/**
+ * Check if node is an iteration over the parameter (for...of, forEach, map, filter,
+ * slice, includes, join, indexOf, concat, flat, etc.)
+ *
+ * Iteration implies validation because it handles empty arrays gracefully and
+ * cannot blow up the runtime — the worst case is no work done.
+ */
+function isIterationOverParam(node, paramName, sourceFile) {
+    // for...of statement
+    if (ts.isForOfStatement(node)) {
+        const iterableText = node.expression.getText(sourceFile);
+        if (iterableText === paramName || iterableText.startsWith(`${paramName}.`)) {
+            return true;
+        }
+    }
+    // Array prototype methods that internally iterate (and therefore handle empty
+    // arrays gracefully) or otherwise produce a bounded view. These are
+    // validation-equivalent because they don't crash on empty/short input.
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const objText = node.expression.expression.getText(sourceFile);
+        const methodName = node.expression.name.getText(sourceFile);
+        const iterationMethods = [
+            'forEach',
+            'map',
+            'filter',
+            'some',
+            'every',
+            'find',
+            'findIndex',
+            'findLast',
+            'findLastIndex',
+            'reduce',
+            'reduceRight',
+            'flatMap',
+            'flat',
+            'slice',
+            'includes',
+            'indexOf',
+            'lastIndexOf',
+            'join',
+            'concat',
+            'entries',
+            'values',
+            'keys',
+            'at',
+            'toSorted',
+            'toReversed',
+            'toSpliced',
+            'with',
+        ];
+        if (objText === paramName && iterationMethods.includes(methodName)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if node is a write-only sink usage of the parameter.
+ *
+ * Out-array sinks (`bucket.push(...)`, `bucket.unshift(...)`) flag the param
+ * as a producer target — the function isn't *consuming* the array, it's
+ * writing into it. Validation belongs at the consumer, not the producer.
+ */
+function isOutSinkUsage(node, paramName, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return false;
+    const objText = node.expression.expression.getText(sourceFile);
+    if (objText !== paramName)
+        return false;
+    const methodName = node.expression.name.getText(sourceFile);
+    // Mutating sink methods — caller is producing into the array.
+    return methodName === 'push' || methodName === 'unshift' || methodName === 'splice';
+}
+/**
+ * Check if node is indexed access on the parameter (`param[i]`).
+ *
+ * Indexed access on a typed array yields `T | undefined` under
+ * `noUncheckedIndexedAccess`; under any reasonable consumer it implies
+ * defensive use and cannot crash on empty/short input the way an
+ * unconditional `.length`-less iteration would. Practically: if the body
+ * does `param[i]`, the author has already structured the access around
+ * length (or expects undefined).
+ */
+function isIndexedAccess(node, paramName, sourceFile) {
+    if (!ts.isElementAccessExpression(node))
+        return false;
+    return node.expression.getText(sourceFile) === paramName;
+}
+/**
+ * Check if node is a spread of the parameter (`...param`) inside a call
+ * argument list, array literal, or object literal.
+ *
+ * Spread iterates the array — equivalent to `for...of`.
+ */
+function isSpreadOfParam(node, paramName, sourceFile) {
+    if (ts.isSpreadElement(node) || ts.isSpreadAssignment(node)) {
+        return node.expression.getText(sourceFile) === paramName;
+    }
+    return false;
+}
+/**
+ * Check if node passes the parameter through to another function call.
+ *
+ * A pure pass-through forwarder (`return otherFn(..., param, ...)`) defers
+ * validation to the destination function — flagging the forwarder is a false
+ * positive, since the wrapper has nothing to validate against. The destination
+ * function (which actually consumes the array) is the meaningful validation
+ * site.
+ *
+ * Restricted to call-argument position (not the callee position) so we don't
+ * match the param being treated as a function.
+ */
+function isForwardedToCall(node, paramName, _sourceFile) {
+    if (!ts.isCallExpression(node) && !ts.isNewExpression(node))
+        return false;
+    const args = node.arguments;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!args)
+        return false;
+    for (const arg of args) {
+        if (ts.isIdentifier(arg) && arg.text === paramName) {
+            return true;
+        }
+        // `Array.from(param)`, `[...param]`, etc. handled by isSpreadOfParam.
+        // Type-cast forwards: `someFn(param as Foo)` or `someFn(param satisfies Foo)`.
+        if (ts.isAsExpression(arg) || ts.isSatisfiesExpression(arg)) {
+            const inner = arg.expression;
+            if (ts.isIdentifier(inner) && inner.text === paramName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if node is a property-shorthand reference to the parameter inside
+ * an object literal (`return { param }`).
+ *
+ * The param value is being copied by reference into a result object — no
+ * iteration, no boundary crossing, the consumer of the returned object is
+ * the meaningful validation site (same logic as `isForwardedToCall`).
+ */
+function isShorthandPropertyReference(node, paramName) {
+    if (!ts.isShorthandPropertyAssignment(node))
+        return false;
+    return node.name.text === paramName;
+}
+/**
+ * Check if node is an optional chaining or nullish coalescing on the parameter
+ */
+function isOptionalHandling(node, paramName, sourceFile) {
+    const nodeText = node.getText(sourceFile);
+    // Optional chaining: param?.length, param?.map
+    if (nodeText.includes(`${paramName}?.`)) {
+        return true;
+    }
+    /* v8 ignore next -- defensive nullish fallback */
+    // Nullish coalescing: param ?? []
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const leftText = node.left.getText(sourceFile);
+        if (leftText === paramName) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if function body contains array validation for the parameter
+ * @param node - The function declaration, method, or arrow function node
+ * @param param - The parameter declaration to check for validation
+ * @param sourceFile - The TypeScript source file for text extraction
+ * @returns True if the function body contains validation for the array parameter
+ */
+function checkForArrayValidation(node, param, sourceFile) {
+    /* v8 ignore next -- defensive guard */
+    if (!node.body)
+        return false;
+    const paramName = ts.isIdentifier(param.name) ? param.name.text : null;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!paramName)
+        return true; // Destructured params are harder to track, assume validated
+    // Underscore-prefixed params are an established TS convention for
+    // "intentionally unused" — the body does not consume them, so demanding
+    // validation is meaningless.
+    if (paramName.startsWith('_'))
+        return true;
+    let hasValidation = false;
+    const visit = (n) => {
+        if (isLengthAccess(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        if (isArrayIsArrayCall(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        if (isZodValidationCall(n, sourceFile)) {
+            hasValidation = true;
+        }
+        if (isValidationFunctionCall(n)) {
+            hasValidation = true;
+        }
+        // Iteration patterns imply graceful handling of arrays
+        if (isIterationOverParam(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Optional chaining/nullish coalescing implies null safety
+        if (isOptionalHandling(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Out-array sinks (param.push(...)) — param is a producer target, not a
+        // consumer input. Validation belongs at the consumer.
+        if (isOutSinkUsage(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Indexed access (param[i]) — defensive, bounded by author intent.
+        if (isIndexedAccess(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Spread (...param) — iterates the array, equivalent to for...of.
+        if (isSpreadOfParam(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Forwarded to another call — destination owns validation.
+        if (isForwardedToCall(n, paramName, sourceFile)) {
+            hasValidation = true;
+        }
+        // Property-shorthand reference ({ param }) — pass-through into a result
+        // object; consumer of the result owns validation.
+        if (isShorthandPropertyReference(n, paramName)) {
+            hasValidation = true;
+        }
+        if (!hasValidation) {
+            ts.forEachChild(n, visit);
+        }
+    };
+    visit(node.body);
+    return hasValidation;
+}
+/**
+ * Check function parameters for unvalidated arrays
+ * Note: Ignore directives are handled at the framework level in defineCheck()
+ * @param {CheckFunctionArrayParamsOptions} options - The check options
+ * @returns Array of violations
+ */
+function checkFunctionArrayParams(options) {
+    const { node, sourceFile, absolutePath } = options;
+    const violations = [];
+    // Skip files in relaxed validation paths
+    if (isRelaxedValidationPath(absolutePath)) {
+        return violations;
+    }
+    // Skip abstract methods (can't have validation in body)
+    if (ts.isMethodDeclaration(node) &&
+        node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)) {
+        return violations;
+    }
+    // Filter to array parameters without validation
+    const unvalidatedArrayParams = node.parameters.filter((param) => {
+        if (!param.type)
+            return false;
+        // Primary gate: use AST to determine if the parameter's type is a top-level
+        // array type.  Object/interface/intersection types whose *properties* are
+        // arrays will correctly return false here, eliminating the largest category
+        // of false positives.
+        if (!isTopLevelArrayType(param.type))
+            return false;
+        const typeText = param.type.getText(sourceFile);
+        // Secondary gate: skip complex/nested types where validation detection is
+        // unreliable (Map values, Record values, function types, Promises, etc.)
+        /* v8 ignore next -- defensive AST/type guard */
+        if (isComplexNestedType(typeText))
+            return false;
+        return !checkForArrayValidation(node, param, sourceFile);
+    });
+    for (const param of unvalidatedArrayParams) {
+        const paramName = ts.isIdentifier(param.name) ? param.name.text : '<destructured>';
+        const { line: lineIdx, character } = sourceFile.getLineAndCharacterOfPosition(param.getStart());
+        const line = lineIdx + 1;
+        const paramText = param.getText(sourceFile);
+        violations.push({
+            line,
+            column: character + 1,
+            message: `Array parameter '${paramName}' lacks validation`,
+            severity: 'warning',
+            suggestion: `Add validation for '${paramName}' array: check Array.isArray(), validate .length bounds, and/or use Zod schema for content validation`,
+            type: 'missing-array-validation',
+            match: paramText,
+        });
+    }
+    return violations;
+}
+/**
+ * Analyze a file for array validation issues
+ * @param content - The file content as a string
+ * @param absolutePath - The absolute path to the file being analyzed
+ * @returns Array of violations found in the file
+ */
+function analyzeFile(content, absolutePath) {
+    const violations = [];
+    // Quick filter: skip files without array-related patterns
+    if (!QUICK_FILTER_KEYWORDS.some((kw) => content.includes(kw))) {
+        return violations;
+    }
+    // Note: Ignore directives are handled at the framework level in defineCheck()
+    const sourceFile = getSharedSourceFile(absolutePath, content);
+    /* v8 ignore next -- defensive guard */
+    if (!sourceFile)
+        return [];
+    const visit = (node) => {
+        // Check function parameters with array types
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isArrowFunction(node)) {
+            violations.push(...checkFunctionArrayParams({ node, sourceFile, absolutePath }));
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return violations;
+}
+/**
+ * Check: quality/array-validation
+ *
+ * Detects array parameters without proper validation to prevent
+ * runtime errors from unvalidated array inputs.
+ *
+ */
+export const arrayValidation = defineCheck({
+    id: 'a9e0e70c-a4af-42e6-bbd7-4c87a72cb7d4',
+    slug: 'array-validation',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'high',
+    description: 'Detect array parameters without proper validation',
+    longDescription: `**Purpose:** Ensures function parameters with array types are validated before use, preventing runtime errors from malformed or unexpected array inputs.
+
+**Detects:**
+- Function/method/arrow-function parameters whose top-level type is an array (\`string[]\`, \`Array<T>\`) and whose body lacks validation
+- Missing \`Array.isArray()\` checks, \`.length\` bounds checks, Zod \`.parse()\`/\`.safeParse()\` calls, or calls to functions named \`validate\`/\`check\`
+- Uses TypeScript AST node kinds (not text matching) to distinguish true array parameters from object/interface/intersection types that merely contain array-typed properties
+- Skips parameters with complex nested types (\`Record<\`, \`Map<\`, \`Promise<\`, function types)
+- Excludes files under \`/internal/\`, \`/utils/\`, \`/helpers/\`, \`/cli/\`, \`/scripts/\`
+
+**Why it matters:** Unvalidated arrays can cause silent data corruption, out-of-bounds errors, or type mismatches at runtime that TypeScript's type system alone cannot prevent.
+
+**Scope:** General best practice. Analyzes each file individually.`,
+    tags: ['quality', 'validation', 'type-safety', 'arrays'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        // Skip test files — array parameter validation in tests is low-risk due to controlled inputs
+        if (isTestFile(filePath))
+            return [];
+        return analyzeFile(content, filePath);
+    },
+});
+//# sourceMappingURL=array-validation.js.map

package/dist/checks/quality/data-integrity/array-validation.js.map

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

package/dist/checks/quality/data-integrity/database-index-coverage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Database Index Coverage check
+ *
+ * Validates that database queries have appropriate indexes.
+ * Detects queries that may cause full table scans.
+ */
+/**
+ * Check: quality/database-index-coverage
+ *
+ * Validates that database queries reference indexed columns
+ * to prevent performance issues from full table scans.
+ */
+export declare const databaseIndexCoverage: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=database-index-coverage.d.ts.map

package/dist/checks/quality/data-integrity/database-index-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-index-coverage.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/database-index-coverage.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAiRH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sCAsBhC,CAAC"}