@vibeorm/generator 1.3.1 → 2.0.0-alpha.10

package/README.md

@@ -1,58 +1,62 @@
 # @vibeorm/generator
 
-TypeScript client generator for VibeORM. Takes a parsed schema IR and produces fully typed client files including model types, input types, delegates, and Zod v4 validation schemas.
+> Part of **[VibeORM](https://github.com/vibeorm/vibeorm)** — a type-safe TypeScript ORM for Bun and Node. Prisma-schema or TypeScript-DSL input, a canonical schema IR, a generated client, and a dialect-aware SQL layer over PostgreSQL, PGlite, SQLite and MySQL.
 
-## Installation
+Turns a `SchemaIR` into a client module directory: plain JavaScript plus a declaration file that is written as text rather than inferred by `tsc`. It is a separate package because the schema-to-client emission is used by the CLI, by build tooling and by tests, none of which want the runtime or the migration engine in scope.
 
 ```bash
-bun add @vibeorm/generator
+bun add @vibeorm/generator@alpha
 ```
 
-## Usage
+> **Pre-release.** `2.0.0-alpha.x`, published under the `alpha` dist-tag. `npm i vibeorm` still resolves to the stable v1 line.
 
-```ts
-import { parsePrismaSchema } from "@vibeorm/parser";
-import { generate } from "@vibeorm/generator";
-import { writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+Most users never install this directly — it ships as a dependency of [`vibeorm`](https://www.npmjs.com/package/vibeorm) and of the generated client. Reach for it when you are writing an adapter or tooling against the runtime.
 
-const schema = parsePrismaSchema({ source: prismaSchemaString });
-const files = generate({ schema });
+## What it emits
 
-const outputDir = "./generated/vibeorm";
-mkdirSync(outputDir, { recursive: true });
+`generateClient` writes exactly three files into `outDir`, in this order:
 
-for (const file of files) {
-  writeFileSync(join(outputDir, file.filename), file.content);
-}
-```
+| File | Contents |
+|---|---|
+| `index.js` | The runtime glue: the normalized IR embedded as plain data, frozen enum objects, a `VibeError` re-export, and the `VibeClient(options)` factory that wires the IR to `@vibeorm/runtime`'s dynamic client. |
+| `index.d.ts` | The entire typed surface, written directly as text. |
+| `README.md` | A short do-not-edit note pointing back at `vibeorm generate`. |
 
-## API
+Output is byte-identical for structurally identical IR: models, enums and extensions are sorted by name, object keys serialize sorted, and every emitter iterates deterministically. That makes a regenerated client a reviewable diff instead of noise.
 
-### `generate({ schema })`
+## Why the .d.ts is written, not inferred
 
-Accepts a `Schema` IR (from `@vibeorm/parser`) and returns an array of `GeneratedFile` objects:
+v1 shipped `.ts` source with inference-heavy generated types, so the consumer's TypeScript server re-derived the ORM's types on every keystroke. v2 emits the declarations as text, and consumers typecheck declarations instead of internals. The cost is measured as the ORM's share of a reference app's typecheck and gated in CI:
+
+| Metric | v1 baseline | v2 measured |
+|---|---|---|
+| Instantiations | 210,840 | **1,531** |
+| Types | 70,558 | **2,006** |
+
+Any feature that would blow that budget ships pre-resolved (generated) rather than inferred. This is the reason the runtime's own delegate types are deliberately broad — precision lives only in the emitted `.d.ts`.
+
+## Usage
 
 ```ts
-type GeneratedFile = {
-  filename: string;
-  content: string;
-};
+import { generateClient } from "@vibeorm/generator";
+import type { GenerateResult } from "@vibeorm/generator";
+
+const result: GenerateResult = await generateClient({
+  schema,                       // SchemaIR from @vibeorm/parser or @vibeorm/dsl
+  outDir: "./generated/vibeorm",
+  extensions: [],               // configured VibeExtension instances, optional
+});
+
+console.log(result.files);      // the written paths, in emission order
 ```
 
-### Generated Files
+`generateClient` throws `VibeError` with code `VIBE_SCHEMA_INVALID` when the IR fails validation, before writing anything.
 
-| File | Contents |
-|------|----------|
-| `enums.ts` | TypeScript enums |
-| `models.ts` | Model types (record shapes) |
-| `inputs.ts` | Create, update, where, and filter input types |
-| `args.ts` | Operation argument types (`FindManyArgs`, `CreateArgs`, etc.) |
-| `result.ts` | Result types narrowed by `select`/`include`/`omit` |
-| `delegates.ts` | Per-model delegate types (the `.findMany()`, `.create()` API surface) |
-| `schemas.ts` | Zod v4 runtime validation schemas |
-| `index.ts` | `VibeClient()` factory that wires model metadata into the runtime |
-
-## License
-
-[MIT](../../LICENSE)
+Extension surfaces are baked into the client rather than resolved at runtime. `bakeExtensions({ schema, extensions })` returns the `BakedExtensions` the emitters consume, and is exported for tooling that needs that view without writing files.
+
+## Links
+
+- [Documentation](https://github.com/vibeorm/vibeorm/tree/master/docs)
+- [Query API](https://github.com/vibeorm/vibeorm/blob/master/docs/queries.md)
+- [Repository and issues](https://github.com/vibeorm/vibeorm)
+- MIT licensed

package/dist/emit-dts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Emits the generated client's index.d.ts as text (decision D3): the entire
+ * typed surface, written directly — no tsc run, no inference for the consumer's
+ * tsserver to pay for.
+ *
+ * Type-budget rules this file is built around (plan §6, constitution rule 2):
+ *   - concrete per-model base types; narrowing via mapped lookups over them;
+ *   - no conditional type deeper than a single level per key — recursion exists
+ *     only where the API is recursive (nested select/include), and each hop is
+ *     one shallow conditional + one mapped lookup;
+ *   - no distributive conditionals over model unions — every model's types are
+ *     spelled out flat;
+ *   - no Zod, no `as const` inference trees, no mega-unions.
+ */
+import type { ComputedManifestEntry } from "@vibeorm/schema";
+import type { BakedExtensions } from "./extension-bake.ts";
+import type { SchemaView } from "./schema-view.ts";
+/**
+ * Emit enums.d.ts: every enum's constant, literal union and flat validator
+ * type, plus the grouped `enumValidators`. Fully pre-resolved — no generics,
+ * no imports — and independent of the client surface in index.d.ts.
+ */
+export declare function emitEnumsDts(params: {
+    view: SchemaView;
+}): string;
+/** Emit the full index.d.ts for a resolved schema view. */
+export declare function emitDts(params: {
+    view: SchemaView;
+    baked?: BakedExtensions;
+    computed?: readonly ComputedManifestEntry[];
+}): string;
+//# sourceMappingURL=emit-dts.d.ts.map

package/dist/emit-dts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-dts.d.ts","sourceRoot":"","sources":["../src/emit-dts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAoB,MAAM,iBAAiB,CAAC;AAG/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAgD,UAAU,EAAE,MAAM,kBAAkB,CAAC;AA4VjG;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,MAAM,CAejE;AAogDD,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,MAAM,EAAE;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,QAAQ,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC7C,GAAG,MAAM,CA8ET"}

package/dist/emit-js.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Emits the generated client's index.js — runtime glue ONLY. All typing lives
+ * in the directly-written index.d.ts (see emit-dts.ts); this file embeds the
+ * normalized Schema IR as plain data (no `as const` inference trees), exports
+ * re-exports the enum constants and `enumValidators` from the lightweight
+ * enums.js entry (emitted here too, by `emitEnumsJs`) and wires `VibeClient()`
+ * to the dynamic client in @vibeorm/runtime. Import specifiers stay bare — the
+ * consumer resolves @vibeorm/runtime and @vibeorm/schema from its own
+ * node_modules.
+ */
+import type { ComputedManifestEntry } from "@vibeorm/schema";
+import type { BakedExtensions } from "./extension-bake.ts";
+import type { SchemaView } from "./schema-view.ts";
+/** The names index.js / index.d.ts re-export from the enums entry (enum constants + the parser group). */
+export declare function enumEntryExports(params: {
+    view: SchemaView;
+}): readonly string[];
+/**
+ * Emit the lightweight enums.js entry: one frozen constant object per enum
+ * (the SAME declaration index.js re-exports — one source of truth) and the
+ * grouped `enumValidators` boundary parsers. Depends on `@vibeorm/schema`
+ * (for the typed `VibeError`) and nothing else — never on the runtime
+ * client or the application schema module, so a frontend can import it.
+ */
+export declare function emitEnumsJs(params: {
+    view: SchemaView;
+}): string;
+/** Emit the full index.js for a resolved schema view. */
+export declare function emitJs(params: {
+    view: SchemaView;
+    baked?: BakedExtensions;
+    computed?: readonly ComputedManifestEntry[];
+}): string;
+//# sourceMappingURL=emit-js.d.ts.map

package/dist/emit-js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-js.d.ts","sourceRoot":"","sources":["../src/emit-js.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAOnD,0GAA0G;AAC1G,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,SAAS,MAAM,EAAE,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,MAAM,CA0DhE;AAmDD,yDAAyD;AACzD,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,QAAQ,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC7C,GAAG,MAAM,CA0ET"}

package/dist/extension-bake.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Generate-time extension baking (plan D9).
+ *
+ * Each configured extension's client plane contributes runtime glue (JS
+ * expressions over its own module's exports) and d.ts text per opted-in model
+ * / per client. This module collects those contributions once, validates the
+ * one-identifier rule against the exported reserved-name lists, and hands the
+ * emitters plain string blocks — the emitted types stay fully pre-resolved
+ * (no inference), keeping the tsserver budget flat.
+ */
+import type { ExtensionManifestEntry, SchemaIR, VibeExtension } from "@vibeorm/schema";
+/** Everything the js/d.ts emitters need, pre-stringified. */
+export type BakedExtensions = {
+    /** `import { x } from "…";` lines for index.js. */
+    readonly jsImports: readonly string[];
+    /** JS object-literal expressions — one ClientExtensionMount each. */
+    readonly mounts: readonly string[];
+    /** Manifest entries (name-sorted) for the staleness gate. */
+    readonly manifest: readonly ExtensionManifestEntry[];
+    /** `import type { x } from "…";` lines for index.d.ts. */
+    readonly dtsImports: readonly string[];
+    /** Model name → delegate-body lines (already 2-space indented). */
+    readonly delegateDts: ReadonlyMap<string, readonly string[]>;
+    /** Module-scope type declaration blocks. */
+    readonly moduleDts: readonly string[];
+    /** VibeClientInstance-body lines for root `$name` namespaces. */
+    readonly clientDts: readonly string[];
+    /** True when nothing was configured — emitters keep their baseline output. */
+    readonly empty: boolean;
+};
+export declare const EMPTY_BAKED_EXTENSIONS: BakedExtensions;
+/**
+ * Collect every configured extension's baked surface for this schema.
+ *
+ * @throws VibeError VIBE_CONFIG on duplicate names/claims (registry) and on
+ *   contributions that break the one-identifier rule (D9).
+ */
+export declare function bakeExtensions(params: {
+    schema: SchemaIR;
+    extensions: readonly VibeExtension[];
+}): BakedExtensions;
+//# sourceMappingURL=extension-bake.d.ts.map

package/dist/extension-bake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-bake.d.ts","sourceRoot":"","sources":["../src/extension-bake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH,OAAO,KAAK,EAGV,sBAAsB,EACtB,QAAQ,EACR,aAAa,EACd,MAAM,iBAAiB,CAAC;AAIzB,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACrD,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC7D,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eASpC,CAAC;AA+BF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,MAAM,EAAE,QAAQ,CAAC;IACjB,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CACtC,GAAG,eAAe,CAuGlB"}

package/dist/generate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The generator's public entry point: SchemaIR → a consumable client module
+ * directory (index.js + directly-written index.d.ts, the lightweight enums.js +
+ * enums.d.ts entry index re-exports from, and README.md).
+ *
+ * Output is byte-identical for structurally identical IR: models, enums and
+ * extensions are sorted by name, object keys are serialized sorted, and every
+ * emitter iterates deterministically.
+ */
+import type { ComputedConfig, SchemaIR, VibeExtension } from "@vibeorm/schema";
+/** What `generateClient` wrote. */
+export type GenerateResult = {
+    /** Paths of the written files (outDir-joined, in emission order). */
+    files: string[];
+};
+/**
+ * Generate the client module for a schema into `outDir` (created if missing).
+ *
+ * @throws VibeError `VIBE_SCHEMA_INVALID` when the IR fails validation.
+ */
+export declare function generateClient(params: {
+    schema: SchemaIR;
+    outDir: string;
+    /** Configured extension instances — their surfaces bake into the client (D9). */
+    extensions?: readonly VibeExtension[];
+    /** Computed-field config — types bake into the .d.ts, the manifest into index.js. */
+    computed?: ComputedConfig;
+}): Promise<GenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAyB,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMtG,mCAAmC;AACnC,MAAM,MAAM,cAAc,GAAG;IAC3B,qEAAqE;IACrE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAOF;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACtC,qFAAqF;IACrF,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B,GAAG,OAAO,CAAC,cAAc,CAAC,CA2B1B"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @vibeorm/generator — Schema IR → generated client (.js + directly-written .d.ts).
+ *
+ * The generated module embeds the normalized IR as plain data, wires
+ * `VibeClient()` to @vibeorm/runtime's dynamic client, and declares the entire
+ * typed surface in an index.d.ts written as text (decision D3) — the consumer's
+ * tsserver never re-infers ORM internals (constitution rules 1–2).
+ */
+export { generateClient } from "./generate.ts";
+export type { GenerateResult } from "./generate.ts";
+export { bakeExtensions } from "./extension-bake.ts";
+export type { BakedExtensions } from "./extension-bake.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}