@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/dist/spec/postgres-fetch.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Where generation gets the Postgres catalogs.
+ *
+ * The committed snapshots, `postgres-catalog-<major>.snapshot.json`, are the
+ * source every ordinary run reads: a fresh clone, CI and `npm run prepack`
+ * generate from them with no Docker and no network. A server is read, one per
+ * major, only when a snapshot cannot serve its pin:
+ *
+ * - the major's pin moved (its `version` in `postgres-pin.ts` differs from the
+ *   snapshot's) or the snapshot is missing or unreadable, or
+ * - `force` is set.
+ *
+ * Reading a server means starting that major's image by tag and digest in a
+ * throwaway container, checking that its `server_version` is the pin, reading
+ * the catalog, and rewriting the snapshot. A server at any other version is
+ * refused: a snapshot labelled with one pin and holding another's surface is
+ * the failure the pin exists to prevent.
+ */
+import { type PostgresPin } from "./postgres-pin.js";
+import { type PostgresCatalog, type PostgresReader } from "./postgres-catalog.js";
+/** The committed snapshot of one major. */
+export declare const snapshotFile: (major: number, dir?: string) => string;
+export interface FetchCatalogsOptions {
+    /** Read a server even when the snapshot matches the pin. */
+    force?: boolean;
+    /** Only these majors (the default is all). */
+    majors?: readonly number[];
+    /** The directory holding the snapshots. Tests point it elsewhere. */
+    snapshotDir?: string;
+    /** Start the server for a major. Tests stub it; the default runs the pinned image. */
+    startServer?: (image: string) => Promise<{
+        reader: PostgresReader;
+        stop(): Promise<void>;
+    }>;
+    /** Log a line saying which route was taken. */
+    log?: (line: string) => void;
+}
+/** Read one pin's catalog from a server and refuse any other version. */
+export declare function catalogFromServer(reader: PostgresReader, pin: PostgresPin, image: string): Promise<PostgresCatalog>;
+/**
+ * The catalogs for the current pins, oldest major first: each snapshot that
+ * matches its pin, and a fresh read (which rewrites the snapshot) for each
+ * that does not. Servers run one at a time.
+ */
+export declare function fetchCatalogs(options?: FetchCatalogsOptions): Promise<PostgresCatalog[]>;
+//# sourceMappingURL=postgres-fetch.d.ts.map

package/dist/spec/postgres-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-fetch.d.ts","sourceRoot":"","sources":["../../src/spec/postgres-fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,EAA6C,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAA+C,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAK5H,2CAA2C;AAC3C,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,MAAK,MAAgB,KAAG,MACd,CAAC;AAEvD,MAAM,WAAW,oBAAoB;IACnC,4DAA4D;IAC5D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sFAAsF;IACtF,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC,CAAC;IAC5F,+CAA+C;IAC/C,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAUD,yEAAyE;AACzE,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CASzH;AAUD;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAiClG"}

package/dist/spec/postgres-pin.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The pinned Postgres servers the Postgres dialect's types come from.
+ *
+ * Postgres publishes no schema for its DDL either. Types, access methods,
+ * operator classes, settings, keywords, function names and extensions are read
+ * from a running server's catalog (chant #3277), so a pin is a server image.
+ * One snapshot per supported major, 14 to 18 (14 leaves community support in
+ * November 2026, and dropping it is deleting its entry and its snapshot), and
+ * the generated types are the union of the five with a `since` and an `until`
+ * major on every entry that is not in all of them.
+ *
+ * Each entry pins an exact minor by tag and by digest. The type surface does
+ * not move between minors (17.9 against 17.11 differs by one setting), but a
+ * floating `18` tag would change generated output with no commit, and a
+ * re-pushed tag must not change it unseen either: generation runs
+ * `image@digest` and refuses a server whose `server_version` is not the
+ * entry's version. The digest is the multi-arch manifest list's.
+ *
+ * Moving a pin: change that major's `version` and `digest` on its one line,
+ * then `chant dev generate` (or `npm run generate`). The committed snapshot no
+ * longer matches, so generation starts that image, rewrites
+ * `src/spec/postgres-catalog-<major>.snapshot.json`, and the pull request's
+ * diff of that file is the surface change. Read its `-` lines: a removed
+ * setting or function is what breaks declarations. Adding a major is one more
+ * line here and one more snapshot.
+ *
+ * The lines are written one per major, in this exact shape, because
+ * {@link postgresUpstreamPin} finds a major's version with a regular
+ * expression over its line.
+ */
+import type { UpstreamPin } from "@intentius/chant/lexicon";
+export interface PostgresPin {
+    /** The major, as `server_version_num / 10000`. */
+    major: number;
+    /** The exact minor, as `server_version` reports it with the Debian build suffix removed, and the docker tag. */
+    version: string;
+    /** The image digest of `postgres:<version>`. Move it with the version. */
+    digest: string;
+}
+/** The official server image. */
+export declare const POSTGRES_IMAGE_REPOSITORY = "postgres";
+/** One pin per supported major, oldest first. */
+export declare const POSTGRES_PINS: readonly PostgresPin[];
+/** The supported majors, oldest first. */
+export declare const POSTGRES_MAJORS: readonly number[];
+/** The latest supported major: the emulator image and the default for a project that names no version. */
+export declare const POSTGRES_LATEST_MAJOR: number;
+export declare function postgresPin(major: number): PostgresPin;
+/** The full image reference generation runs: tag for the reader, digest for the runtime. */
+export declare function postgresImage(major: number): string;
+/**
+ * `postgres/postgres` publishes no GitHub releases, only tags: `REL_18_6`,
+ * `REL_18_BETA1`, `REL_18_RC1`, `REL9_6_24`, `Release_2_0`. A stable release
+ * maps to `18.6`; every other spelling is skipped.
+ */
+export declare function versionFromReleaseTag(tag: string): string | null;
+/**
+ * The upstream pin descriptor for one major's line in this file, labelled
+ * `postgres-<major>`. The sql plugin lists all five in `upstreamPins` beside
+ * ClickHouse's `upstreamPin`, so `chant dev pinned-upgrade` and the upgrade Op
+ * report each. Each tracks only its own major (`trackMajor`), so the 17 pin
+ * reports `17.12` and never `18.6`.
+ */
+export declare function postgresUpstreamPin(major: number): UpstreamPin & {
+    readonly label: string;
+};
+//# sourceMappingURL=postgres-pin.d.ts.map

package/dist/spec/postgres-pin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-pin.d.ts","sourceRoot":"","sources":["../../src/spec/postgres-pin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,gHAAgH;IAChH,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iCAAiC;AACjC,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD,iDAAiD;AACjD,eAAO,MAAM,aAAa,EAAE,SAAS,WAAW,EAM/C,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAAsC,CAAC;AAEpF,0GAA0G;AAC1G,eAAO,MAAM,qBAAqB,QAA+C,CAAC;AAElF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAItD;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW3F"}