@opensip-cli/checks-typescript 0.1.10 → 0.1.11

package/dist/checks/quality/data-integrity/null-safety.d.ts

@@ -3,88 +3,8 @@
  *
  * Detects unsafe property and method access without null checks.
  */
-import { type CheckViolation } from '@opensip-cli/fitness';
-import * as ts from 'typescript';
-/**
- * Recipe-config shape for null-safety. Project-specific safe-by-construction
- * paths and factory/builder symbols belong in a recipe's
- * `checks.config['null-safety']` block, not in the check's built-in defaults.
- */
-export interface NullSafetyConfig extends Record<string, unknown> {
-    /**
-     * Additional path patterns whose files are skipped entirely. Each entry
-     * is compiled to a case-insensitive RegExp via `new RegExp(entry, 'i')`.
-     */
-    additionalSafeNullPaths?: readonly string[];
-    /**
-     * Additional call-text prefixes treated as non-null by construction (a
-     * property access on a matching call result is not flagged). Use this for
-     * PROJECT-SPECIFIC factory/builder functions whose non-null contract is
-     * local to your codebase — do not hardcode them into the shipped check.
-     * Matched via `String.prototype.startsWith` against the full call text.
-     */
-    additionalSafeBuilders?: readonly string[];
-    /**
-     * Use TYPE-AWARE analysis (a real `ts.Program` + `TypeChecker`): a property
-     * access on a call/element-access result is flagged only when the receiver's
-     * ACTUAL static type includes `null`/`undefined` (`any`/`unknown`/unresolved →
-     * not flagged; the checker also handles control-flow narrowing, builder/Zod
-     * return types, and chain depth, so the verb-prefix convention does not apply).
-     * `additionalSafeBuilders` remains a manual escape hatch for symbols the checker
-     * cannot resolve.
-     *
-     * **Default `true`** (D2). Set `false` to fall back to the legacy
-     * name/convention heuristic (faster, no Program build, but higher
-     * false-negative rate — it trusts any `get*`/`find*`/… call as non-null).
-     */
-    typeAware?: boolean;
-}
-/**
- * Call prefixes whose results are non-null by construction, so a property
- * access on them needs no guard. Scope is deliberately limited to facts that
- * hold for ANY codebase:
- *
- *   1. Language / runtime guarantees — `Object.*`, `Array.*`, `JSON.*`,
- *      `new URL()`, Node `crypto`/`child_process`, `Intl`, the TS compiler API.
- *   2. Widely-used libraries whose builder/query APIs are documented non-null
- *      — Zod, TypeORM, Drizzle, better-sqlite3, neverthrow `Result`, Express.
- *   3. Generic builder-pattern conventions — `builder.`, `*ResultBuilder.`.
- *
- * PROJECT-SPECIFIC safe symbols must NOT be hardcoded here: baking one
- * codebase's invariants into a generic check silently suppresses real null
- * bugs in every other codebase (e.g. an adopter whose own `getThing()` can
- * return null). Adopters extend this set with their own factories via the
- * `additionalSafeBuilders` recipe-config key — see `buildEffectiveSafeBuilders`.
- */
-export declare const SAFE_BUILDER_PREFIXES: string[];
-/**
- * Common method name prefixes that indicate safe (non-null) return values.
- * Methods starting with these prefixes are conventionally designed to always
- * return a value or throw, never return null/undefined.
- */
-export declare const SAFE_METHOD_PREFIXES: string[];
-/**
- * @param {*} content
- * @param {*} filePath
- * @returns {*}
- * Analyze a file for null safety issues. Exported for the FP-regression
- * suite (see `__tests__/null-safety-fp.test.ts`).
- */
-export declare function analyzeNullSafety(content: string, filePath: string): CheckViolation[];
-/**
- * Type-aware variant (D2): walk the Program's SourceFile and flag a property
- * access on a call/element-access result ONLY when the receiver's actual type
- * includes `null`/`undefined`. The TypeChecker subsumes every heuristic the
- * convention path uses — control-flow narrowing (guards), builder/Zod return
- * types, and chain depth all fall out of real types — so this detector is
- * deliberately minimal. Fail-open: `any`/`unknown`/unresolved types are not
- * nullable per `isTypeNullable`, so "the compiler doesn't know" never flags.
- *
- * Reads the same path skip + escape-hatch config as the convention path
- * (`additionalSafeNullPaths`, `additionalSafeBuilders`). Exported for the
- * type-aware test suite.
- */
-export declare function analyzeNullSafetyTyped(sourceFile: ts.SourceFile, checker: ts.TypeChecker, filePath: string): CheckViolation[];
+export { analyzeNullSafety, analyzeNullSafetyTyped } from './null-safety-analyze.js';
+export { SAFE_BUILDER_PREFIXES, SAFE_METHOD_PREFIXES } from './null-safety-config.js';
 /**
  * Check: quality/null-safety
  *

package/dist/checks/quality/data-integrity/null-safety.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"null-safety.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/null-safety.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/D;;;OAGG;IACH,uBAAuB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAaD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,UA4DjC,CAAC;AAiTF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,UAwChC,CAAC;AAoOF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAmFrF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,QAAQ,EAAE,MAAM,GACf,cAAc,EAAE,CA4ClB;AAyBD;;;;GAIG;AACH,eAAO,MAAM,UAAU,sCA+CrB,CAAC"}
+{"version":3,"file":"null-safety.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/null-safety.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEtF;;;;GAIG;AACH,eAAO,MAAM,UAAU,sCA+CrB,CAAC"}