primitive-admin 1.0.55 → 1.0.57

package/dist/src/lib/codegen-shared/prettierStable.js

@@ -0,0 +1,610 @@
+/**
+ * Prettier-default-stable emission helpers for the codegen emitters (#1565).
+ *
+ * ─────────────────────────── FORMATTING CONTRACT ───────────────────────────
+ * Generated `*.generated.ts` output MUST be a fixed point of Prettier's DEFAULT
+ * config (printWidth 80, 2-space indent, `trailingComma: "all"`): running
+ * `prettier --write` over a freshly generated file must leave it byte-for-byte
+ * unchanged.
+ *
+ * Why it matters: `databases codegen --check` / `workflows codegen --check`
+ * compare the emission to what is on disk BYTE-FOR-BYTE
+ * (`codegen-shared/generatedFiles.ts`). A consumer whose pipeline runs codegen,
+ * then `prettier --write`, then `--check` in CI (the common shape) fails the
+ * check the moment the emission is not already prettier-formatted, even though
+ * nothing is semantically stale. That is the bug this module fixes.
+ *
+ * By maintainer decision (#1565) there is NO Prettier dependency anywhere — not
+ * at runtime, not as a devDependency, and there is no automated round-trip
+ * test. The contract is upheld by this module plus the exact-output unit tests
+ * in `cli/tests/unit/codegen-prettier-stable.test.ts`.
+ *
+ * **If you change an emitter or this module, verify the contract by hand before
+ * landing:** regenerate a representative output (a database type with long op
+ * names and a projection; a workflow with a long key and a `oneOf` output),
+ * run Prettier's default config over the files, and confirm they are unchanged
+ * and `--check` still passes.
+ *
+ * Note "always emit the multi-line shape" is NOT sufficient on its own:
+ * Prettier COLLAPSES a broken call/parameter/type-argument list that would fit
+ * within 80 columns, so an over-broken construct is just as unstable as an
+ * over-long one. It only preserves an author's line break inside an object
+ * literal / object type. So the helpers below reproduce Prettier's width
+ * decision for the handful of shapes these generators emit, and the emitters
+ * always break the object literals (where the break IS preserved).
+ * ───────────────────────────────────────────────────────────────────────────
+ */
+/** Prettier's default `printWidth`. */
+export const PRINT_WIDTH = 80;
+/** `level` indentation levels of 2 spaces (Prettier's default `tabWidth`). */
+export function indent(level) {
+    return "  ".repeat(level);
+}
+/**
+ * A TS string literal for `value`, quoted the way Prettier's DEFAULT config
+ * would (`singleQuote: false`).
+ *
+ * `JSON.stringify` is NOT a fixed point: it always double-quotes and escapes
+ * every embedded `"`, but Prettier picks the quote that needs FEWER escapes
+ * (tie → double), so `JSON.stringify("say \"hi\"")` → `"say \"hi\""` while
+ * Prettier emits `'say "hi"'`, and `codegen --check` then fails on a
+ * semantically identical file (#1565). This reproduces Prettier's `printString`
+ * exactly: start from the canonical `JSON.stringify` escaping (correct for all
+ * control characters), count the quotes to choose the enclosing quote, then
+ * re-escape for that quote.
+ */
+export function tsStringLiteral(value) {
+    // `JSON.stringify` yields a valid double-quoted literal with every necessary
+    // escape (`\"`, `\\`, `\n`, `\uXXXX`, …) and no unnecessary ones.
+    const rawContent = JSON.stringify(value).slice(1, -1);
+    // Prettier counts the quote characters in the raw content and switches to the
+    // alternate quote only when the preferred (double) one occurs strictly more
+    // often — i.e. when double-quoting would need more escapes.
+    let doubleCount = 0;
+    let singleCount = 0;
+    for (const ch of rawContent) {
+        if (ch === '"')
+            doubleCount++;
+        else if (ch === "'")
+            singleCount++;
+    }
+    const quote = doubleCount > singleCount ? "'" : '"';
+    const other = quote === '"' ? "'" : '"';
+    // Prettier's `makeString`: unescape the now-enclosing-irrelevant other quote,
+    // escape the enclosing quote, and keep every other escape as JSON produced it.
+    const body = rawContent.replace(/\\(.)|(["'])/gs, (_match, escaped, bareQuote) => {
+        if (escaped !== undefined) {
+            // `\"` becomes a bare `"` when single quotes now enclose the literal.
+            return escaped === other ? escaped : "\\" + escaped;
+        }
+        // A bare quote character: escape it only when it is the enclosing quote.
+        return bareQuote === quote ? "\\" + bareQuote : bareQuote;
+    });
+    return `${quote}${body}${quote}`;
+}
+export const atom = (text) => ({ kind: "atom", text });
+export const block = (render) => ({
+    kind: "block",
+    render,
+});
+export const union = (members) => members.length === 1 ? members[0] : { kind: "union", members };
+export const intersection = (members) => members.length === 1 ? members[0] : { kind: "intersection", members };
+export const generic = (name, args) => ({
+    kind: "generic",
+    name,
+    args,
+});
+export const arrayOf = (element) => ({
+    kind: "array",
+    element,
+});
+/**
+ * An inline-first object type (`{ input: X }`). Unlike `block`, it starts
+ * inline and only breaks when it does not fit — which is exactly what Prettier
+ * does with an object type the emitter writes on one line.
+ */
+export const objectType = (members) => ({
+    kind: "objectType",
+    members,
+});
+/**
+ * `Record<string, T>` — a two-argument generic, so Prettier breaks it open when
+ * a long alias name pushes it past the print width. Never emit it as a plain
+ * atom.
+ */
+export const recordOf = (value) => generic("Record", [atom("string"), atom(value)]);
+/** True when an element type needs parentheses before a `[]` suffix. */
+function needsParensAsArrayElement(node) {
+    return node.kind === "union" || node.kind === "intersection";
+}
+/**
+ * True when Prettier hugs the node as a LONE type argument — an identifier /
+ * keyword or an object type. `Foo<SomeVeryLongIdentifier>` therefore stays on
+ * one line however wide it gets, while `QueryResult<Pick<A, "b">>` (a nested
+ * generic argument) breaks its list open.
+ */
+function isHuggableTypeArg(node) {
+    return node.kind === "atom" || node.kind === "block";
+}
+/**
+ * True when an over-width node can break WITHIN itself, keeping its head on the
+ * line it starts. A lone identifier, or a generic whose single type argument is
+ * hugged (`QueryResult<SomeLongName>`), has no break point — Prettier moves the
+ * whole thing below the `=` of a type alias instead.
+ */
+function canBreakInPlace(node) {
+    switch (node.kind) {
+        case "atom":
+            return false;
+        case "block":
+        case "objectType":
+        case "union":
+        case "intersection":
+            return true;
+        case "array":
+            return canBreakInPlace(node.element);
+        case "generic":
+            return node.args.length === 1 && isHuggableTypeArg(node.args[0])
+                ? canBreakInPlace(node.args[0])
+                : true;
+    }
+}
+/** The width of a string's last line — what a following construct starts from. */
+function lastLineWidth(text) {
+    return text.length - (text.lastIndexOf("\n") + 1);
+}
+/**
+ * The node's single-line form, or null when it contains a `block` (which is
+ * always multi-line and can therefore never render inline).
+ */
+export function inlineType(node) {
+    switch (node.kind) {
+        case "atom":
+            return node.text;
+        case "block":
+            return null;
+        case "union":
+        case "intersection": {
+            const sep = node.kind === "union" ? " | " : " & ";
+            const parts = node.members.map(inlineType);
+            return parts.some((p) => p === null) ? null : parts.join(sep);
+        }
+        case "generic": {
+            const parts = node.args.map(inlineType);
+            if (parts.some((p) => p === null))
+                return null;
+            return `${node.name}<${parts.join(", ")}>`;
+        }
+        case "array": {
+            const elem = inlineType(node.element);
+            if (elem === null)
+                return null;
+            return needsParensAsArrayElement(node.element)
+                ? `(${elem})[]`
+                : `${elem}[]`;
+        }
+        case "objectType":
+            return `{ ${node.members.join("; ")} }`;
+    }
+}
+/**
+ * The width from a node's start to its first break opportunity when it breaks.
+ * Prettier's fit test for a construct looks ahead past it to the next place the
+ * line COULD break, so an intersection member's decision depends on how much of
+ * the following member precedes its own first break.
+ */
+function firstBreakWidth(node) {
+    switch (node.kind) {
+        case "atom":
+            return node.text.length;
+        case "block":
+        case "objectType":
+            return 1; // `{`
+        case "union":
+            return 0;
+        case "array":
+            return needsParensAsArrayElement(node.element)
+                ? 1
+                : firstBreakWidth(node.element);
+        case "intersection":
+            return firstBreakWidth(node.members[0]);
+        case "generic":
+            return node.args.length === 1 && isHuggableTypeArg(node.args[0])
+                ? node.name.length + 1 + firstBreakWidth(node.args[0])
+                : node.name.length + 1; // `Name<`
+    }
+}
+/** True when the node has to break regardless of the available width. */
+function alwaysBreaks(node) {
+    return inlineType(node) === null;
+}
+/**
+ * Render a type expression the way Prettier's default config would.
+ *
+ * The returned string's FIRST line carries NO leading indentation — the caller
+ * has already positioned the cursor at `col`. Continuation lines are indented
+ * relative to `level`.
+ *
+ * @param node    the type expression.
+ * @param col     0-based column where the node's first character sits.
+ * @param level   indentation level for the node's continuation lines.
+ * @param reserve characters that follow the node on its closing line (a
+ *                trailing `;` or `,`), counted in the fit decision so the wrap
+ *                boundary matches Prettier's exactly.
+ */
+export function printType(node, col, level, reserve = 0) {
+    const inline = inlineType(node);
+    if (inline !== null && col + inline.length + reserve <= PRINT_WIDTH) {
+        return inline;
+    }
+    switch (node.kind) {
+        case "atom":
+            // An over-width atom has nowhere to break — Prettier leaves it long too.
+            return node.text;
+        case "block":
+            return node.render(level);
+        case "generic": {
+            // Prettier HUGS a lone type argument that is an identifier/keyword or an
+            // object type — it never breaks the list open, even over-width. Only the
+            // argument itself may break (an object type does).
+            if (node.args.length === 1 && isHuggableTypeArg(node.args[0])) {
+                const inner = printType(node.args[0], col + node.name.length + 1, level, reserve + 1);
+                return `${node.name}<${inner}>`;
+            }
+            // One type argument per line. A type-argument list takes NO trailing
+            // comma under Prettier; a non-last argument reserves its separator.
+            const inner = node.args
+                .map((a, i) => {
+                const last = i === node.args.length - 1;
+                return (indent(level + 1) +
+                    printType(a, (level + 1) * 2, level + 1, last ? 0 : 1));
+            })
+                .join(",\n");
+            return `${node.name}<\n${inner}\n${indent(level)}>`;
+        }
+        case "union":
+            return printUnionBroken(node.members, level);
+        case "array": {
+            // A parenthesized element that overflows breaks inside its parens:
+            // `(\n  | "a"\n  | "b"\n)[]`. A bare element (identifier / generic)
+            // breaks in place and keeps the `[]` on its closing line.
+            if (!needsParensAsArrayElement(node.element)) {
+                return `${printType(node.element, col, level, reserve + 2)}[]`;
+            }
+            // Prettier prints the parens and a union element's `|` separators as ONE
+            // group: once the parens break, the leading-pipe form is forced, so there
+            // is no state where the parens break but the members stay inline. A plain
+            // `printType` of the element would re-run its own fit test and return the
+            // union INLINE whenever it happens to fit at column 2 — emitting
+            // `(\n  "a" | "b"\n)[]`, which Prettier then rewrites. Force the broken
+            // union form here instead so the output is a genuine fixed point.
+            const inner = node.element.kind === "union"
+                ? printUnionBroken(node.element.members, level + 1)
+                : printType(node.element, (level + 1) * 2, level + 1);
+            return `(\n${indent(level + 1)}${inner}\n${indent(level)})[]`;
+        }
+        case "intersection": {
+            // Prettier keeps intersection members on one line and breaks INSIDE the
+            // first member that cannot reach the next break opportunity — so
+            // `{ input: Short } & Omit<A, B>` breaks the `Omit<...>` argument list,
+            // while a long `{ input: VeryLong }` breaks the object instead and leaves
+            // the `Omit<...>` inline on the closing `}` line.
+            let cursor = col;
+            const parts = [];
+            node.members.forEach((m, i) => {
+                const sep = i > 0 ? " & " : "";
+                cursor += sep.length;
+                const last = i === node.members.length - 1;
+                // What follows this member before the line could next break.
+                const lookahead = last
+                    ? reserve
+                    : 3 + firstBreakWidth(node.members[i + 1]);
+                const rendered = printType(m, cursor, level, lookahead);
+                parts.push(sep + rendered);
+                cursor = rendered.includes("\n")
+                    ? lastLineWidth(rendered)
+                    : cursor + rendered.length;
+            });
+            return parts.join("");
+        }
+        case "objectType": {
+            const members = node.members
+                .map((m) => `${indent(level + 1)}${m};`)
+                .join("\n");
+            return `{\n${members}\n${indent(level)}}`;
+        }
+    }
+}
+/**
+ * Prettier's leading-pipe form for a union that has to break — every member on
+ * its own line, whatever their widths. The first line carries no indent (the
+ * caller positioned it); the rest are indented to `level`. A member renders one
+ * level deeper, since the `| ` prefix is exactly one indent wide.
+ */
+function printUnionBroken(members, level) {
+    return members
+        .map((m, i) => {
+        const head = i === 0 ? "| " : `${indent(level)}| `;
+        return head + printType(m, level * 2 + 2, level + 1);
+    })
+        .join("\n");
+}
+/**
+ * Render `export type <name> = <expr>;` as Prettier would.
+ *
+ * A union moves below the `=` in leading-pipe form (its own rule). Otherwise
+ * the RHS stays on the `=` line if it can REACH ITS FIRST BREAK there — so
+ * `= Record<` / `= QueryResult<` stays and breaks its argument list — and
+ * moves below the `=` whole when it cannot (`=\n  MutationResult;`,
+ * `=\n  QueryResult<Pick<M, "a">>;`). That is Prettier's "fluid" assignment
+ * layout: it fit-tests only up to the right-hand side's first break point, not
+ * its whole width.
+ */
+export function renderTypeAlias(name, node) {
+    const prefix = `export type ${name} = `;
+    if (node.kind === "union") {
+        if (!needsHeadBreak(node, prefix.length, 1)) {
+            return `${prefix}${inlineType(node)};`;
+        }
+        // When `export type <name> =` does not itself fit, Prettier switches the
+        // assignment to its break-after-operator layout: the header keeps the `=`
+        // and the union moves below it.
+        if (`export type ${name} =`.length > PRINT_WIDTH) {
+            // In that layout the union is measured afresh at its new indent — the
+            // over-long header is behind it and no longer constrains it. A union that
+            // fits there prints INLINE, with no leading pipes and no blank line
+            // (#1565 review cycle 1).
+            const inlineUnion = inlineType(node);
+            if (inlineUnion !== null &&
+                indent(1).length + inlineUnion.length + 1 <= PRINT_WIDTH) {
+                return `export type ${name} =\n${indent(1)}${inlineUnion};`;
+            }
+            // Only when it still does not fit does it break, and then the assignment's
+            // indent stacks on top of the union's own — the members land one level
+            // deeper, behind a blank line left by the (whitespace-trimmed) empty
+            // first line.
+            const body = printUnionBroken(node.members, 2);
+            return `export type ${name} =\n\n${indent(2)}${body};`;
+        }
+        const body = printUnionBroken(node.members, 1);
+        return `export type ${name} =\n${indent(1)}${body};`;
+    }
+    const inline = inlineType(node);
+    if (inline !== null && prefix.length + inline.length + 1 <= PRINT_WIDTH) {
+        return `${prefix}${inline};`;
+    }
+    const broken = `export type ${name} =\n${indent(1)}${printType(node, 2, 1, 1)};`;
+    // A right-hand side with no break point inside it (`unknown`,
+    // `QueryResult<Thing>` — a lone hugged type argument) can only stay on the
+    // `=` line by fitting there WHOLE, and the inline test above just established
+    // it does not. So it always moves below the `=`.
+    if (!canBreakInPlace(node))
+        return broken;
+    // A breakable one only has to reach its first break point (`<` / `{`) on the
+    // `=` line; it breaks open from there.
+    if (prefix.length + firstBreakWidth(node) > PRINT_WIDTH)
+        return broken;
+    return `${prefix}${printType(node, prefix.length, 0, 1)};`;
+}
+/**
+ * Render an object-type member line (`  name?: T;`) at `level` as Prettier
+ * would. A union that has to break moves below the `name:`; anything else
+ * breaks in place.
+ */
+export function renderMember(level, name, optional, node) {
+    const head = `${indent(level)}${name}${optional ? "?" : ""}: `;
+    if (needsHeadBreak(node, head.length, 1)) {
+        const body = printUnionBroken(node.members, level + 1);
+        return `${head.trimEnd()}\n${indent(level + 1)}${body};`;
+    }
+    return `${head}${printType(node, head.length, level, 1)};`;
+}
+/**
+ * True when a union following a `... = ` / `name: ` prefix must move onto its
+ * own indented lines. Only unions do this — a generic, object type, or
+ * intersection breaks in place, keeping its head on the prefix's line.
+ */
+function needsHeadBreak(node, col, reserve) {
+    if (node.kind !== "union")
+        return false;
+    if (alwaysBreaks(node))
+        return true;
+    const inline = inlineType(node);
+    return col + inline.length + reserve > PRINT_WIDTH;
+}
+/** A parameter entry's single-line form, or null when its type must break. */
+function paramInline(entry) {
+    if (typeof entry === "string")
+        return entry;
+    const inline = inlineType(entry.type);
+    return inline === null ? null : `${entry.name}: ${inline}`;
+}
+/**
+ * Render a parenthesized value/parameter list, wrapping to one entry per line
+ * (WITH a trailing comma — Prettier's default is `trailingComma: "all"`) when
+ * the single-line form would not fit. A `{ name, type }` entry whose type is too
+ * wide for its own line breaks INSIDE itself the way Prettier would.
+ *
+ * `prefix` must include its own leading indentation; `level` is the
+ * indentation level of the line `prefix` sits on.
+ */
+export function renderParenList(prefix, entries, tail, level) {
+    const inlines = entries.map(paramInline);
+    if (inlines.every((e) => e !== null)) {
+        const inline = `${prefix}(${inlines.join(", ")})${tail}`;
+        if (inline.length <= PRINT_WIDTH)
+            return inline;
+    }
+    const body = entries
+        .map((entry) => {
+        if (typeof entry === "string")
+            return `${indent(level + 1)}${entry},`;
+        const head = `${indent(level + 1)}${entry.name}: `;
+        return `${head}${printType(entry.type, head.length, level + 1, 1)},`;
+    })
+        .join("\n");
+    return `${prefix}(\n${body}\n${indent(level)})${tail}`;
+}
+/**
+ * Render a call whose LAST argument is an object literal, the way Prettier's
+ * default config would. Prettier tries three shapes in order and takes the
+ * first that fits, so this does too:
+ *
+ *   1. everything on one line;
+ *   2. "last argument expansion" — hug the object literal, keeping the earlier
+ *      arguments on the call's line and breaking the object's members;
+ *   3. one argument per line (with a trailing comma), the object inline.
+ *
+ * `prefix` (callee + any type arguments) must include its own leading
+ * indentation; `level` is the indentation level of the line it sits on. `tail`
+ * is whatever follows the closing paren (e.g. `","`) and is counted in every
+ * fit decision.
+ *
+ * `objectMembers` is optional: a call with NO trailing object-literal argument
+ * (`define<O>(key, options)`, `subscribe<T>(dbId, key, options)`) passes
+ * `undefined`, and then only two shapes apply — everything on one line, or one
+ * argument per line — since there is no last-argument object to hug.
+ */
+export function renderCall(prefix, leadingArgs, objectMembers, level, tail = "") {
+    // The callee may itself be multi-line (a broken type-argument list); what
+    // matters for every fit decision below is the column its last line ends at.
+    const calleeWidth = lastLineWidth(prefix);
+    // No trailing object literal to hug: Prettier tries one line, then falls
+    // straight to one argument per line (with a trailing comma).
+    if (objectMembers === undefined) {
+        const oneLine = `${prefix}(${leadingArgs.join(", ")})${tail}`;
+        if (calleeWidth + oneLine.length - prefix.length <= PRINT_WIDTH) {
+            return oneLine;
+        }
+        const broken = leadingArgs
+            .map((a) => `${indent(level + 1)}${a},`)
+            .join("\n");
+        return `${prefix}(\n${broken}\n${indent(level)})${tail}`;
+    }
+    const objectInline = `{ ${objectMembers.map(memberInline).join(", ")} }`;
+    const args = [...leadingArgs, objectInline];
+    const oneLine = `${prefix}(${args.join(", ")})${tail}`;
+    if (calleeWidth + oneLine.length - prefix.length <= PRINT_WIDTH) {
+        return oneLine;
+    }
+    const hugHead = `${prefix}(${leadingArgs.map((a) => `${a}, `).join("")}{`;
+    if (calleeWidth + hugHead.length - prefix.length <= PRINT_WIDTH) {
+        return `${hugHead}\n${objectBody(objectMembers, level)}\n${indent(level)}})${tail}`;
+    }
+    // One argument per line. The object argument stays inline on its line if it
+    // fits there; otherwise it expands too.
+    const objectLine = `${indent(level + 1)}${objectInline},`;
+    const objectArg = objectLine.length <= PRINT_WIDTH
+        ? objectLine
+        : `${indent(level + 1)}{\n${objectBody(objectMembers, level + 1)}\n${indent(level + 1)}},`;
+    const broken = [
+        ...leadingArgs.map((a) => `${indent(level + 1)}${a},`),
+        objectArg,
+    ].join("\n");
+    return `${prefix}(\n${broken}\n${indent(level)})${tail}`;
+}
+/** A member's one-line form (`...opts`, `workflowKey: "x"`). */
+function memberInline(m) {
+    return typeof m === "string" ? m : `${m.key}: ${m.value}`;
+}
+/**
+ * An object literal's members, one per line with a trailing comma. A `key:
+ * value` line whose value would overflow moves the value onto the next line
+ * (Prettier's break-after-operator layout for a property with a string value);
+ * a bare entry has no break point and just runs long.
+ */
+function objectBody(members, level) {
+    return members
+        .map((m) => {
+        const line = `${indent(level + 1)}${memberInline(m)},`;
+        if (line.length <= PRINT_WIDTH || typeof m === "string")
+            return line;
+        return `${indent(level + 1)}${m.key}:\n${indent(level + 2)}${m.value},`;
+    })
+        .join("\n");
+}
+/**
+ * Render an arrow function whose body is a single call ending in an object
+ * literal — the shape both codegen factories emit.
+ *
+ * Prettier keeps the body on the `=>` line only when the WHOLE call fits there
+ * on one line; a call that has to break at all moves to its own indented line
+ * (it never hugs the object up onto the `=>` line). `head` is the arrow's
+ * signature through `=>` (it may itself be multi-line if the parameter list
+ * broke); `level` is the indentation level of the body line.
+ */
+export function renderArrowCall(opts) {
+    const { head, callee, leadingArgs, objectMembers, level } = opts;
+    const tail = opts.tail ?? "";
+    const calleeInline = inlineType(callee);
+    const args = objectMembers === undefined
+        ? leadingArgs
+        : [...leadingArgs, `{ ${objectMembers.map(memberInline).join(", ")} }`];
+    const oneLine = `${calleeInline}(${args.join(", ")})${tail}`;
+    if (calleeInline !== null &&
+        lastLineWidth(head) + 1 + oneLine.length <= PRINT_WIDTH) {
+        return `${head} ${oneLine}`;
+    }
+    const prefix = indent(level) + printType(callee, level * 2, level, 1);
+    return `${head}\n${renderCall(prefix, leadingArgs, objectMembers, level, tail)}`;
+}
+/**
+ * Render an object-literal property whose value is an arrow function returning a
+ * single call — the shape the database ops factory emits (`  <op>: (params, …)
+ * => client.databases.executeOperation(…)`).
+ *
+ * Prettier applies its assignment layout to the `key: value` pair: the arrow
+ * stays on the key's line only when it can REACH ITS FIRST BREAK there — the
+ * `(` opening its parameter list. When even that `(` does not fit (a property
+ * key long enough that `<indent><key>: (` passes the print width), Prettier
+ * breaks after the colon and renders the WHOLE arrow — parameter list, return
+ * type, and body — one level deeper:
+ *
+ *     aVeryLongOpName:
+ *       (
+ *         params: P,
+ *         options?: OpsCallOptions,
+ *       ): Promise<R> =>
+ *         client.databases.executeOperation<R>(
+ *           databaseId,
+ *           "aVeryLongOpName",
+ *           { params, ...options },
+ *         ),
+ *
+ * Reproducing that break is what keeps a long-but-legal op name (>= 74
+ * characters, with this file's 4-space property indent) prettier-stable.
+ *
+ * @param level         indentation level of the property line.
+ * @param key           the property key, already quoted if it needs to be.
+ * @param params        the arrow's parameter list entries.
+ * @param signatureTail what follows the parameter list's `)` — e.g.
+ *                      `": Promise<R> =>"`.
+ */
+export function renderArrowProperty(opts) {
+    const { level, key, params, signatureTail, callee } = opts;
+    const { leadingArgs, objectMembers } = opts;
+    const tail = opts.tail ?? "";
+    const keyPrefix = `${indent(level)}${key}: `;
+    // `+ 1` is the arrow's `(` — its first break opportunity.
+    if (keyPrefix.length + 1 > PRINT_WIDTH) {
+        const head = renderParenList(indent(level + 1), params, signatureTail, level + 1);
+        const body = renderArrowCall({
+            head,
+            callee,
+            leadingArgs,
+            objectMembers,
+            level: level + 2,
+            tail,
+        });
+        return `${indent(level)}${key}:\n${body}`;
+    }
+    return renderArrowCall({
+        head: renderParenList(keyPrefix, params, signatureTail, level),
+        callee,
+        leadingArgs,
+        objectMembers,
+        level: level + 1,
+        tail,
+    });
+}
+//# sourceMappingURL=prettierStable.js.map

package/dist/src/lib/codegen-shared/prettierStable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettierStable.js","sourceRoot":"","sources":["../../../../src/lib/codegen-shared/prettierStable.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/db-codegen/dbGenerator.js

@@ -19,7 +19,8 @@ import * as path from "path";
 import { writeOrCheckGeneratedFiles, } from "../codegen-shared/generatedFiles.js";
 import { describeDbType, } from "./dbTypeIR.js";
 import { resolveRecordInterfaceName, opParamsInterfaceName, opResultAliasName, opsFactoryName, subscriptionsFactoryName, objectPropertyKey, } from "./dbNaming.js";
-import { renderHeader, renderRecordInterface, renderOpParamsInterface, renderOpResultAlias, renderFactories, RESULT_ALIASES_BLOCK, } from "./dbTemplates.js";
+import { renderHeader, renderRecordInterface, renderOpParamsInterface, renderOpResultAlias, renderFactories, fieldNameUnion, RESULT_ALIASES_BLOCK, } from "./dbTemplates.js";
+import { atom, generic } from "../codegen-shared/prettierStable.js";
 export { inferArrayParamElementTypes, inferRequiredRecordFields, } from "./dbTypeIR.js";
 const GENERATED_FILE_SUFFIX = ".generated.ts";
 /**
@@ -116,11 +117,13 @@ export function renderDbTypeFile(input) {
     // known member, so this mapping never fails.
     const factorySubscriptions = ir.subscriptions.map((sub) => {
         const interfaceName = recordInterfaceByModel[sub.modelName];
+        // `Pick<Record, "a" | "b">` when the subscription projects fields, else
+        // the bare record interface — built as a `TypeNode` (mirroring
+        // `queryResultGeneric`'s projection) so the emitter can break it the way
+        // Prettier would inside `SubscribeOptions<...>` / `subscribe<...>`.
         const eventType = sub.select && sub.select.length > 0
-            ? `Pick<${interfaceName}, ${sub.select
-                .map((f) => JSON.stringify(f))
-                .join(" | ")}>`
-            : interfaceName;
+            ? generic("Pick", [atom(interfaceName), fieldNameUnion(sub.select)])
+            : atom(interfaceName);
         return {
             propertyKey: objectPropertyKey(sub.subscriptionKey),
             subscriptionKey: sub.subscriptionKey,