@vibeorm/generator 1.1.2 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/generator",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "TypeScript client generator for VibeORM — produces typed delegates, inputs, and Zod schemas from a Prisma schema",
   "license": "MIT",
   "keywords": [
@@ -37,6 +37,6 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@vibeorm/parser": "1.1.2"
+    "@vibeorm/parser": "1.1.3"
   }
 }

package/src/generators/generate-client.ts

@@ -1,4 +1,4 @@
-import type { Schema } from "@vibeorm/parser";
+import type { Model, Schema } from "@vibeorm/parser";
 import { fileHeader, toCamelCase } from "../utils.ts";
 
 /**
@@ -49,7 +49,7 @@ export function generateClient(params: { schema: Schema }): string {
 
   // Generate the VibeClient type (intersection of all delegates)
   const clientProperties = schema.models
-    .map((m) => `  ${toCamelCase({ str: m.name })}: ${m.name}Delegate;`)
+    .map((m) => generateClientProperty({ model: m }))
     .join("\n");
 
   parts.push(`export type VibeClientInstance = {
@@ -78,6 +78,38 @@ ${clientProperties}
   return parts.join("\n");
 }
 
+function generateClientProperty(params: { model: Model }): string {
+  const { model } = params;
+  const modelVar = toCamelCase({ str: model.name });
+
+  return `  /**
+   * Operations for the ${model.name} model.
+   *
+   * @example
+   * const rows = await db.${modelVar}.findMany();
+   *
+   * @example
+   * const filteredRows = await db.${modelVar}.findMany({
+   *   where: {
+   *     // Add ${model.name}-specific filters here
+   *   },
+   * });
+   *
+   * @example
+   * const page = await db.${modelVar}.findMany({
+   *   where: {
+   *     // Add ${model.name}-specific filters here
+   *   },
+   *   orderBy: {
+   *     // e.g. createdAt: "desc"
+   *   },
+   *   take: 20,
+   *   skip: 0,
+   * });
+   */
+  ${modelVar}: ${model.name}Delegate;`;
+}
+
 function generateModelMeta(params: { schema: Schema }): string {
   const { schema } = params;
 

package/src/generators/generate-delegates.ts

@@ -1,4 +1,4 @@
-import type { Model, Schema, ScalarField, EnumField } from "@vibeorm/parser";
+import type { Model, Schema, ScalarField } from "@vibeorm/parser";
 import { fileHeader, toCamelCase } from "../utils.ts";
 
 const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
@@ -47,7 +47,7 @@ export function generateDelegates(params: { schema: Schema }): string {
   const extraImports = hasJsonField ? ", JsonValue" : "";
   parts.push(`import type { ${payloadImports}${extraImports} } from "./models.ts";`);
 
-  parts.push(`import type { GetResult } from "./result.ts";`);
+  parts.push(`import type { GetResult, Exact } from "./result.ts";`);
 
   // Import enums if any models have enum fields
   if (schema.enums.length > 0) {
@@ -69,68 +69,251 @@ export function generateDelegates(params: { schema: Schema }): string {
 function generateModelDelegate(params: { model: Model }): string {
   const { model } = params;
   const p = `$${model.name}Payload`;
+  const modelVar = toCamelCase({ str: model.name });
 
-  return `export type ${model.name}Delegate = {
+  const findManyWhereBlock = buildFindManyWhereBlock({ model });
+  const uniqueWhereBlock = buildUniqueWhereBlock({ model });
+  const createDataBlock = buildObjectBlock({
+    key: "data",
+    lines: getExampleDataLines({ model }),
+  });
+  const updateDataBlock = buildObjectBlock({
+    key: "data",
+    lines: getExampleUpdateLines({ model }),
+  });
+  const createManyDataBlock = buildArrayOfObjectsBlock({
+    key: "data",
+    lines: getExampleDataLines({ model }),
+  });
+  const upsertCreateBlock = buildObjectBlock({
+    key: "create",
+    lines: getExampleDataLines({ model }),
+  });
+  const upsertUpdateBlock = buildObjectBlock({
+    key: "update",
+    lines: getExampleUpdateLines({ model }),
+  });
+  const includeBlock = buildIncludeBlock({ model });
+  const orderByField = getOrderByFieldName({ model });
+
+  return `/**
+ * Delegate API for the ${model.name} model.
+ * Access this via \`db.${modelVar}\`.
+ */
+export type ${model.name}Delegate = {
+  /**
+   * Find zero or more ${model.name} records.
+   *
+   * @example
+   * const rows = await db.${modelVar}.findMany();
+   *
+   * @example
+   * const filteredRows = await db.${modelVar}.findMany({
+${findManyWhereBlock}
+   * });
+   *
+   * @example
+   * const page = await db.${modelVar}.findMany({
+${findManyWhereBlock}${includeBlock}
+   *   orderBy: {
+   *     ${orderByField}: "desc",
+   *   },
+   *   take: 20,
+   *   skip: 0,
+   * });
+   */
   findMany<T extends ${model.name}FindManyArgs>(
-    args?: T,
+    args?: Exact<T, ${model.name}FindManyArgs>,
   ): Promise<GetResult<${p}, T, "findMany">>;
 
+  /**
+   * Find the first ${model.name} record matching a filter.
+   *
+   * @example
+   * const row = await db.${modelVar}.findFirst({
+${findManyWhereBlock}
+   *   orderBy: {
+   *     ${orderByField}: "desc",
+   *   },
+   * });
+   */
   findFirst<T extends ${model.name}FindFirstArgs>(
-    args?: T,
+    args?: Exact<T, ${model.name}FindFirstArgs>,
   ): Promise<GetResult<${p}, T, "findFirst">>;
 
+  /**
+   * Find one ${model.name} record by a unique field.
+   *
+   * @example
+   * const row = await db.${modelVar}.findUnique({
+${uniqueWhereBlock}
+   * });
+   */
   findUnique<T extends ${model.name}FindUniqueArgs>(
-    args: T,
+    args: Exact<T, ${model.name}FindUniqueArgs>,
   ): Promise<GetResult<${p}, T, "findUnique">>;
 
+  /**
+   * Find one ${model.name} record by a unique field, or throw if not found.
+   *
+   * @example
+   * const row = await db.${modelVar}.findUniqueOrThrow({
+${uniqueWhereBlock}
+   * });
+   */
   findUniqueOrThrow<T extends ${model.name}FindUniqueArgs>(
-    args: T,
+    args: Exact<T, ${model.name}FindUniqueArgs>,
   ): Promise<GetResult<${p}, T, "findUniqueOrThrow">>;
 
+  /**
+   * Find the first ${model.name} record matching a filter, or throw if not found.
+   */
   findFirstOrThrow<T extends ${model.name}FindFirstArgs>(
-    args?: T,
+    args?: Exact<T, ${model.name}FindFirstArgs>,
   ): Promise<GetResult<${p}, T, "findFirstOrThrow">>;
 
+  /**
+   * Create one ${model.name} record.
+   *
+   * @example
+   * const row = await db.${modelVar}.create({
+${createDataBlock}
+   * });
+   */
   create<T extends ${model.name}CreateArgs>(
-    args: T,
+    args: Exact<T, ${model.name}CreateArgs>,
   ): Promise<GetResult<${p}, T, "create">>;
 
+  /**
+   * Create multiple ${model.name} records in one query.
+   *
+   * @example
+   * const result = await db.${modelVar}.createMany({
+${createManyDataBlock}
+   *   skipDuplicates: true,
+   * });
+   */
   createMany(
     args: ${model.name}CreateManyArgs,
   ): Promise<{ count: number }>;
 
+  /**
+   * Create multiple ${model.name} records and return selected fields.
+   *
+   * @example
+   * const rows = await db.${modelVar}.createManyAndReturn({
+${createManyDataBlock}
+   *   select: {
+   *     // Choose fields to return
+   *   },
+   * });
+   */
   createManyAndReturn<T extends ${model.name}CreateManyAndReturnArgs>(
-    args: T,
+    args: Exact<T, ${model.name}CreateManyAndReturnArgs>,
   ): Promise<GetResult<${p}, T, "createManyAndReturn">>;
 
+  /**
+   * Update one ${model.name} record.
+   *
+   * @example
+   * const row = await db.${modelVar}.update({
+${uniqueWhereBlock}
+${updateDataBlock}
+   * });
+   */
   update<T extends ${model.name}UpdateArgs>(
-    args: T,
+    args: Exact<T, ${model.name}UpdateArgs>,
   ): Promise<GetResult<${p}, T, "update">>;
 
+  /**
+   * Update one ${model.name} record if it exists, or create it otherwise.
+   *
+   * @example
+   * const row = await db.${modelVar}.upsert({
+${uniqueWhereBlock}
+${upsertCreateBlock}
+${upsertUpdateBlock}
+   * });
+   */
   upsert<T extends ${model.name}UpsertArgs>(
-    args: T,
+    args: Exact<T, ${model.name}UpsertArgs>,
   ): Promise<GetResult<${p}, T, "upsert">>;
 
+  /**
+   * Delete one ${model.name} record by a unique field.
+   *
+   * @example
+   * const row = await db.${modelVar}.delete({
+${uniqueWhereBlock}
+   * });
+   */
   delete<T extends ${model.name}DeleteArgs>(
-    args: T,
+    args: Exact<T, ${model.name}DeleteArgs>,
   ): Promise<GetResult<${p}, T, "delete">>;
 
+  /**
+   * Delete multiple ${model.name} records.
+   *
+   * @example
+   * const result = await db.${modelVar}.deleteMany({
+${findManyWhereBlock}
+   * });
+   */
   deleteMany(
     args?: ${model.name}DeleteManyArgs,
   ): Promise<{ count: number }>;
 
+  /**
+   * Update multiple ${model.name} records.
+   *
+   * @example
+   * const result = await db.${modelVar}.updateMany({
+${findManyWhereBlock}
+${updateDataBlock}
+   * });
+   */
   updateMany(
     args: ${model.name}UpdateManyArgs,
   ): Promise<{ count: number }>;
 
+  /**
+   * Count ${model.name} records.
+   *
+   * @example
+   * const total = await db.${modelVar}.count({
+${findManyWhereBlock}
+   * });
+   */
   count(
     args?: ${model.name}CountArgs,
   ): Promise<number>;
 
+  /**
+   * Run aggregate calculations on ${model.name} records.
+   *
+   * @example
+   * const stats = await db.${modelVar}.aggregate({
+${findManyWhereBlock}
+   *   _count: true,
+   *   _avg: {
+   *     // Choose numeric fields
+   *   },
+   * });
+   */
   aggregate(
     args: ${model.name}AggregateArgs,
   ): Promise<Aggregate${model.name}Result>;
 
+  /**
+   * Group ${model.name} records by scalar fields.
+   *
+   * @example
+   * const grouped = await db.${modelVar}.groupBy({
+   *   by: ["${orderByField}"],
+${findManyWhereBlock}
+   *   _count: true,
+   * });
+   */
   groupBy(
     args: ${model.name}GroupByArgs,
   ): Promise<${model.name}GroupByResult[]>;
@@ -138,6 +321,194 @@ function generateModelDelegate(params: { model: Model }): string {
 `;
 }
 
