@vibeorm/generator 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# @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.
+
+## Installation
+
+```bash
+bun add @vibeorm/generator
+```
+
+## Usage
+
+```ts
+import { parsePrismaSchema } from "@vibeorm/parser";
+import { generate } from "@vibeorm/generator";
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+const schema = parsePrismaSchema({ source: prismaSchemaString });
+const files = generate({ schema });
+
+const outputDir = "./generated/vibeorm";
+mkdirSync(outputDir, { recursive: true });
+
+for (const file of files) {
+  writeFileSync(join(outputDir, file.filename), file.content);
+}
+```
+
+## API
+
+### `generate({ schema })`
+
+Accepts a `Schema` IR (from `@vibeorm/parser`) and returns an array of `GeneratedFile` objects:
+
+```ts
+type GeneratedFile = {
+  filename: string;
+  content: string;
+};
+```
+
+### Generated Files
+
+| 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)

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vibeorm/generator",
+  "version": "1.0.0",
+  "description": "TypeScript client generator for VibeORM — produces typed delegates, inputs, and Zod schemas from a Prisma schema",
+  "license": "MIT",
+  "keywords": [
+    "orm",
+    "codegen",
+    "prisma",
+    "bun",
+    "typescript",
+    "postgresql"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "default": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibeorm/vibeorm.git",
+    "directory": "packages/generator"
+  },
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/generator",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "dependencies": {
+    "@vibeorm/parser": "workspace:*"
+  }
+}

package/src/generate.ts

@@ -0,0 +1,65 @@
+import type { Schema } from "@vibeorm/parser";
+import { generateEnums } from "./generators/generate-enums.ts";
+import { generateModels } from "./generators/generate-models.ts";
+import {
+  generateInputs,
+  generateFilterTypes,
+  generateRelationFilterTypes,
+} from "./generators/generate-inputs.ts";
+import { generateArgs } from "./generators/generate-args.ts";
+import { generateResult } from "./generators/generate-result.ts";
+import { generateDelegates } from "./generators/generate-delegates.ts";
+import { generateClient } from "./generators/generate-client.ts";
+import { generateSchemas } from "./generators/generate-schemas.ts";
+
+export type GeneratedFile = {
+  filename: string;
+  content: string;
+};
+
+/**
+ * Takes a parsed schema IR and produces all the generated TypeScript files.
+ */
+export function generate(params: { schema: Schema }): GeneratedFile[] {
+  const { schema } = params;
+
+  const files: GeneratedFile[] = [
+    {
+      filename: "enums.ts",
+      content: generateEnums({ enums: schema.enums }),
+    },
+    {
+      filename: "models.ts",
+      content: generateModels({ schema }),
+    },
+    {
+      filename: "inputs.ts",
+      content:
+        generateInputs({ schema }) +
+        generateFilterTypes() +
+        generateRelationFilterTypes({ schema }),
+    },
+    {
+      filename: "args.ts",
+      content: generateArgs({ schema }),
+    },
+    {
+      filename: "result.ts",
+      content: generateResult({ schema }),
+    },
+    {
+      filename: "delegates.ts",
+      content: generateDelegates({ schema }),
+    },
+    {
+      filename: "index.ts",
+      content: generateClient({ schema }),
+    },
+    {
+      filename: "schemas.ts",
+      content: generateSchemas({ schema }),
+    },
+  ];
+
+  return files;
+}

package/src/generators/generate-args.ts

