no-mistakes 0.71.1 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.71.1",
+  "version": "0.73.0",
   "description": "Deterministic impact maps, test plans, Playwright coverage, and repository checks for coding agents",
   "license": "MIT",
   "repository": {
@@ -45,9 +45,9 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "no-mistakes-darwin-arm64": "0.71.1",
-    "no-mistakes-linux-arm64-gnu": "0.71.1",
-    "no-mistakes-linux-x64-gnu": "0.71.1",
-    "no-mistakes-win32-x64-msvc": "0.71.1"
+    "no-mistakes-darwin-arm64": "0.73.0",
+    "no-mistakes-linux-arm64-gnu": "0.73.0",
+    "no-mistakes-linux-x64-gnu": "0.73.0",
+    "no-mistakes-win32-x64-msvc": "0.73.0"
   }
 }

package/postgres-catalog-types.d.ts

@@ -14,6 +14,11 @@ export interface PostgresCatalogOptions {
   coverage?: PostgresCatalogCoverage;
   /** Opt in to evidence for these exact schemas; absent or inaccessible schemas become null. */
   searchPathSchemas?: string[];
+  /**
+   * Non-empty name to record as `currentDatabase` instead of the connected database's name.
+   * Use the deployed database's name so regeneration does not depend on where it runs.
+   */
+  currentDatabase?: string;
 }
 export interface PostgresOrderingCatalog {
   formatVersion: 2;

package/postgres-expression-types.d.ts

@@ -0,0 +1,29 @@
+import type {
+  PostgresSqlIdentifier,
+  PostgresSqlName,
+  PostgresSqlSpan,
+} from "./postgres-source-types";
+/** Syntactic root; wrappers never promote a nested call through an unrelated operator. */
+export type PostgresSqlExpressionRoot =
+  | { kind: "columnReference"; name: PostgresSqlName }
+  | {
+      kind: "functionCall";
+      name: PostgresSqlName;
+      arguments: PostgresSqlCallArgument[];
+      argumentsComplete: boolean;
+      syntax: PostgresSqlFunctionSyntax;
+      modifiers: string[];
+    }
+  | { kind: "parenthesized"; expression: PostgresSqlExpressionRoot }
+  | { kind: "cast"; dataType: string; expression: PostgresSqlExpressionRoot }
+  | { kind: "literal"; sql: string }
+  | { kind: "binary" | "unary"; operator: string }
+  | { kind: "case" | "subquery" | "other" };
+/** Bare CURRENT_TIMESTAMP is a value function; CURRENT_TIMESTAMP(3) uses call syntax. */
+export type PostgresSqlFunctionSyntax = "call" | "value";
+export interface PostgresSqlCallArgument {
+  name: PostgresSqlIdentifier | null;
+  sql: string;
+  span: PostgresSqlSpan | null;
+  root: PostgresSqlExpressionRoot;
+}

package/postgres-query-types.d.ts

@@ -0,0 +1,127 @@
+import type {
+  PostgresSqlIdentifier,
+  PostgresSqlName,
+  PostgresSqlSpan,
+} from "./postgres-source-types";
+/** Syntactic SELECT facts; IDs are deterministic and local to this query report. */
+export interface PostgresSqlQuery {
+  scopes: PostgresSqlQueryScope[];
+  relations: PostgresSqlQueryRelation[];
+  joins: PostgresSqlQueryJoin[];
+  columns: PostgresSqlQueryColumn[];
+  equalities: PostgresSqlQueryEquality[];
+  exists: PostgresSqlQueryExists[];
+  ctes: PostgresSqlQueryCte[];
+  unsupported: PostgresSqlQueryUnsupported[];
+  complete: boolean;
+}
+export type PostgresSqlQueryClause =
+  | "root"
+  | "setBranch"
+  | "cte"
+  | "from"
+  | "projection"
+  | "where"
+  | "joinOn"
+  | "having"
+  | "groupBy"
+  | "orderBy"
+  | "limit"
+  | "offset"
+  | "other";
+export interface PostgresSqlQueryScope {
+  id: number;
+  parentScopeId: number | null;
+  clause: PostgresSqlQueryClause;
+  cteDefinitionId: number | null;
+  setOperation: string | null;
+  setQuantifier: string | null;
+  span: PostgresSqlSpan | null;
+}
+export type PostgresSqlQueryRelationKind = "table" | "cte" | "derived" | "joined" | "unsupported";
+export interface PostgresSqlQueryRelation {
+  id: number;
+  scopeId: number;
+  kind: PostgresSqlQueryRelationKind;
+  name: PostgresSqlName | null;
+  alias: PostgresSqlIdentifier | null;
+  columnAliases: PostgresSqlIdentifier[];
+  cteId: number | null;
+  subqueryScopeId: number | null;
+  members: number[];
+  lateral: boolean;
+  span: PostgresSqlSpan | null;
+}
+export type PostgresSqlQueryJoinKind =
+  | "inner"
+  | "left"
+  | "right"
+  | "full"
+  | "cross"
+  | "semi"
+  | "anti"
+  | "other";
+export interface PostgresSqlQueryJoin {
+  id: number;
+  scopeId: number;
+  kind: PostgresSqlQueryJoinKind;
+  left: number[];
+  right: number[];
+  constraint: string;
+  usingColumns: PostgresSqlName[];
+  span: PostgresSqlSpan | null;
+}
+export type PostgresSqlQueryColumnResolution = "resolved" | "unqualified" | "unknown" | "ambiguous";
+export interface PostgresSqlQueryColumn {
+  scopeId: number;
+  clause: PostgresSqlQueryClause;
+  name: PostgresSqlName;
+  relationId: number | null;
+  relationScopeId: number | null;
+  resolution: PostgresSqlQueryColumnResolution;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlPredicateContext {
+  mandatory: boolean;
+  underOr: boolean;
+  underNot: boolean;
+  underCase: boolean;
+  underBooleanTest: boolean;
+  underOther: boolean;
+}
+export interface PostgresSqlQueryEquality {
+  scopeId: number;
+  clause: PostgresSqlQueryClause;
+  joinId: number | null;
+  left: PostgresSqlQueryColumn | null;
+  right: PostgresSqlQueryColumn | null;
+  context: PostgresSqlPredicateContext;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlQueryExists {
+  scopeId: number;
+  subqueryScopeId: number;
+  negated: boolean;
+  context: PostgresSqlPredicateContext;
+  correlated: boolean;
+  correlations: PostgresSqlQueryColumn[];
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlQueryCte {
+  id: number;
+  ownerScopeId: number;
+  queryScopeId: number;
+  name: PostgresSqlIdentifier;
+  columnAliases: PostgresSqlIdentifier[];
+  recursive: boolean;
+  referenced: boolean;
+  used: boolean;
+  cyclic: boolean;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlQueryUnsupported {
+  scopeId: number;
+  clause: PostgresSqlQueryClause;
+  reason: string;
+  span: PostgresSqlSpan | null;
+}

package/postgres-source-types.d.ts

@@ -1,3 +1,7 @@
+import type { PostgresSqlExpressionRoot } from "./postgres-expression-types";
+export type * from "./postgres-expression-types";
+import type { PostgresSqlQuery } from "./postgres-query-types";
+export type * from "./postgres-query-types";
 import type { PostgresSqlDrop } from "./postgres-drop-types";
 export type * from "./postgres-drop-types";
 import type {
@@ -44,6 +48,7 @@ export interface PostgresSqlExpression {
   span: PostgresSqlSpan | null;
   columns: PostgresSqlName[];
   functions: PostgresSqlFunctionReference[];
+  root: PostgresSqlExpressionRoot;
 }
 export interface PostgresSqlType {
   sql: string;
@@ -168,6 +173,7 @@ export interface PostgresSqlFunction {
   security: string | null;
 }
 export type PostgresSqlStatementKind =
+  | { kind: "select"; query: PostgresSqlQuery }
   | {
       kind: "createTable";
       table: PostgresSqlName;