no-mistakes 0.69.0 → 0.70.0

package/index.d.ts

@@ -1,3 +1,10 @@
+import type {
+  PostgresCatalog,
+  PostgresCatalogOptions,
+  PostgresCompleteCatalog,
+  PostgresOrderingCatalog,
+} from "./postgres-catalog-types";
+export type * from "./postgres-catalog-types";
 import type {
   CheckReport,
   AnalyzeProjectOptions,
@@ -175,3 +182,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,7 @@ function createJsonApis(descriptors) {
 }
 
 const jsonApis = createJsonApis({
+  generatePostgresCatalog: "generatePostgresCatalogJson",
   analyzeProject: "analyzeProjectJson",
   callSites: "callSitesJson",
   check: "checkJson",
@@ -164,3 +165,5 @@ 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;

package/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.69.0",
+  "version": "0.70.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.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.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"
   }
 }

package/postgres-catalog-types.d.ts

@@ -0,0 +1,105 @@
+/** Which facts a generated catalog carries. It is stated in the catalog's `coverage` field. */
+export type PostgresCatalogCoverage = "complete" | "ordering";
+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;
+}
+export interface PostgresOrderingCatalog {
+  formatVersion: 2;
+  coverage: "ordering";
+  schema: 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;
+  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;
+}