@@ -0,0 +1,322 @@
+import type { Model, Schema, RelationField, ScalarField } from "@vibeorm/parser";
+import { fileHeader } from "../utils.ts";
+
+/**
+ * Generates Select, Include, and Args types for each model,
+ * plus the FindManyArgs, FindFirstArgs, FindUniqueArgs, etc.
+ */
+export function generateArgs(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Imports
+  const modelImports = schema.models.map((m) => `${m.name}WhereInput, ${m.name}WhereUniqueInput, ${m.name}OrderByInput, ${m.name}CreateInput, ${m.name}UpdateInput`).join(", ");
+  parts.push(`import type { ${modelImports}, SortOrder, SortOrderWithNulls } from "./inputs.ts";`);
+
+  const payloadImports = schema.models.map((m) => `$${m.name}Payload`).join(", ");
+  parts.push(`import type { ${payloadImports}, OperationPayload } from "./models.ts";\n`);
+
+  // Shared types
+  parts.push(`export type RelationStrategy = "query" | "join";
+
+export type NumberWithAggregatesFilter = {
+  equals?: number;
+  not?: number;
+  lt?: number;
+  lte?: number;
+  gt?: number;
+  gte?: number;
+};
+`);
+
+  // Generate Select + Include + Args for each model
+  for (const model of schema.models) {
+    parts.push(generateSelectType({ model, schema }));
+    parts.push(generateIncludeType({ model, schema }));
+    parts.push(generateOperationArgs({ model }));
+    parts.push(generateAggregateInputTypes({ model }));
+  }
+
+  return parts.join("\n");
+}
+
+// ─── Select Type ──────────────────────────────────────────────────
+
+function generateSelectType(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model, schema } = params;
+
+  const entries: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar" || field.kind === "enum") {
+      entries.push(`  ${field.name}?: boolean;`);
+    } else if (field.kind === "relation") {
+      if (field.isList) {
+        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindManyArgs;`);
+      } else {
+        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindFirstArgs;`);
+      }
+    }
+  }
+
+  // Add _count support for relation counting
+  const countableRelations = model.fields.filter(
+    (f): f is RelationField => f.kind === "relation" && f.isList
+  );
+  if (countableRelations.length > 0) {
+    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
+    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
+  }
+
+  return `export type ${model.name}Select = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── Include Type ─────────────────────────────────────────────────
+
+function generateIncludeType(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+
+  const relationFields = model.fields.filter(
+    (f): f is RelationField => f.kind === "relation"
+  );
+
+  if (relationFields.length === 0) {
+    return `export type ${model.name}Include = Record<string, never>;\n`;
+  }
+
+  const entries = relationFields.map((f) => {
+    if (f.isList) {
+      return `  ${f.name}?: boolean | ${f.relatedModel}FindManyArgs;`;
+    }
+    return `  ${f.name}?: boolean | ${f.relatedModel}FindFirstArgs;`;
+  });
+
+  // Add _count support for relation counting
+  const countableRelations = relationFields.filter((f) => f.isList);
+  if (countableRelations.length > 0) {
+    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
+    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
+  }
+
+  return `export type ${model.name}Include = {
+${entries.join("\n")}
+};
+`;
+}
+
+// ─── Operation Args ───────────────────────────────────────────────
+
+function generateOperationArgs(params: { model: Model }): string {
+  const { model } = params;
+
+  // Omit type — inverse of select (exclude specific fields)
+  const scalarFieldNames = model.fields
+    .filter((f) => f.kind === "scalar" || f.kind === "enum")
+    .map((f) => `  ${f.name}?: boolean;`);
+
+  const omitTypeDef = `export type ${model.name}Omit = {
+${scalarFieldNames.join("\n")}
+};
+`;
+
+  return `${omitTypeDef}
+export type ${model.name}FindManyArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  omit?: ${model.name}Omit;
+  where?: ${model.name}WhereInput;
+  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
+  take?: number;
+  skip?: number;
+  cursor?: ${model.name}WhereUniqueInput;
+  distinct?: (keyof ${model.name}Select)[];
+  relationStrategy?: RelationStrategy;
+};
+
+export type ${model.name}FindFirstArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  omit?: ${model.name}Omit;
+  where?: ${model.name}WhereInput;
+  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
+  take?: number;
+  skip?: number;
+  cursor?: ${model.name}WhereUniqueInput;
+  relationStrategy?: RelationStrategy;
+};
+
+export type ${model.name}FindUniqueArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  omit?: ${model.name}Omit;
+  where: ${model.name}WhereUniqueInput;
+  relationStrategy?: RelationStrategy;
+};
+
+export type ${model.name}CreateArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  omit?: ${model.name}Omit;
+  data: ${model.name}CreateInput;
+  relationStrategy?: RelationStrategy;
+};
+
+export type ${model.name}UpdateArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  omit?: ${model.name}Omit;
+  where: ${model.name}WhereUniqueInput;
+  data: ${model.name}UpdateInput;
+  relationStrategy?: RelationStrategy;
+};
+
+export type ${model.name}UpsertArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  where: ${model.name}WhereUniqueInput;
+  create: ${model.name}CreateInput;
+  update: ${model.name}UpdateInput;
+};
+
+export type ${model.name}DeleteArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  where: ${model.name}WhereUniqueInput;
+};
+
+export type ${model.name}DeleteManyArgs = {
+  where?: ${model.name}WhereInput;
+};
+
+export type ${model.name}CountArgs = {
+  where?: ${model.name}WhereInput;
+  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
+  take?: number;
+  skip?: number;
+  cursor?: ${model.name}WhereUniqueInput;
+};
+
+export type ${model.name}CreateManyArgs = {
+  data: ${model.name}CreateInput | ${model.name}CreateInput[];
+  skipDuplicates?: boolean;
+};
+
+export type ${model.name}CreateManyAndReturnArgs = {
+  select?: ${model.name}Select | null;
+  include?: ${model.name}Include | null;
+  data: ${model.name}CreateInput | ${model.name}CreateInput[];
+  skipDuplicates?: boolean;
+};
+
+export type ${model.name}UpdateManyArgs = {
+  where?: ${model.name}WhereInput;
+  data: ${model.name}UpdateInput;
+};
+
+export type ${model.name}AggregateArgs = {
+  where?: ${model.name}WhereInput;
+  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
+  take?: number;
+  skip?: number;
+  cursor?: ${model.name}WhereUniqueInput;
+  _count?: true | ${model.name}CountAggregateInputType;
+  _avg?: ${model.name}AvgAggregateInputType;
+  _sum?: ${model.name}SumAggregateInputType;
+  _min?: ${model.name}MinAggregateInputType;
+  _max?: ${model.name}MaxAggregateInputType;
+};
+
+export type ${model.name}GroupByArgs = {
+  by: (keyof ${model.name}Select)[];
+  where?: ${model.name}WhereInput;
+  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
+  having?: ${model.name}ScalarWhereWithAggregatesInput;
+  take?: number;
+  skip?: number;
+  _count?: true | ${model.name}CountAggregateInputType;
+  _avg?: ${model.name}AvgAggregateInputType;
+  _sum?: ${model.name}SumAggregateInputType;
+  _min?: ${model.name}MinAggregateInputType;
+  _max?: ${model.name}MaxAggregateInputType;
+};
+`;
+}
+
+// ─── Aggregate Input Types ────────────────────────────────────────
+
+const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
+
+function generateAggregateInputTypes(params: { model: Model }): string {
+  const { model } = params;
+
+  const scalarFields = model.fields.filter(
+    (f): f is ScalarField => f.kind === "scalar"
+  );
+
+  const numericFields = scalarFields.filter(
+    (f) => NUMERIC_PRISMA_TYPES.has(f.prismaType)
+  );
+
+  // CountAggregateInputType — all scalar fields + _all
+  const countEntries = [
+    `  _all?: boolean;`,
+    ...scalarFields.map((f) => `  ${f.name}?: boolean;`),
+  ];
+
+  // AvgAggregateInputType — only numeric fields
+  const avgEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
+
+  // SumAggregateInputType — only numeric fields
+  const sumEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
+
+  // MinAggregateInputType — all scalar fields
+  const minEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
+
+  // MaxAggregateInputType — all scalar fields
+  const maxEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
+
+  // ScalarWhereWithAggregatesInput — for HAVING clause in groupBy
+  const havingEntries = scalarFields.map((f) => {
+    return `  ${f.name}?: {
+    _count?: NumberWithAggregatesFilter;
+    _avg?: NumberWithAggregatesFilter;
+    _sum?: NumberWithAggregatesFilter;
+    _min?: NumberWithAggregatesFilter;
+    _max?: NumberWithAggregatesFilter;
+  };`;
+  });
+
+  return `export type ${model.name}CountAggregateInputType = {
+${countEntries.join("\n")}
+};
+
+export type ${model.name}AvgAggregateInputType = {
+${avgEntries.length > 0 ? avgEntries.join("\n") : "  [key: string]: never;"}
+};
+
+export type ${model.name}SumAggregateInputType = {
+${sumEntries.length > 0 ? sumEntries.join("\n") : "  [key: string]: never;"}
+};
+
+export type ${model.name}MinAggregateInputType = {
+${minEntries.join("\n")}
+};
+
+export type ${model.name}MaxAggregateInputType = {
+${maxEntries.join("\n")}
+};
+
+export type ${model.name}ScalarWhereWithAggregatesInput = {
+${havingEntries.join("\n")}
+};
+`;
+}

package/src/generators/generate-client.ts

@@ -0,0 +1,186 @@
+import type { Schema } from "@vibeorm/parser";
+import { fileHeader, toCamelCase } from "../utils.ts";
+
+/**
+ * Generates the main index.ts file that:
+ * - Re-exports all types
+ * - Creates the VibeClient class that wires delegates to the runtime
+ */
+export function generateClient(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Re-exports
+  parts.push(`export * from "./enums.ts";`);
+  parts.push(`export * from "./models.ts";`);
+  parts.push(`export * from "./inputs.ts";`);
+  parts.push(`export * from "./args.ts";`);
+  parts.push(`export * from "./result.ts";`);
+  parts.push(`export * from "./delegates.ts";`);
+  parts.push(`export * from "./schemas.ts";`);
+  parts.push(``);
+
+  // Import delegate types
+  const delegateImports = schema.models
+    .map((m) => `${m.name}Delegate`)
+    .join(", ");
+  parts.push(`import type { ${delegateImports} } from "./delegates.ts";`);
+
+  // Import runtime
+  parts.push(`import { createClient } from "@vibeorm/runtime";`);
+  parts.push(`import type { VibeClientOptions } from "@vibeorm/runtime";`);
+  parts.push(``);
+
+  // Import schemas for validation wiring
+  const schemaImports = schema.models.flatMap((m) => [
+    `${m.name}Schema`,
+    `${m.name}CreateInputSchema`,
+    `${m.name}UpdateInputSchema`,
+    `${m.name}WhereInputSchema`,
+  ]);
+  parts.push(`import { ${schemaImports.join(", ")} } from "./schemas.ts";`);
+  parts.push(``);
+
+  // Generate the model metadata object that the runtime needs
+  parts.push(generateModelMeta({ schema }));
+
+  // Generate the schemas map for validation wiring
+  parts.push(generateSchemasMap({ schema }));
+
+  // Generate the VibeClient type (intersection of all delegates)
+  const clientProperties = schema.models
+    .map((m) => `  ${toCamelCase({ str: m.name })}: ${m.name}Delegate;`)
+    .join("\n");
+
+  parts.push(`export type VibeClientInstance = {
+${clientProperties}
+  $transaction<T>(fn: (tx: VibeClientInstance) => Promise<T>): Promise<T>;
+  $transaction(promises: Promise<unknown>[]): Promise<unknown[]>;
+  $queryRaw<T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
+  $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
+  $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T[]>;
+  $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
+  $connect(): Promise<void>;
+  $disconnect(): Promise<void>;
+};
+`);
+
+  // Generate the VibeClient constructor function
+  parts.push(`export function VibeClient(options: VibeClientOptions): VibeClientInstance {
+  return createClient({
+    options,
+    modelMeta: MODEL_META,
+    schemas: options.validate ? SCHEMAS : undefined,
+  }) as unknown as VibeClientInstance;
+}
+`);
+
+  return parts.join("\n");
+}
+
+function generateModelMeta(params: { schema: Schema }): string {
+  const { schema } = params;
+
+  const modelEntries = schema.models.map((model) => {
+    const scalarFields = model.fields
+      .filter((f) => f.kind === "scalar" || f.kind === "enum")
+      .map((f) => {
+        const dbName = f.kind === "scalar" ? f.dbName : f.dbName;
+        const isUpdatedAt = f.kind === "scalar" && f.isUpdatedAt;
+        const extras: string[] = [];
+        if (isUpdatedAt) extras.push(`isUpdatedAt: true`);
+        if (f.kind === "scalar") extras.push(`type: "${f.prismaType}"`);
+
+        // Emit default kind for application-level generation (uuid, cuid, nanoid, ulid)
+        if (f.default) {
+          const appLevelDefaults = new Set(["uuid", "cuid", "nanoid", "ulid"]);
+          if (appLevelDefaults.has(f.default.kind)) {
+            extras.push(`hasDefault: "${f.default.kind}"`);
+          } else if (f.default.kind !== "dbgenerated") {
+            // autoincrement, now, literal — DB handles these, but runtime should know
+            extras.push(`hasDefault: true`);
+          }
+        }
+
+        // Extract @vibeorm.idPrefix from documentation comment
+        const doc = (f.kind === "scalar" || f.kind === "enum") ? f.documentation : undefined;
+        if (doc) {
+          const prefixMatch = doc.match(/@vibeorm\.idPrefix\(["']([^"']+)["']\)/);
+          if (prefixMatch) {
+            extras.push(`idPrefix: "${prefixMatch[1]}"`);
+          }
+        }
+
+        const extraStr = extras.length > 0 ? `, ${extras.join(", ")}` : "";
+        return `      { name: "${f.name}", dbName: "${dbName}", kind: "${f.kind}" as const${extraStr} }`;
+      });
+
+    const relationFields = model.fields
+      .filter((f) => f.kind === "relation")
+      .map((f) => {
+        if (f.kind !== "relation") return "";
+        const isM2M = f.relation.type === "manyToMany";
+        let joinTableLine = "";
+        if (isM2M) {
+          const sorted = [model.name, f.relatedModel].sort();
+          const jtName = `_${sorted[0]}To${sorted[1]}`;
+          joinTableLine = `\n        joinTable: "${jtName}",`;
+        }
+        const relationNameLine = f.relation.name
+          ? `\n        relationName: "${f.relation.name}",`
+          : "";
+        return `      {
+        name: "${f.name}",
+        kind: "relation" as const,
+        relatedModel: "${f.relatedModel}",
+        type: "${f.relation.type}" as const,
+        isList: ${f.isList},
+        isForeignKey: ${f.relation.isForeignKey},
+        fields: ${JSON.stringify(f.relation.fields)},
+        references: ${JSON.stringify(f.relation.references)},${relationNameLine}${joinTableLine}
+      }`;
+      });
+
+    const pkFields = JSON.stringify(model.primaryKey.fields);
+    const uniqueFields = model.fields
+      .filter((f) => (f.kind === "scalar" || f.kind === "enum") && f.isUnique)
+      .map((f) => `"${f.name}"`);
+
+    return `  ${toCamelCase({ str: model.name })}: {
+    name: "${model.name}",
+    dbName: "${model.dbName}",
+    primaryKey: ${pkFields},
+    uniqueFields: [${uniqueFields.join(", ")}],
+    scalarFields: [
+${scalarFields.join(",\n")}
+    ],
+    relationFields: [
+${relationFields.join(",\n")}
+    ],
+  }`;
+  });
+
+  return `const MODEL_META = {
+${modelEntries.join(",\n")}
+} as const;
+`;
+}
+
+function generateSchemasMap(params: { schema: Schema }): string {
+  const { schema } = params;
+
+  const entries = schema.models.map((model) => {
+    const key = toCamelCase({ str: model.name });
+    return `  ${key}: {
+    model: ${model.name}Schema,
+    createInput: ${model.name}CreateInputSchema,
+    updateInput: ${model.name}UpdateInputSchema,
+    whereInput: ${model.name}WhereInputSchema,
+  }`;
+  });
+
+  return `const SCHEMAS = {
+${entries.join(",\n")}
+};
+`;
+}