no-mistakes 0.70.0 → 0.72.0

package/index.d.ts

@@ -1,3 +1,8 @@
+import type { PostgresSqlSource, PostgresSqlFacts } from "./postgres-source-types";
+export type * from "./postgres-source-types";
+/** Parse SQL on the native async worker without repository I/O or a database. */
+export function parsePostgresSql(source: PostgresSqlSource): Promise<PostgresSqlFacts>;
+export function parsePostgresSql(sources: PostgresSqlSource[]): Promise<PostgresSqlFacts[]>;
 import type {
   PostgresCatalog,
   PostgresCatalogOptions,

package/index.js

@@ -24,6 +24,7 @@ function createJsonApis(descriptors) {
 }
 
 const jsonApis = createJsonApis({
+  parsePostgresSql: "parsePostgresSqlJson",
   generatePostgresCatalog: "generatePostgresCatalogJson",
   analyzeProject: "analyzeProjectJson",
   callSites: "callSitesJson",
@@ -167,3 +168,4 @@ module.exports.testsTargets = planning.testsTargets;
 module.exports.testsWhy = planning.testsWhy;
 
 module.exports.generatePostgresCatalog = jsonApis.generatePostgresCatalog;
+module.exports.parsePostgresSql = jsonApis.parsePostgresSql;

package/index.mjs

@@ -21,6 +21,7 @@ export const {
   fetches,
   flow,
   generatePostgresCatalog,
+  parsePostgresSql,
   impactedChecks,
   importUsages,
   importers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.70.0",
+  "version": "0.72.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.70.0",
-    "no-mistakes-linux-arm64-gnu": "0.70.0",
-    "no-mistakes-linux-x64-gnu": "0.70.0",
-    "no-mistakes-win32-x64-msvc": "0.70.0"
+    "no-mistakes-darwin-arm64": "0.72.0",
+    "no-mistakes-linux-arm64-gnu": "0.72.0",
+    "no-mistakes-linux-x64-gnu": "0.72.0",
+    "no-mistakes-win32-x64-msvc": "0.72.0"
   }
 }

package/postgres-catalog-types.d.ts

@@ -1,5 +1,7 @@
 /** Which facts a generated catalog carries. It is stated in the catalog's `coverage` field. */
 export type PostgresCatalogCoverage = "complete" | "ordering";
+/** Explicit accessible relation names for requested schemas; an unrequested key is absent. */
+export type PostgresSearchPathEvidence = Partial<Record<string, string[] | null>>;
 export interface PostgresCatalogOptions {
   /** Environment variable containing a PostgreSQL connection URL; never pass secrets as options. */
   connectionEnv: string;
@@ -10,11 +12,21 @@ export interface PostgresCatalogOptions {
    * `ordering` carries only what conflict and lock ordering need; other catalog rules reject it.
    */
   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;
   coverage: "ordering";
   schema: string;
+  searchPathEvidence?: PostgresSearchPathEvidence;
+  /** Exact connected database name; absent in catalogs generated by older versions. */
+  currentDatabase?: string;
   tables: Record<string, PostgresCatalogTable>;
 }
 /** A catalog with every fact the catalog model holds. Every catalog rule accepts it. */
@@ -22,6 +34,9 @@ export interface PostgresCompleteCatalog {
   formatVersion: 2;
   coverage: "complete";
   schema: string;
+  searchPathEvidence?: PostgresSearchPathEvidence;
+  /** Exact connected database name; absent in catalogs generated by older versions. */
+  currentDatabase?: string;
   tables: Record<string, PostgresCompleteCatalogTable>;
   functions: Record<string, PostgresCatalogFunction>;
   enums: Record<string, PostgresCatalogEnum>;

package/postgres-drop-types.d.ts

@@ -0,0 +1,11 @@
+import type { PostgresSqlName } from "./postgres-source-types";
+export interface PostgresSqlDrop {
+  objectType: string;
+  names: PostgresSqlName[];
+  table: PostgresSqlName | null;
+  signatures: string[];
+  ifExists: boolean;
+  cascade: boolean;
+  restrict: boolean;
+  temporary: boolean;
+}

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-procedural-types.d.ts

@@ -0,0 +1,25 @@
+import type {
+  PostgresSqlDiagnostic,
+  PostgresSqlExpression,
+  PostgresSqlSpan,
+  PostgresSqlStatement,
+} from "./postgres-source-types";
+/** Nested facts are procedural source occurrences, never guaranteed execution. */
+export interface PostgresSqlProceduralBlock {
+  language: string;
+  bodyEncoding: PostgresSqlBodyEncoding;
+  bodySpan: PostgresSqlSpan;
+  statements: PostgresSqlStatement[];
+  diagnostics: PostgresSqlDiagnostic[];
+  complete: boolean;
+}
+
+/** Branch DDL describes source occurrences, never guaranteed execution. */
+export interface PostgresSqlConditionalBranch {
+  condition: PostgresSqlExpression | null;
+  span: PostgresSqlSpan;
+  statements: PostgresSqlStatement[];
+}
+
+/** Original body source slices retain this enclosing literal encoding. */
+export type PostgresSqlBodyEncoding = "dollarQuoted" | "singleQuoted";

package/postgres-source-types.d.ts

@@ -0,0 +1,201 @@
+import type { PostgresSqlExpressionRoot } from "./postgres-expression-types";
+export type * from "./postgres-expression-types";
+import type { PostgresSqlDrop } from "./postgres-drop-types";
+export type * from "./postgres-drop-types";
+import type {
+  PostgresSqlConditionalBranch,
+  PostgresSqlProceduralBlock,
+} from "./postgres-procedural-types";
+export type * from "./postgres-procedural-types";
+/** Pure SQL source input. No repository, database, or filesystem options are needed. */
+export interface PostgresSqlSource {
+  sql: string;
+  fileName?: string | null;
+}
+/** UTF-8 byte offset, with one-based Unicode scalar line and column. */
+export interface PostgresSqlPosition {
+  offset: number;
+  line: number;
+  column: number;
+}
+/** End-exclusive source span. */
+export interface PostgresSqlSpan {
+  start: PostgresSqlPosition;
+  end: PostgresSqlPosition;
+}
+export interface PostgresSqlDiagnostic {
+  message: string;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlIdentifier {
+  value: string;
+  quoted: boolean;
+  identity: string;
+}
+export interface PostgresSqlName {
+  parts: PostgresSqlIdentifier[];
+  sql: string;
+}
+export interface PostgresSqlFunctionReference {
+  name: PostgresSqlName;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlExpression {
+  sql: string;
+  identity: string;
+  span: PostgresSqlSpan | null;
+  columns: PostgresSqlName[];
+  functions: PostgresSqlFunctionReference[];
+  root: PostgresSqlExpressionRoot;
+}
+export interface PostgresSqlType {
+  sql: string;
+  name: PostgresSqlName | null;
+  builtin: string | null;
+  modifiers: string[];
+  arrayDimensions: (number | null)[];
+  fields: PostgresSqlColumn[];
+}
+export interface PostgresSqlGeneratedColumn {
+  expression: PostgresSqlExpression;
+  storage: string | null;
+}
+export interface PostgresSqlIdentityColumn {
+  mode: string;
+  options: string[];
+}
+export interface PostgresSqlColumn {
+  name: PostgresSqlIdentifier;
+  dataType: PostgresSqlType;
+  nullable: boolean;
+  default: PostgresSqlExpression | null;
+  generated: PostgresSqlGeneratedColumn | null;
+  identity: PostgresSqlIdentityColumn | null;
+  constraints: PostgresSqlConstraint[];
+  span: PostgresSqlSpan | null;
+}
+export type PostgresSqlConstraintKind = "primaryKey" | "unique" | "foreignKey" | "check" | "other";
+export interface PostgresSqlConstraint {
+  kind: PostgresSqlConstraintKind;
+  name: PostgresSqlIdentifier | null;
+  columns: PostgresSqlIdentifier[];
+  expression: PostgresSqlExpression | null;
+  referencedTable: PostgresSqlName | null;
+  referencedColumns: PostgresSqlIdentifier[];
+  onDelete: string | null;
+  onUpdate: string | null;
+  characteristics: string | null;
+  sql: string;
+}
+export type PostgresSqlAlterOperation =
+  | { kind: "addColumn"; column: PostgresSqlColumn }
+  | {
+      kind: "alterColumnType";
+      column: PostgresSqlIdentifier;
+      dataType: PostgresSqlType;
+      using: PostgresSqlExpression | null;
+    }
+  | { kind: "setDefault"; column: PostgresSqlIdentifier; expression: PostgresSqlExpression }
+  | { kind: "dropDefault" | "setNotNull" | "dropNotNull"; column: PostgresSqlIdentifier }
+  | { kind: "addConstraint"; constraint: PostgresSqlConstraint; notValid: boolean }
+  | { kind: "validateConstraint"; name: PostgresSqlIdentifier }
+  | { kind: "other"; sql: string };
+export interface PostgresSqlIndexKey {
+  expression: PostgresSqlExpression;
+  ascending: boolean;
+  nullsFirst: boolean;
+  operatorClass: PostgresSqlName | null;
+}
+export interface PostgresSqlIndex {
+  name: PostgresSqlName | null;
+  table: PostgresSqlName;
+  method: string;
+  unique: boolean;
+  nullsDistinct: boolean;
+  keys: PostgresSqlIndexKey[];
+  include: PostgresSqlIdentifier[];
+  predicate: PostgresSqlExpression | null;
+  options: string[];
+  structuralIdentity: string;
+}
+export interface PostgresSqlView {
+  name: PostgresSqlName;
+  columns: PostgresSqlIdentifier[];
+  materialized: boolean;
+  temporary: boolean;
+  orReplace: boolean;
+  query: string;
+  dependencies: PostgresSqlName[];
+  dependenciesComplete: boolean;
+  functions: PostgresSqlFunctionReference[];
+}
+export interface PostgresSqlTriggerTransition {
+  kind: string;
+  name: PostgresSqlName;
+}
+export interface PostgresSqlTrigger {
+  name: PostgresSqlName;
+  table: PostgresSqlName;
+  timing: string | null;
+  events: string[];
+  forEach: string | null;
+  condition: PostgresSqlExpression | null;
+  function: PostgresSqlName | null;
+  arguments: string[];
+  constraint: boolean;
+  orReplace: boolean;
+  referencedTable: PostgresSqlName | null;
+  transitions: PostgresSqlTriggerTransition[];
+  executionKind: string | null;
+  characteristics: string | null;
+}
+export interface PostgresSqlFunctionArgument {
+  name: PostgresSqlIdentifier | null;
+  mode: string | null;
+  dataType: PostgresSqlType;
+  default: PostgresSqlExpression | null;
+}
+export interface PostgresSqlFunction {
+  name: PostgresSqlName;
+  arguments: PostgresSqlFunctionArgument[];
+  returnType: PostgresSqlType | null;
+  returnsSet: boolean;
+  language: string | null;
+  behavior: string | null;
+  bodySql: string | null;
+  orReplace: boolean;
+  temporary: boolean;
+  calledOnNull: string | null;
+  parallel: string | null;
+  configuration: string[];
+  security: string | null;
+}
+export type PostgresSqlStatementKind =
+  | {
+      kind: "createTable";
+      table: PostgresSqlName;
+      columns: PostgresSqlColumn[];
+      constraints: PostgresSqlConstraint[];
+      temporary: boolean;
+    }
+  | { kind: "alterTable"; table: PostgresSqlName; operations: PostgresSqlAlterOperation[] }
+  | { kind: "createIndex"; index: PostgresSqlIndex }
+  | { kind: "createView"; view: PostgresSqlView }
+  | { kind: "createTrigger"; trigger: PostgresSqlTrigger }
+  | { kind: "createFunction"; function: PostgresSqlFunction }
+  | { kind: "drop"; drop: PostgresSqlDrop }
+  | { kind: "doBlock"; block: PostgresSqlProceduralBlock }
+  | { kind: "conditional"; branches: PostgresSqlConditionalBranch[] }
+  | { kind: "other" };
+export type PostgresSqlStatement = PostgresSqlStatementKind & {
+  ordinal: number;
+  span: PostgresSqlSpan;
+  sql: string;
+};
+/** Versioned facts retain valid neighbors when a statement cannot be parsed. */
+export interface PostgresSqlFacts {
+  schemaVersion: 1;
+  fileName: string | null;
+  statements: PostgresSqlStatement[];
+  diagnostics: PostgresSqlDiagnostic[];
+}