no-mistakes 0.26.0 → 0.27.0

package/README.md

@@ -8,6 +8,7 @@ npm install --save-dev no-mistakes
 npx no-mistakes dependencies src/main.mts --json
 npx no-mistakes dependents src/utils.mts --json
 npx no-mistakes symbols src/utils.mts --json
+npx no-mistakes import-usages --root . --filter 'src/**' --json
 npx no-mistakes check --json
 ```
 
@@ -19,15 +20,19 @@ const {
   dependents,
   check,
   fetches,
+  importUsages,
+  flow,
   playwrightRelated,
   symbols,
   testsPlan,
+  testsTargets,
   queueEdges,
   queueRelated,
   queueCheck,
   serverRouteList,
   serverRouteEdges,
   serverRouteRelated,
+  serverContracts,
   reactAnalyze,
   reactCheck,
 } = require("no-mistakes");
@@ -48,6 +53,10 @@ const {
     files: ["src/utils.mts"],
     include: "both",
   });
+  const imports = await importUsages({
+    root: process.cwd(),
+    filters: ["src/**"],
+  });
   const signatureImpact = await symbols({
     root: process.cwd(),
     files: ["src/utils.mts"],
@@ -59,10 +68,21 @@ const {
     framework: "vitest", // also supports "playwright" and "swift"
     changedFiles: ["src/utils.mts"],
   });
+  const targetCommands = await testsTargets({
+    root: process.cwd(),
+    framework: "vitest",
+    files: ["src/utils.test.mts"],
+  });
   const projectCheck = await check({
     root: process.cwd(),
     tsconfig: "tsconfig.json",
   });
+  const localFlow = await flow({
+    root: process.cwd(),
+    target: "src/utils.mts#parseDate",
+    direction: "dependents",
+    depth: 1,
+  });
   const coveredByPlaywright = await playwrightRelated({
     root: process.cwd(),
     files: ["web/app/users/page.tsx"],
@@ -77,6 +97,10 @@ const {
     root: process.cwd(),
     roots: ["src/server.ts"],
   });
+  const contracts = await serverContracts({
+    root: process.cwd(),
+    roots: ["src/server.ts"],
+  });
   const components = await reactAnalyze({
     root: process.cwd(),
     targets: ["app/**/*.tsx"],

package/flow-types.d.ts

@@ -0,0 +1,41 @@
+import type { Relationship } from "./traversal-types";
+
+export interface FlowOptions {
+  target: string;
+  root?: string;
+  tsconfig?: string;
+  config?: string;
+  direction?: "deps" | "dependents" | "both";
+  depth?: number;
+  relationships?: Relationship[];
+}
+
+export interface FlowNode {
+  id: string;
+  kind: "file" | "symbol" | "module" | "queue-job";
+  depth: number;
+  file?: string;
+  symbol?: string;
+  module?: string;
+  queueFile?: string;
+  job?: string;
+}
+
+export interface FlowEdge {
+  from: string;
+  to: string;
+  kind: string;
+}
+
+export interface FlowReport {
+  root: string;
+  target: string;
+  nodes: FlowNode[];
+  edges: FlowEdge[];
+}
+
+export interface FetchesOptions {
+  root?: string;
+  config?: string;
+  targets?: string[];
+}

package/import-usage-types.d.ts

@@ -0,0 +1,27 @@
+export type ImportUsageKind = "static" | "type" | "dynamic" | "require" | "require-resolve";
+
+export interface ImportUsage {
+  specifier: string;
+  packageName: string | null;
+  kind: ImportUsageKind;
+  line: number;
+  sideEffectOnly: boolean;
+  reExport: boolean;
+}
+
+export interface ImportUsageFile {
+  path: string;
+  imports: ImportUsage[];
+}
+
+export interface ImportUsagesOptions {
+  files?: string[];
+  root?: string;
+  scanRoots?: string[];
+  filters?: string[];
+}
+
+export interface ImportUsagesResult {
+  roots: string[];
+  files: ImportUsageFile[];
+}

package/index.d.ts

@@ -22,8 +22,12 @@ import type {
   ExportsOfOptions,
   ExportsOfResult,
   FetchesOptions,
+  FlowOptions,
+  FlowReport,
   ImpactedChecksOptions,
   ImpactedChecksReport,
+  ImportUsagesOptions,
+  ImportUsagesResult,
   ImportersOptions,
   ImportersResult,
   ResolveCheckOptions,
@@ -42,6 +46,7 @@ import type {
   ReactViolation,
   ResourceRefRow,
   ServerRoutesReport,
+  ServerContractsReport,
   SignatureImpactResult,
   SwiftImporterRow,
   SwiftOptions,
@@ -56,6 +61,8 @@ import type {
   TestsImpactOptions,
   TestsPlanDocumentOptions,
   TestsPlanOptions,
+  TestsTargetsOptions,
+  TestsTargetsReport,
   TestsWhyOptions,
   TraverseOptions,
   WhyStep,
@@ -70,15 +77,18 @@ export function analyzeProject(options: AnalyzeProjectOptions): Promise<AnalyzeP
 export function symbols(options: SymbolsSignatureImpactOptions): Promise<SignatureImpactResult>;
 export function symbols(options: SymbolsListOptions): Promise<SymbolsResult>;
 export function symbols(options: SymbolsOptions): Promise<SymbolsResult | SignatureImpactResult>;
+export function importUsages(options?: ImportUsagesOptions): Promise<ImportUsagesResult>;
 export function importers(options: ImportersOptions): Promise<ImportersResult>;
 export function exportsOf(options: ExportsOfOptions): Promise<ExportsOfResult>;
 export function deadExports(options: DeadExportsOptions): Promise<DeadExportsResult>;
 export function callSites(options: CallSitesOptions): Promise<CallSitesResult>;
 export function resolveCheck(options: ResolveCheckOptions): Promise<ResolveCheckResult>;
 export function fetches(options?: FetchesOptions): Promise<unknown>;
+export function flow(options: FlowOptions): Promise<FlowReport>;
 export function check(options?: ProjectOptions): Promise<CheckReport>;
 export function testsPlan(options: TestsPlanOptions): Promise<TestPlan>;
 export function testsImpact(options: TestsImpactOptions): Promise<TestPlan>;
+export function testsTargets(options: TestsTargetsOptions): Promise<TestsTargetsReport>;
 export function testsWhy(options: TestsWhyOptions): Promise<Record<string, WhyStep[]>>;
 export function testsComment(options: TestsPlanDocumentOptions): Promise<string>;
 export function testsGraph(options: TestsPlanDocumentOptions): Promise<TestGraph>;
@@ -95,6 +105,7 @@ export function serverRoutes(options?: ProjectOptions): Promise<ServerRoutesRepo
 export function serverRouteList(options?: ProjectOptions): Promise<unknown[]>;
 export function serverRouteEdges(options?: ProjectOptions): Promise<GraphEdge[]>;
 export function serverRouteRelated(options: ProjectOptions): Promise<GraphEdge[]>;
+export function serverContracts(options?: ProjectOptions): Promise<ServerContractsReport>;
 export function reactAnalyze(options?: ProjectOptions): Promise<ReactComponentFacts[]>;
 export function reactCheck(options?: ProjectOptions): Promise<ReactViolation[]>;
 export function reactUsages(

package/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const native = require("./bin/no-mistakes.node");
+const planning = require("./planning");
 
 async function callJson(fn, options) {
   return JSON.parse(await fn(JSON.stringify(options || {})));
@@ -26,6 +27,10 @@ async function symbols(options) {
   return callJson(native.symbolsJson, options);
 }
 
+async function importUsages(options) {
+  return callJson(native.importUsagesJson, options);
+}
+
 async function importers(options) {
   return callJson(native.importersJson, options);
 }
@@ -54,30 +59,6 @@ async function check(options) {
   return callJson(native.checkJson, options);
 }
 
-async function testsPlan(options) {
-  return callJson(native.testsPlanJson, options);
-}
-
-async function testsImpact(options) {
-  return callJson(native.testsImpactJson, options);
-}
-
-async function testsWhy(options) {
-  return callJson(native.testsWhyJson, options);
-}
-
-async function testsComment(options) {
-  return native.testsCommentMarkdown(JSON.stringify(options || {}));
-}
-
-async function testsGraph(options) {
-  return callJson(native.testsGraphJson, options);
-}
-
-async function testsGraphMermaid(options) {
-  return native.testsGraphMermaid(JSON.stringify(options || {}));
-}
-
 async function playwrightCheck(options) {
   return callJson(native.playwrightCheckJson, options);
 }
@@ -94,38 +75,6 @@ async function playwrightTests(options) {
   return callJson(native.playwrightTestsJson, options);
 }
 
-async function queues(options) {
-  return callJson(native.queuesJson, options);
-}
-
-async function queueEdges(options) {
-  return callJson(native.queueEdgesJson, options);
-}
-
-async function queueRelated(options) {
-  return callJson(native.queueRelatedJson, options);
-}
-
-async function queueCheck(options) {
-  return callJson(native.queueCheckJson, options);
-}
-
-async function serverRoutes(options) {
-  return callJson(native.serverRoutesJson, options);
-}
-
-async function serverRouteList(options) {
-  return callJson(native.serverRouteListJson, options);
-}
-
-async function serverRouteEdges(options) {
-  return callJson(native.serverRouteEdgesJson, options);
-}
-
-async function serverRouteRelated(options) {
-  return callJson(native.serverRouteRelatedJson, options);
-}
-
 async function reactAnalyze(options) {
   return callJson(native.reactAnalyzeJson, options);
 }
@@ -208,6 +157,7 @@ module.exports = {
   exportsOf,
   fetches,
   impactedChecks,
+  importUsages,
   importers,
   infraOutputs,
   infraResourceRefs,
@@ -217,10 +167,6 @@ module.exports = {
   playwrightEdges,
   playwrightRelated,
   playwrightTests,
-  queues,
-  queueCheck,
-  queueEdges,
-  queueRelated,
   reactAnalyze,
   reactCheck,
   reactUsages,
@@ -228,18 +174,9 @@ module.exports = {
   related,
   resolveCheck,
   rscCallers,
-  serverRouteEdges,
-  serverRouteList,
-  serverRouteRelated,
-  serverRoutes,
   swiftImporters,
   swiftTestTargets,
   symbols,
-  testsComment,
-  testsGraph,
-  testsGraphMermaid,
-  testsImpact,
-  testsPlan,
-  testsWhy,
   version,
+  ...planning,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Static codebase analysis tools for TS/JS dependencies, dependents, and symbols",
   "license": "MIT",
   "repository": {
@@ -15,6 +15,7 @@
     "bin/",
     "*.d.ts",
     "index.js",
+    "planning.js",
     "scripts/install.js",
     "scripts/install/",
     "README.md",

package/planning.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const native = require("./bin/no-mistakes.node");
+
+async function callJson(fn, options) {
+  return JSON.parse(await fn(JSON.stringify(options || {})));
+}
+
+async function testsTargets(options) {
+  return callJson(native.testsTargetsJson, options);
+}
+
+async function testsPlan(options) {
+  return callJson(native.testsPlanJson, options);
+}
+
+async function testsImpact(options) {
+  return callJson(native.testsImpactJson, options);
+}
+
+async function testsWhy(options) {
+  return callJson(native.testsWhyJson, options);
+}
+
+async function testsComment(options) {
+  return native.testsCommentMarkdown(JSON.stringify(options || {}));
+}
+
+async function testsGraph(options) {
+  return callJson(native.testsGraphJson, options);
+}
+
+async function testsGraphMermaid(options) {
+  return native.testsGraphMermaid(JSON.stringify(options || {}));
+}
+
+async function queues(options) {
+  return callJson(native.queuesJson, options);
+}
+
+async function queueEdges(options) {
+  return callJson(native.queueEdgesJson, options);
+}
+
+async function queueRelated(options) {
+  return callJson(native.queueRelatedJson, options);
+}
+
+async function queueCheck(options) {
+  return callJson(native.queueCheckJson, options);
+}
+
+async function serverRoutes(options) {
+  return callJson(native.serverRoutesJson, options);
+}
+
+async function serverRouteList(options) {
+  return callJson(native.serverRouteListJson, options);
+}
+
+async function serverRouteEdges(options) {
+  return callJson(native.serverRouteEdgesJson, options);
+}
+
+async function serverRouteRelated(options) {
+  return callJson(native.serverRouteRelatedJson, options);
+}
+
+async function serverContracts(options) {
+  return callJson(native.serverContractsJson, options);
+}
+
+async function flow(options) {
+  return callJson(native.flowJson, options);
+}
+
+module.exports = {
+  flow,
+  queueCheck,
+  queueEdges,
+  queueRelated,
+  queues,
+  serverContracts,
+  serverRouteEdges,
+  serverRouteList,
+  serverRouteRelated,
+  serverRoutes,
+  testsComment,
+  testsGraph,
+  testsGraphMermaid,
+  testsImpact,
+  testsPlan,
+  testsTargets,
+  testsWhy,
+};

package/scripts/install/download.js

@@ -78,6 +78,13 @@ function request(
           return;
         }
 
+        try {
+          validateUrl(redirectedUrl.toString());
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
         request(
           redirectedUrl.toString(),
           handleResponse,

package/server-contract-types.d.ts

@@ -0,0 +1,29 @@
+export interface ServerContractsReport {
+  routes: ServerRouteContract[];
+  clientRefs: ServerContractClientRef[];
+  mismatches: ServerContractMismatch[];
+}
+
+export interface ServerRouteContract {
+  file: string;
+  line: number;
+  method: string;
+  route: string;
+  queryParams: string[];
+}
+
+export interface ServerContractClientRef {
+  file: string;
+  line: number;
+  route: string;
+  queryParams: string[];
+  matchedRoute?: string | null;
+}
+
+export interface ServerContractMismatch {
+  file: string;
+  line: number;
+  route: string;
+  matchedRoute: string;
+  missingParams: string[];
+}

package/test-types.d.ts

@@ -31,6 +31,13 @@ export interface TestsImpactOptions {
   includeSymbols?: boolean;
 }
 
+export interface TestsTargetsOptions {
+  framework: "vitest" | "playwright" | "swift";
+  root?: string;
+  config?: string;
+  files: string[];
+}
+
 export interface TestPlan {
   selected_tests: SelectedTest[];
   groups?: TestPlanGroup[];
@@ -73,6 +80,23 @@ export interface TestPlanWarning {
   file: string;
 }
 
+export interface TestsTargetsReport {
+  framework: "vitest" | "playwright" | "swift";
+  tests: TestTargetRow[];
+  warnings: TestTargetWarning[];
+}
+
+export interface TestTargetRow {
+  testFile: string;
+  targets: TestExecutionTarget[];
+}
+
+export interface TestTargetWarning {
+  type: string;
+  message: string;
+  file: string;
+}
+
 export interface TestsWhyOptions {
   root?: string;
   config?: string;

package/traversal-types.d.ts

@@ -1,3 +1,5 @@
+import type { ImportUsagesOptions } from "./import-usage-types";
+import type { FlowOptions } from "./flow-types";
 import type { PlaywrightOptions, PlaywrightRelatedOptions } from "./report-types";
 
 export type Relationship =
@@ -172,28 +174,26 @@ export interface ProjectOptions {
 }
 
 type BatchedProjectOptions = Omit<ProjectOptions, "root" | "tsconfig" | "config">;
+type BatchedFlowOptions = Omit<FlowOptions, "root" | "tsconfig" | "config">;
 type BatchedQueueRelatedOptions = BatchedProjectOptions & { files: string[] };
 type BatchedServerRouteRelatedOptions = BatchedProjectOptions &
   ({ files: string[] } | { roots: string[] });
 
-export interface FetchesOptions {
-  root?: string;
-  config?: string;
-  targets?: string[];
-}
-
 export type AnalyzeProjectReportRequest =
   | ({ type: "dependencies" | "dependents" | "related"; id?: string } & Omit<
       TraverseOptions,
       "root" | "tsconfig"
     >)
   | ({ type: "symbols"; id?: string } & (SymbolsListOptions | SymbolsSignatureImpactOptions))
+  | ({ type: "importUsages"; id?: string } & Omit<ImportUsagesOptions, "root">)
+  | ({ type: "flow"; id?: string } & BatchedFlowOptions)
   | ({ type: "queues" | "queueEdges" | "queueCheck"; id?: string } & BatchedProjectOptions)
   | ({ type: "queueRelated"; id?: string } & BatchedQueueRelatedOptions)
   | ({
       type: "serverRoutes" | "serverRouteList" | "serverRouteEdges";
       id?: string;
     } & BatchedProjectOptions)
+  | ({ type: "serverContracts"; id?: string } & BatchedProjectOptions)
   | ({ type: "serverRouteRelated"; id?: string } & BatchedServerRouteRelatedOptions)
   | ({ type: "reactAnalyze" | "reactCheck"; id?: string } & Pick<
       ProjectOptions,

package/types.d.ts

@@ -1,6 +1,9 @@
 export * from "./traversal-types";
+export * from "./flow-types";
+export * from "./import-usage-types";
 export * from "./test-types";
 export * from "./report-types";
+export * from "./server-contract-types";
 export * from "./ci-types";
 export * from "./query-types";
 export * from "./named-query-types";