+function buildObjectBlock(params: { key: string; lines: string[] }): string {
+  const { key, lines } = params;
+  const safeLines = lines.length > 0 ? lines : ["// Add model fields here"];
+  return `   *   ${key}: {
+${safeLines.map((line) => `   *     ${line}`).join("\n")}
+   *   },`;
+}
+
+function buildArrayOfObjectsBlock(params: { key: string; lines: string[] }): string {
+  const { key, lines } = params;
+  const safeLines = lines.length > 0 ? lines : ["// Add model fields here"];
+  return `   *   ${key}: [
+   *     {
+${safeLines.map((line) => `   *       ${line}`).join("\n")}
+   *     },
+   *   ],`;
+}
+
+function buildFindManyWhereBlock(params: { model: Model }): string {
+  return buildObjectBlock({
+    key: "where",
+    lines: getFindManyWhereLines({ model: params.model }),
+  });
+}
+
+function buildUniqueWhereBlock(params: { model: Model }): string {
+  return buildObjectBlock({
+    key: "where",
+    lines: getUniqueWhereLines({ model: params.model }),
+  });
+}
+
+function buildIncludeBlock(params: { model: Model }): string {
+  const relationField = params.model.fields.find((f) => f.kind === "relation");
+  if (!relationField) return "";
+  return `
+   *   include: {
+   *     ${relationField.name}: true,
+   *   },`;
+}
+
+function getFindManyWhereLines(params: { model: Model }): string[] {
+  const field = getPreferredWhereField({ model: params.model });
+  if (!field) {
+    return ["// Add model-specific filters here"];
+  }
+
+  const fieldNameLower = field.name.toLowerCase();
+  if (field.prismaType === "String") {
+    if (fieldNameLower.includes("email")) {
+      return [`${field.name}: { endsWith: "@example.com" },`];
+    }
+    return [`${field.name}: { contains: "sample" },`];
+  }
+
+  if (field.prismaType === "DateTime") {
+    return [`${field.name}: { gte: new Date("2024-01-01T00:00:00.000Z") },`];
+  }
+
+  if (field.prismaType === "Boolean") {
+    return [`${field.name}: true,`];
+  }
+
+  if (field.prismaType === "BigInt") {
+    return [`${field.name}: { gte: 1n },`];
+  }
+
+  if (field.prismaType === "Decimal") {
+    return [`${field.name}: { gte: "1.00" },`];
+  }
+
+  if (field.prismaType === "Int" || field.prismaType === "Float") {
+    return [`${field.name}: { gte: 1 },`];
+  }
+
+  if (field.prismaType === "Json") {
+    return [`${field.name}: { equals: { key: "value" } },`];
+  }
+
+  if (field.prismaType === "Bytes") {
+    return [`${field.name}: { equals: new Uint8Array([1, 2, 3]) },`];
+  }
+
+  return [`${field.name}: { equals: ${getSampleValueForScalarField({ field })} },`];
+}
+
+function getUniqueWhereLines(params: { model: Model }): string[] {
+  const uniqueField = params.model.fields.find(
+    (f): f is ScalarField =>
+      f.kind === "scalar" && !f.isList && (f.isId || f.isUnique)
+  );
+
+  if (!uniqueField) {
+    return ["// Provide a unique field (for example id or email)"];
+  }
+
+  return [`${uniqueField.name}: ${getSampleValueForScalarField({ field: uniqueField })},`];
+}
+
+function getExampleDataLines(params: { model: Model }): string[] {
+  const candidates = params.model.fields.filter(
+    (f): f is ScalarField =>
+      f.kind === "scalar" &&
+      !f.isList &&
+      !f.isId &&
+      !f.isUpdatedAt &&
+      !f.default
+  );
+
+  const selected = candidates.length > 0
+    ? candidates
+    : params.model.fields.filter(
+      (f): f is ScalarField =>
+        f.kind === "scalar" && !f.isList && !f.isId && !f.isUpdatedAt
+    );
+
+  if (selected.length === 0) {
+    return ["// Add model fields here"];
+  }
+
+  return selected.slice(0, 2).map((field) => {
+    return `${field.name}: ${getSampleValueForScalarField({ field })},`;
+  });
+}
+
+function getExampleUpdateLines(params: { model: Model }): string[] {
+  const selected = params.model.fields.filter(
+    (f): f is ScalarField =>
+      f.kind === "scalar" && !f.isList && !f.isId && !f.isUpdatedAt
+  );
+
+  if (selected.length === 0) {
+    return ["// Add fields to update"];
+  }
+
+  return selected.slice(0, 2).map((field) => {
+    return `${field.name}: ${getSampleValueForScalarField({ field })},`;
+  });
+}
+
+function getPreferredWhereField(params: { model: Model }): ScalarField | undefined {
+  const fields = params.model.fields.filter(
+    (f): f is ScalarField => f.kind === "scalar" && !f.isList
+  );
+
+  return fields.find((f) => !f.isId && f.prismaType === "String")
+    ?? fields.find((f) => !f.isId && f.prismaType === "DateTime")
+    ?? fields.find((f) => !f.isId && NUMERIC_PRISMA_TYPES.has(f.prismaType))
+    ?? fields.find((f) => !f.isId && f.prismaType === "Boolean")
+    ?? fields.find((f) => !f.isId)
+    ?? fields[0];
+}
+
+function getOrderByFieldName(params: { model: Model }): string {
+  const scalarFields = params.model.fields.filter(
+    (f): f is ScalarField => f.kind === "scalar" && !f.isList
+  );
+
+  const preferred = scalarFields.find((f) => f.name === "createdAt")
+    ?? scalarFields.find((f) => f.name === "updatedAt")
+    ?? scalarFields.find((f) => f.isId)
+    ?? scalarFields[0];
+
+  return preferred?.name ?? "id";
+}
+
+function getSampleValueForScalarField(params: { field: ScalarField }): string {
+  const { field } = params;
+  const fieldNameLower = field.name.toLowerCase();
+
+  if (field.prismaType === "String") {
+    if (fieldNameLower.includes("email")) return '"user@example.com"';
+    if (fieldNameLower.includes("name")) return '"Example"';
+    if (fieldNameLower.includes("title")) return '"Example title"';
+    return '"sample"';
+  }
+
+  if (field.prismaType === "Boolean") return "true";
+  if (field.prismaType === "Int" || field.prismaType === "Float") return "1";
+  if (field.prismaType === "Decimal") return '"1.00"';
+  if (field.prismaType === "BigInt") return "1n";
+  if (field.prismaType === "DateTime") return 'new Date("2024-01-01T00:00:00.000Z")';
+  if (field.prismaType === "Json") return '{ key: "value" }';
+  if (field.prismaType === "Bytes") return "new Uint8Array([1, 2, 3])";
+
+  return "undefined";
+}
+
 function generateAggregateResultType(params: { model: Model }): string {
   const { model } = params;
 

package/src/generators/generate-result.ts

@@ -36,6 +36,25 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
 /** Flatten intersection types for cleaner hover tooltips */
 type Compute<T> = T extends Function ? T : { [K in keyof T]: T[K] } & unknown;
 
+/**
+ * Enforces strict type safety by recursively rejecting excess properties.
+ *
+ * TypeScript's structural subtyping allows objects to have extra properties
+ * when passed through generics (\`<T extends Args>\`). This utility type
+ * maps any key in A that is NOT in W to \`never\`, causing a compile-time
+ * error when unknown keys (e.g. typos in where/select/include) are used.
+ *
+ * Primitives, arrays, functions, and Dates are passed through unchanged
+ * to preserve literal types for return type narrowing via GetFindResult.
+ */
+export type Exact<A, W> = W extends unknown
+  ? A extends W
+    ? A extends Record<string, unknown>
+      ? { [K in keyof A]: K extends keyof W ? Exact<A[K], W[K]> : never }
+      : A
+    : W
+  : never;
+
 /** Extract scalar fields from a payload (default selection) */
 type DefaultSelection<P extends OperationPayload> = P["scalars"];