no-mistakes 0.69.0 → 0.71.1

package/index.d.ts

@@ -1,3 +1,15 @@
+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,
+  PostgresCompleteCatalog,
+  PostgresOrderingCatalog,
+} from "./postgres-catalog-types";
+export type * from "./postgres-catalog-types";
 import type {
   CheckReport,
   AnalyzeProjectOptions,
@@ -175,3 +187,17 @@ export function reactCheck(
 export function reactUsages(
   options: WithInvocationOptions<ProjectOptions & { target: string }>,
 ): Promise<ReactUsagesReport>;
+
+/**
+ * Observe committed PostgreSQL metadata in a read-only transaction and return the catalog that
+ * `schemaCatalogPath` reads. Requires psql. `coverage: "ordering"` returns only the ordering facts.
+ */
+export function generatePostgresCatalog(
+  options: WithInvocationOptions<PostgresCatalogOptions & { coverage: "ordering" }>,
+): Promise<PostgresOrderingCatalog>;
+export function generatePostgresCatalog(
+  options: WithInvocationOptions<PostgresCatalogOptions & { coverage?: "complete" }>,
+): Promise<PostgresCompleteCatalog>;
+export function generatePostgresCatalog(
+  options: WithInvocationOptions<PostgresCatalogOptions>,
+): Promise<PostgresCatalog>;

package/index.js

@@ -24,6 +24,8 @@ function createJsonApis(descriptors) {
 }
 
 const jsonApis = createJsonApis({
+  parsePostgresSql: "parsePostgresSqlJson",
+  generatePostgresCatalog: "generatePostgresCatalogJson",
   analyzeProject: "analyzeProjectJson",
   callSites: "callSitesJson",
   check: "checkJson",
@@ -164,3 +166,6 @@ module.exports.testsImpact = planning.testsImpact;
 module.exports.testsPlan = planning.testsPlan;
 module.exports.testsTargets = planning.testsTargets;
 module.exports.testsWhy = planning.testsWhy;
+
+module.exports.generatePostgresCatalog = jsonApis.generatePostgresCatalog;
+module.exports.parsePostgresSql = jsonApis.parsePostgresSql;

package/index.mjs

@@ -20,6 +20,8 @@ export const {
   exportsOf,
   fetches,
   flow,
+  generatePostgresCatalog,
+  parsePostgresSql,
   impactedChecks,
   importUsages,
   importers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.69.0",
+  "version": "0.71.1",
   "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.69.0",
-    "no-mistakes-linux-arm64-gnu": "0.69.0",
-    "no-mistakes-linux-x64-gnu": "0.69.0",
-    "no-mistakes-win32-x64-msvc": "0.69.0"
+    "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"
   }
 }

package/postgres-catalog-types.d.ts

@@ -0,0 +1,115 @@
+/** 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;
+  /** Exact PostgreSQL schema name. */
+  schema: string;
+  /**
+   * `complete` (the default) carries every schema fact, and every catalog rule accepts it.
+   * `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[];
+}
+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. */
+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>;
+  views: Record<string, PostgresCatalogView>;
+}
+export type PostgresCatalog = PostgresOrderingCatalog | PostgresCompleteCatalog;
+export interface PostgresCatalogColumn {
+  dataType: string;
+  nullable: boolean;
+  ordinalPosition: number;
+  defaultExpression: string | null;
+  generated: "stored" | "virtual" | null;
+  generatedExpression: string | null;
+  identity: "a" | "d" | null;
+}
+export interface PostgresCompleteCatalogColumn extends PostgresCatalogColumn {
+  comment: string | null;
+}
+export interface PostgresCatalogIndexKey {
+  column: string | null;
+  opclass: string;
+  collation: string | null;
+  orderingSupported: boolean;
+  expression: string;
+  descending: boolean;
+  nullsFirst: boolean;
+}
+export interface PostgresCatalogIndex {
+  accessMethod: string;
+  unique: boolean;
+  primary: boolean;
+  constraintBacked: boolean;
+  immediate: boolean;
+  live: boolean;
+  valid: boolean;
+  ready: boolean;
+  predicate: string | null;
+  definition: string;
+  keys: PostgresCatalogIndexKey[];
+}
+export interface PostgresCatalogTable {
+  relationKind: "table" | "partitioned table";
+  columns: Record<string, PostgresCatalogColumn>;
+  primaryKey: { columns: string[] } | null;
+  uniqueConstraints: Record<string, { columns: string[] }>;
+  indexes: Record<string, PostgresCatalogIndex>;
+}
+export interface PostgresCatalogForeignKey {
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete: "NO ACTION" | "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT";
+  onUpdate: "NO ACTION" | "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT";
+  validated: boolean;
+}
+export interface PostgresCompleteCatalogTable extends Omit<PostgresCatalogTable, "columns"> {
+  columns: Record<string, PostgresCompleteCatalogColumn>;
+  comment: string | null;
+  /** `pg_get_partkeydef` text such as `RANGE (created_at)`; `null` unless partitioned. */
+  physicalPartition: { key: string } | null;
+  foreignKeys: Record<string, PostgresCatalogForeignKey>;
+  /** `definition` is `pg_get_constraintdef` text; NOT NULL constraints are not checks. */
+  checkConstraints: Record<string, { definition: string; validated: boolean }>;
+  /** `definition` is `pg_get_triggerdef` text; internal triggers are omitted. */
+  triggers: Record<string, { definition: string }>;
+}
+/** Keyed by name and identity arguments, such as `touch()` or `over(a integer)`. */
+export interface PostgresCatalogFunction {
+  /** `pg_get_functiondef` text. */
+  definition: string;
+}
+export interface PostgresCatalogEnum {
+  /** Labels in `enumsortorder`. */
+  values: string[];
+}
+export interface PostgresCatalogView {
+  materialized: boolean;
+  /** `pg_get_viewdef` text. */
+  definition: string;
+  comment: string | null;
+}

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-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,198 @@
+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[];
+}
+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[];
+}