@intentius/chant-lexicon-sql 0.124.46 → 0.124.48

package/dist/coverage.js

@@ -4,8 +4,10 @@
  * Which kinds of object each dialect declares (#3911): every `CREATE` command
  * a pinned server has (`./coverage/<dialect>-commands.json`, written by
  * `scripts/sql-create-commands.ts` from the server's own sources) has a row
- * in `./coverage/<dialect>.json` marking it declared, refused with a reason,
- * or out of scope. A command with several forms that differ in what chant can
+ * in `./coverage/<dialect>.json` marking it declared, referenced, refused
+ * with a reason, or out of scope. A referenced kind (a ClickHouse named
+ * collection, #4395) is never declared: a declaration names one, a plan
+ * checks it exists, and import lists the server's as prerequisites. A command with several forms that differ in what chant can
  * hold (`CREATE TYPE ... AS ENUM` and `CREATE TYPE ... AS RANGE`) has a row
  * per form. Import refuses an object of a refused kind by that row's `kind`
  * (`./core/undeclarable.ts`), and the docs page is rendered from the rows
@@ -26,6 +28,8 @@ import postgresKinds from "./coverage/postgres.json" with { type: "json" };
 import clickhouseKinds from "./coverage/clickhouse.json" with { type: "json" };
 import postgresCommands from "./coverage/postgres-commands.json" with { type: "json" };
 import clickhouseCommands from "./coverage/clickhouse-commands.json" with { type: "json" };
+/** Every status a coverage row may have. */
+export const KIND_STATUSES = ["declared", "referenced", "refused", "out-of-scope"];
 /** Each dialect's coverage table. */
 export const KIND_COVERAGE = {
     postgres: postgresKinds.kinds,
@@ -47,7 +51,8 @@ export function kindRow(dialect, kind) {
  * What is wrong with a dialect's coverage table, against its pinned servers'
  * commands: a command a pinned server has and no row covers, a row for a
  * command no pinned server has, a kind named twice, a declared row with no
- * entity, a refused or out-of-scope row with no reason. Empty when complete.
+ * entity, a referenced, refused or out-of-scope row with no reason. Empty
+ * when complete.
  */
 export function kindCoverageProblems(dialect, opts = {}) {
     const rows = opts.rows ?? KIND_COVERAGE[dialect];
@@ -68,8 +73,8 @@ export function kindCoverageProblems(dialect, opts = {}) {
         if (seen.has(r.kind))
             problems.push(`the kind "${r.kind}" has two rows`);
         seen.add(r.kind);
-        if (!["declared", "refused", "out-of-scope"].includes(r.status))
-            problems.push(`${r.kind}: status "${r.status}" is not declared, refused or out-of-scope`);
+        if (!KIND_STATUSES.includes(r.status))
+            problems.push(`${r.kind}: status "${r.status}" is not ${KIND_STATUSES.slice(0, -1).join(", ")} or ${KIND_STATUSES.at(-1)}`);
         if (r.status === "declared" && !r.entity)
             problems.push(`${r.kind} is declared, and names no entity type`);
         if (r.status !== "declared" && !r.reason)

package/dist/drizzle-command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]`
+ * (#4401): build the project the way `chant build` does, folded, and write the
+ * Drizzle schema module {@link renderDrizzle} renders from its entities.
+ *
+ * The file goes to `<project>/drizzle-schema.ts` by default, outside the
+ * source directory the build reads, and starts with chant's generated-file
+ * marker either way. `-o` and `--output` put it elsewhere, which is also the
+ * flag a workspace `generated` entry's generator passes. `--check` renders the
+ * same text and compares it with the file instead of writing it: exit 1,
+ * naming the file, when they differ.
+ */
+import type { CommandGroupContext } from "@intentius/chant/cli/command-group";
+/** The file `chant sql drizzle` writes by default, in the project directory. */
+export declare const DRIZZLE_SCHEMA_FILE = "drizzle-schema.ts";
+export declare function runDrizzle(ctx: CommandGroupContext): Promise<number>;
+//# sourceMappingURL=drizzle-command.d.ts.map

package/dist/drizzle-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-command.d.ts","sourceRoot":"","sources":["../src/drizzle-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAI9E,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AA6BvD,wBAAsB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4C1E"}

package/dist/drizzle-command.js

@@ -0,0 +1,91 @@
+/**
+ * `chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]`
+ * (#4401): build the project the way `chant build` does, folded, and write the
+ * Drizzle schema module {@link renderDrizzle} renders from its entities.
+ *
+ * The file goes to `<project>/drizzle-schema.ts` by default, outside the
+ * source directory the build reads, and starts with chant's generated-file
+ * marker either way. `-o` and `--output` put it elsewhere, which is also the
+ * flag a workspace `generated` entry's generator passes. `--check` renders the
+ * same text and compares it with the file instead of writing it: exit 1,
+ * naming the file, when they differ.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { DrizzleDialectError, renderDrizzle } from "./drizzle.js";
+import { buildFolded, loadProject } from "./sql-types-command.js";
+/** The file `chant sql drizzle` writes by default, in the project directory. */
+export const DRIZZLE_SCHEMA_FILE = "drizzle-schema.ts";
+const USAGE = "usage: chant sql drizzle [--output <path>] [--check] [--bigint number|bigint]";
+function parseArgs(args) {
+    const out = { check: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--output" || a === "-o") {
+            const v = args[++i];
+            if (!v)
+                return { error: `${a} needs a path` };
+            out.output = v;
+        }
+        else if (a.startsWith("--output="))
+            out.output = a.slice("--output=".length);
+        else if (a === "--check")
+            out.check = true;
+        else if (a === "--bigint" || a.startsWith("--bigint=")) {
+            const v = a === "--bigint" ? args[++i] : a.slice("--bigint=".length);
+            if (v !== "number" && v !== "bigint")
+                return { error: "--bigint takes number or bigint" };
+            out.bigint = v;
+        }
+        else
+            return { error: `unknown argument ${a}` };
+    }
+    return out;
+}
+export async function runDrizzle(ctx) {
+    const args = parseArgs(ctx.rawArgs);
+    if ("error" in args) {
+        console.error(`${args.error}\n${USAGE}`);
+        return 1;
+    }
+    const cwd = process.cwd();
+    const project = await loadProject(cwd);
+    const output = args.output !== undefined ? resolve(cwd, args.output) : join(project.projectDir, DRIZZLE_SCHEMA_FILE);
+    const result = await buildFolded(project, "chant sql drizzle", "nothing was written");
+    if (!result)
+        return 1;
+    let rendered;
+    try {
+        rendered = renderDrizzle(result.entities, { config: project.config, ...(args.bigint ? { bigintMode: args.bigint } : {}) });
+    }
+    catch (err) {
+        if (!(err instanceof DrizzleDialectError))
+            throw err;
+        console.error(`chant sql drizzle: ${err.message}`);
+        return 1;
+    }
+    const shown = relative(cwd, output);
+    const named = shown && !shown.startsWith("..") ? shown : output;
+    if (args.check) {
+        // Compares only; the file is never written.
+        const onDisk = existsSync(output) ? readFileSync(output, "utf8") : undefined;
+        if (onDisk === rendered.text) {
+            console.log(`${named} is current`);
+            return 0;
+        }
+        console.error(onDisk === undefined
+            ? `chant sql drizzle: ${named} does not exist; run \`chant sql drizzle\` to write it`
+            : `chant sql drizzle: ${named} differs from what the build declares; run \`chant sql drizzle\` to rewrite it`);
+        return 1;
+    }
+    mkdirSync(dirname(output), { recursive: true });
+    writeFileSync(output, rendered.text);
+    const { tables, views, enums, sequences } = rendered.counts;
+    const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+    console.log(`wrote ${named}: ${[plural(tables, "table"), plural(views, "view"), plural(enums, "enum"), plural(sequences, "sequence")].join(", ")}`);
+    for (const s of rendered.skipped)
+        console.log(`not written: ${s.kind} ${s.names.join(", ")} (${s.reason})`);
+    for (const n of rendered.approximated)
+        console.log(`partly written: ${n}`);
+    return 0;
+}

package/dist/drizzle.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The Drizzle schema module `chant sql drizzle` writes (#4401): a Postgres
+ * build's tables, enums, sequences and views as `drizzle-orm/pg-core`
+ * declarations, so an application queries with Drizzle's row types while
+ * chant owns the schema, the plan and the apply.
+ *
+ * {@link renderDrizzle} is pure: the entities of a build in, the module's
+ * text and a list of what it left out. It reads the objects as the
+ * serializer writes them, as `sql-types.ts` does, so a `.sql` file's objects
+ * and a composite's members are covered as the build covers them.
+ *
+ * The API it writes is drizzle-orm {@link DRIZZLE_ORM_CHECKED}'s `pg-core`
+ * (type definitions read from the published package):
+ *
+ * - `pgTable(name, columns, (t) => [...])`, or `pgSchema(name).table(...)`
+ *   for a schema other than `public` (`pgSchema("public")` throws);
+ * - column builders, `.notNull()`, `.default()`, `.primaryKey()`,
+ *   `.generatedAlwaysAsIdentity()`, `.generatedAlwaysAs()`, `.array()`;
+ * - `foreignKey({ name, columns, foreignColumns })` with `.onDelete()` and
+ *   `.onUpdate()`, `unique(name).on()`, `check(name, sql)`,
+ *   `index(name).on()`, `uniqueIndex(name).on()`;
+ * - `pgEnum`, `pgSequence`, and `pgView(name, columns).existing()`;
+ * - `customType` for a column type Drizzle has no builder for.
+ *
+ * Each column key is the column's name in the database, so a row has the
+ * keys `RowOf` has. Every constraint and index carries the name Postgres
+ * would give it (`./postgres/constraint-names.ts`) when the DDL names none,
+ * so `drizzle-kit` compares equal names.
+ *
+ * Foreign keys use `foreignKey()` and not a column's `.references()`: the
+ * latter takes no name, and Drizzle derives `orders_user_id_users_id_fk`
+ * where Postgres says `orders_user_id_fkey`.
+ *
+ * Views are `.existing()`: chant creates them, and `drizzle-kit` must not.
+ */
+import type { Declarable } from "@intentius/chant/declarable";
+/** The drizzle-orm version whose type definitions the output was written against. */
+export declare const DRIZZLE_ORM_CHECKED = "0.45.4";
+export interface RenderDrizzleOptions {
+    /** The project's config: `sql.postgresMajor` for the catalog, `sql.dialect` when nothing is declared. */
+    config?: Record<string, unknown>;
+    /** How a `bigint` column reads: Drizzle's `number` (the default, as `drizzle-kit pull` writes it) or `bigint`. */
+    bigintMode?: "number" | "bigint";
+}
+export interface DrizzleRender {
+    text: string;
+    /** Objects with no Drizzle declaration, by kind. */
+    skipped: Array<{
+        kind: string;
+        names: string[];
+        reason: string;
+    }>;
+    /** Parts of a mapped object that Drizzle cannot say: `app.orders: ...`. */
+    approximated: string[];
+    counts: {
+        tables: number;
+        views: number;
+        enums: number;
+        sequences: number;
+    };
+}
+/** Thrown for a build that is not Postgres. */
+export declare class DrizzleDialectError extends Error {
+}
+/**
+ * The Drizzle schema module for a build's entities. Throws
+ * {@link DrizzleDialectError} when the build is not Postgres.
+ */
+export declare function renderDrizzle(entities: ReadonlyMap<string, Declarable>, opts?: RenderDrizzleOptions): DrizzleRender;
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../src/drizzle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAU9D,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,WAAW,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,kHAAkH;IAClH,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,2EAA2E;IAC3E,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E;AAED,+CAA+C;AAC/C,qBAAa,mBAAoB,SAAQ,KAAK;CAAG;AAsSjD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,IAAI,GAAE,oBAAyB,GAAG,aAAa,CAyUvH"}