@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/postgres/catalog-types.js

@@ -0,0 +1,18 @@
+/**
+ * The shapes of the generated Postgres tables (`src/generated/postgres.ts`).
+ * The data is generated; these types are not, so the generated module stays
+ * data and a reader of it has one place to look for what a field means.
+ *
+ * The generated types are the union of every supported major's catalog. A
+ * name that is not in all of them carries a {@link VersionRange}, in the
+ * generated `VERSION_RANGES` table and as `@since` / `@until` on the member's
+ * JSDoc. `since` is the first major with the name and is absent when that is
+ * the oldest supported major; `until` is the last major with it and is absent
+ * when that is the newest.
+ */
+/** True when `range` (or no range) covers `major`. */
+export function availableAt(range, major) {
+    if (!range)
+        return true;
+    return (range.since === undefined || major >= range.since) && (range.until === undefined || major <= range.until);
+}

package/dist/postgres/container.js

@@ -0,0 +1,58 @@
+/**
+ * A throwaway `postgres` server in a container, for catalog generation and the
+ * live tests: started under a unique name with no published port, queried with
+ * `docker exec psql`, and always removed.
+ *
+ * The official image restarts the server once after `initdb`, so the ready
+ * line appears twice in its log; the server is ready on the second.
+ */
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { uniqueContainerName } from "../core/container.js";
+export { dockerAvailable } from "../core/container.js";
+const exec = promisify(execFile);
+function psqlIn(name, sql) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("docker", ["exec", "-i", name, "psql", "-U", "postgres", "-qAt", "-v", "ON_ERROR_STOP=1", "-f", "-"]);
+        const out = [];
+        const err = [];
+        child.stdout.on("data", (d) => out.push(d));
+        child.stderr.on("data", (d) => err.push(d));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve(Buffer.concat(out).toString("utf-8"));
+            else
+                reject(new Error(`psql failed (${code}): ${Buffer.concat(err).toString("utf-8").trim()}`));
+        });
+        child.stdin.end(sql);
+    });
+}
+/** Start `image` and wait until the server accepts connections. Pulls the image when it is absent. */
+export async function startScratchPostgres(image, options = {}) {
+    const name = uniqueContainerName(options.namePrefix ?? "chant-sql-pg");
+    let removed = false;
+    const stop = async () => {
+        if (removed)
+            return;
+        removed = true;
+        await exec("docker", ["rm", "-f", "-v", name]).catch(() => undefined);
+    };
+    try {
+        await exec("docker", ["run", "-d", "--name", name, "-e", "POSTGRES_PASSWORD=chant", image], { timeout: 600000 });
+        const deadline = Date.now() + (options.readyTimeoutMs ?? 120000);
+        for (;;) {
+            const logs = await exec("docker", ["logs", name]).then((r) => `${r.stdout}${r.stderr}`, () => "");
+            if ((logs.match(/database system is ready to accept connections/g) ?? []).length >= 2)
+                break;
+            if (Date.now() > deadline)
+                throw new Error(`${name} did not accept connections within the timeout`);
+            await new Promise((r) => setTimeout(r, 500));
+        }
+        return { name, psql: (sql) => psqlIn(name, sql), stop };
+    }
+    catch (err) {
+        await stop();
+        throw err;
+    }
+}