@vibeorm/generator 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/generator",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "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.3"
+    "@vibeorm/parser": "1.1.4"
   }
 }

package/src/generate.ts

@@ -11,6 +11,7 @@ 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";
+import { generateViewTypes } from "./generators/generate-view-types.ts";
 
 export type GeneratedFile = {
   filename: string;
@@ -59,6 +60,10 @@ export function generate(params: { schema: Schema }): GeneratedFile[] {
       filename: "schemas.ts",
       content: generateSchemas({ schema }),
     },
+    {
+      filename: "view-types.ts",
+      content: generateViewTypes({ schema }),
+    },
   ];
 
   return files;

package/src/generators/generate-client.ts

@@ -18,6 +18,7 @@ export function generateClient(params: { schema: Schema }): string {
   parts.push(`export * from "./result.ts";`);
   parts.push(`export * from "./delegates.ts";`);
   parts.push(`export * from "./schemas.ts";`);
+  parts.push(`export * from "./view-types.ts";`);
   parts.push(``);
 
   // Import delegate types
@@ -26,6 +27,9 @@ export function generateClient(params: { schema: Schema }): string {
     .join(", ");
   parts.push(`import type { ${delegateImports} } from "./delegates.ts";`);
 
+  // Import view types
+  parts.push(`import type { ViewDefinitionInput, ViewClient } from "./view-types.ts";`);
+
   // Import runtime
   parts.push(`import { createClient } from "@vibeorm/runtime";`);
   parts.push(`import type { VibeClientOptions, TransactionOptions } from "@vibeorm/runtime";`);
@@ -62,6 +66,35 @@ ${clientProperties}
   $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
   $connect(): Promise<void>;
   $disconnect(): Promise<void>;
+
+  /**
+   * Create a read-only view that restricts which fields are returned per model.
+   *
+   * @example
+   * const publicApi = db.defineView({
+   *   name: "public-api",
+   *   definition: {
+   *     user: { id: true, name: true, createdAt: true },
+   *     post: { id: true, title: true },
+   *   },
+   * });
+   *
+   * // Only returns { id, name, createdAt }
+   * const users = await publicApi.user.findMany();
+   *
+   * // Reveal extra fields (accessible but excluded from JSON.stringify)
+   * const user = await publicApi.user.findUniqueOrThrow({
+   *   where: { id: 1 },
+   *   reveal: { email: true },
+   * });
+   * user.email;           // accessible
+   * JSON.stringify(user);  // { id, name, createdAt } — email excluded
+   * user.$unsafe();        // { id, name, createdAt, email } — escape hatch
+   */
+  defineView<D extends ViewDefinitionInput>(params: {
+    name: string;
+    definition: D;
+  }): ViewClient<D>;
 };
 `);
 

package/src/generators/generate-delegates.ts

@@ -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) {
@@ -123,7 +123,7 @@ ${findManyWhereBlock}${includeBlock}
    * });
    */
   findMany<T extends ${model.name}FindManyArgs>(
-    args?: T,
+    args?: Exact<T, ${model.name}FindManyArgs>,
   ): Promise<GetResult<${p}, T, "findMany">>;
 
   /**
@@ -138,7 +138,7 @@ ${findManyWhereBlock}
    * });
    */
   findFirst<T extends ${model.name}FindFirstArgs>(
-    args?: T,
+    args?: Exact<T, ${model.name}FindFirstArgs>,
   ): Promise<GetResult<${p}, T, "findFirst">>;
 
   /**
@@ -150,7 +150,7 @@ ${uniqueWhereBlock}
    * });
    */
   findUnique<T extends ${model.name}FindUniqueArgs>(
-    args: T,
+    args: Exact<T, ${model.name}FindUniqueArgs>,
   ): Promise<GetResult<${p}, T, "findUnique">>;
 
   /**
@@ -162,14 +162,14 @@ ${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">>;
 
   /**
@@ -181,7 +181,7 @@ ${createDataBlock}
    * });
    */
   create<T extends ${model.name}CreateArgs>(
-    args: T,
+    args: Exact<T, ${model.name}CreateArgs>,
   ): Promise<GetResult<${p}, T, "create">>;
 
   /**
@@ -209,7 +209,7 @@ ${createManyDataBlock}
    * });
    */
   createManyAndReturn<T extends ${model.name}CreateManyAndReturnArgs>(
-    args: T,
+    args: Exact<T, ${model.name}CreateManyAndReturnArgs>,
   ): Promise<GetResult<${p}, T, "createManyAndReturn">>;
 
   /**
@@ -222,7 +222,7 @@ ${updateDataBlock}
    * });
    */
   update<T extends ${model.name}UpdateArgs>(
-    args: T,
+    args: Exact<T, ${model.name}UpdateArgs>,
   ): Promise<GetResult<${p}, T, "update">>;
 
   /**
@@ -236,7 +236,7 @@ ${upsertUpdateBlock}
    * });
    */
   upsert<T extends ${model.name}UpsertArgs>(
-    args: T,
+    args: Exact<T, ${model.name}UpsertArgs>,
   ): Promise<GetResult<${p}, T, "upsert">>;
 
   /**
@@ -248,7 +248,7 @@ ${uniqueWhereBlock}
    * });
    */
   delete<T extends ${model.name}DeleteArgs>(
-    args: T,
+    args: Exact<T, ${model.name}DeleteArgs>,
   ): Promise<GetResult<${p}, T, "delete">>;
 
   /**

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"];
 

package/src/generators/generate-view-types.ts

@@ -0,0 +1,319 @@
+import type { Model, Schema, RelationField } from "@vibeorm/parser";
+import { fileHeader, toCamelCase } from "../utils.ts";
+
+/**
+ * Generates view-related types:
+ *
+ * - ViewDefinitionInput: restricts what fields can go into defineView()
+ * - ViewClient<D>: the typed return type of defineView()
+ * - Per-model ViewDelegate types with only read operations
+ * - Per-model ViewFindManyArgs etc. with reveal support
+ * - ViewResultWrapper type for toJSON/$unsafe
+ */
+export function generateViewTypes(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // ─── Imports ──────────────────────────────────────────────────────
+
+  // Import model types
+  const modelImports = schema.models.map((m) => m.name).join(", ");
+  parts.push(`import type { ${modelImports} } from "./models.ts";`);
+
+  // Import payload types
+  const payloadImports = schema.models.map((m) => `$${m.name}Payload`).join(", ");
+  parts.push(`import type { ${payloadImports}, OperationPayload } from "./models.ts";`);
+
+  // Import args types (for where, orderBy, whereUnique)
+  const argsImports = schema.models.flatMap((m) => [
+    `${m.name}CountArgs`,
+    `${m.name}AggregateArgs`,
+    `${m.name}GroupByArgs`,
+  ]).join(", ");
+  parts.push(`import type { ${argsImports} } from "./args.ts";`);
+
+  // Import input types
+  const inputImports = schema.models.flatMap((m) => [
+    `${m.name}WhereInput`,
+    `${m.name}WhereUniqueInput`,
+    `${m.name}OrderByInput`,
+  ]).join(", ");
+  parts.push(`import type { ${inputImports} } from "./inputs.ts";`);
+
+  // Import delegate types for aggregate/groupBy result types
+  const delegateResultImports = schema.models.flatMap((m) => {
+    const hasRelations = m.fields.some((f) => f.kind === "relation");
+    return [
+      `Aggregate${m.name}Result`,
+      `${m.name}GroupByResult`,
+    ];
+  }).join(", ");
+  parts.push(`import type { ${delegateResultImports} } from "./delegates.ts";`);
+
+  // Import Exact from result
+  parts.push(`import type { Exact } from "./result.ts";`);
+
+  // Import ViewResult from runtime
+  parts.push(`import { ViewResult } from "@vibeorm/runtime";`);
+
+  parts.push(``);
+
+  // ─── ViewResultWrapper ────────────────────────────────────────────
+
+  parts.push(`
+// ─── View Result Wrapper Types ──────────────────────────────────
+
+/**
+ * Wraps a query result with view serialization safety.
+ * - Direct property access for all fields (view + revealed)
+ * - toJSON() excludes revealed fields (called by JSON.stringify)
+ * - $unsafe() returns a plain object with all fields
+ */
+export type ViewResultWrapper<T> = T & {
+  toJSON(): Partial<T>;
+  $unsafe(): T;
+};
+`);
+
+  // ─── ViewDefinitionInput ──────────────────────────────────────────
+
+  parts.push(`// ─── View Definition ──────────────────────────────────────────────`);
+  parts.push(``);
+  parts.push(`/**`);
+  parts.push(` * Restricts what can be passed to defineView({ definition }).`);
+  parts.push(` * Maps model camelCase keys to boolean field maps.`);
+  parts.push(` */`);
+
+  const defEntries = schema.models.map((m) => {
+    const modelVar = toCamelCase({ str: m.name });
+    const scalarFields = m.fields
+      .filter((f) => f.kind === "scalar" || f.kind === "enum")
+      .map((f) => `"${f.name}"`)
+      .join(" | ");
+    return `  ${modelVar}?: Partial<Record<${scalarFields}, true>>;`;
+  });
+
+  parts.push(`export type ViewDefinitionInput = {`);
+  parts.push(defEntries.join("\n"));
+  parts.push(`};`);
+  parts.push(``);
+
+  // ─── Per-model scalar field keys type ─────────────────────────────
+
+  for (const model of schema.models) {
+    const scalarFieldNames = model.fields
+      .filter((f) => f.kind === "scalar" || f.kind === "enum")
+      .map((f) => `"${f.name}"`)
+      .join(" | ");
+    parts.push(`type ${model.name}ScalarFieldKeys = ${scalarFieldNames};`);
+  }
+  parts.push(``);
+
+  // ─── Per-model ViewFindArgs ───────────────────────────────────────
+
+  for (const model of schema.models) {
+    parts.push(generateViewFindArgs({ model, schema }));
+  }
+
+  // ─── Per-model ViewDelegate ───────────────────────────────────────
+
+  for (const model of schema.models) {
+    parts.push(generateViewDelegate({ model, schema }));
+  }
+
+  // ─── ViewClient mapped type ───────────────────────────────────────
+
+  parts.push(generateViewClientType({ schema }));
+
+  return parts.join("\n");
+}
+
+// ─── ViewFindArgs (per model) ─────────────────────────────────────
+
+function generateViewFindArgs(params: { model: Model; schema: Schema }): string {
+  const { model, schema } = params;
+  const n = model.name;
+
+  const relationFields = model.fields.filter(
+    (f): f is RelationField => f.kind === "relation"
+  );
+  const hasRelations = relationFields.length > 0;
+
+  // Build the include type for views (maps relation names to view-aware nested args)
+  let viewIncludeType = "Record<string, never>";
+  if (hasRelations) {
+    const includeEntries = relationFields.map((f) => {
+      const relModelVar = toCamelCase({ str: f.relatedModel });
+      if (f.isList) {
+        return `    ${f.name}?: boolean | ${f.relatedModel}ViewFindManyArgs<VD extends { ${relModelVar}: infer RF } ? RF extends Record<string, true> ? RF : Record<string, true> : Record<string, true>, VD>;`;
+      }
+      return `    ${f.name}?: boolean | ${f.relatedModel}ViewFindFirstArgs<VD extends { ${relModelVar}: infer RF } ? RF extends Record<string, true> ? RF : Record<string, true> : Record<string, true>, VD>;`;
+    });
+    viewIncludeType = `{\n${includeEntries.join("\n")}\n  }`;
+  }
+
+  return `
+// ─── ${n} View Args ─────────────────────────────────────────
+
+export type ${n}ViewFindManyArgs<
+  VF extends Record<string, true> = Record<string, true>,
+  VD extends ViewDefinitionInput = ViewDefinitionInput,
+> = {
+  select?: Partial<Record<keyof VF & ${n}ScalarFieldKeys, boolean>>;
+  reveal?: Partial<Record<Exclude<${n}ScalarFieldKeys, keyof VF>, boolean>>;
+  include?: ${hasRelations ? viewIncludeType : "Record<string, never>"};
+  where?: ${n}WhereInput;
+  orderBy?: ${n}OrderByInput | ${n}OrderByInput[];
+  take?: number;
+  skip?: number;
+  cursor?: ${n}WhereUniqueInput;
+  distinct?: (keyof ${n})[];
+  relationStrategy?: "query" | "join";
+};
+
+export type ${n}ViewFindFirstArgs<
+  VF extends Record<string, true> = Record<string, true>,
+  VD extends ViewDefinitionInput = ViewDefinitionInput,
+> = ${n}ViewFindManyArgs<VF, VD>;
+
+export type ${n}ViewFindUniqueArgs<
+  VF extends Record<string, true> = Record<string, true>,
+  VD extends ViewDefinitionInput = ViewDefinitionInput,
+> = {
+  select?: Partial<Record<keyof VF & ${n}ScalarFieldKeys, boolean>>;
+  reveal?: Partial<Record<Exclude<${n}ScalarFieldKeys, keyof VF>, boolean>>;
+  include?: ${hasRelations ? viewIncludeType : "Record<string, never>"};
+  where: ${n}WhereUniqueInput;
+  relationStrategy?: "query" | "join";
+};
+`;
+}
+
+// ─── ViewDelegate (per model) ─────────────────────────────────────
+
+function generateViewDelegate(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+  const n = model.name;
+
+  return `
+// ─── ${n} View Delegate ─────────────────────────────────────
+
+export type ${n}ViewDelegate<
+  VF extends Record<string, true> = Record<string, true>,
+  VD extends ViewDefinitionInput = ViewDefinitionInput,
+> = {
+  /**
+   * Find zero or more ${n} records, restricted to view fields.
+   */
+  findMany<T extends ${n}ViewFindManyArgs<VF, VD>>(
+    args?: Exact<T, ${n}ViewFindManyArgs<VF, VD>>
+  ): Promise<ViewResultWrapper<
+    ViewSelectResult<${n}, VF, T>
+  >[]>;
+
+  /**
+   * Find the first ${n} matching the filter, or null.
+   */
+  findFirst<T extends ${n}ViewFindFirstArgs<VF, VD>>(
+    args?: Exact<T, ${n}ViewFindFirstArgs<VF, VD>>
+  ): Promise<ViewResultWrapper<
+    ViewSelectResult<${n}, VF, T>
+  > | null>;
+
+  /**
+   * Find a unique ${n} by its primary key or unique field, or null.
+   */
+  findUnique<T extends ${n}ViewFindUniqueArgs<VF, VD>>(
+    args: Exact<T, ${n}ViewFindUniqueArgs<VF, VD>>
+  ): Promise<ViewResultWrapper<
+    ViewSelectResult<${n}, VF, T>
+  > | null>;
+
+  /**
+   * Find a unique ${n} or throw if not found.
+   */
+  findUniqueOrThrow<T extends ${n}ViewFindUniqueArgs<VF, VD>>(
+    args: Exact<T, ${n}ViewFindUniqueArgs<VF, VD>>
+  ): Promise<ViewResultWrapper<
+    ViewSelectResult<${n}, VF, T>
+  >>;
+
+  /**
+   * Find the first ${n} matching the filter, or throw.
+   */
+  findFirstOrThrow<T extends ${n}ViewFindFirstArgs<VF, VD>>(
+    args?: Exact<T, ${n}ViewFindFirstArgs<VF, VD>>
+  ): Promise<ViewResultWrapper<
+    ViewSelectResult<${n}, VF, T>
+  >>;
+
+  /**
+   * Count matching ${n} records.
+   */
+  count(args?: ${n}CountArgs): Promise<number>;
+
+  /**
+   * Aggregate ${n} records.
+   */
+  aggregate(args: ${n}AggregateArgs): Promise<Aggregate${n}Result>;
+
+  /**
+   * Group ${n} records.
+   */
+  groupBy(args: ${n}GroupByArgs): Promise<${n}GroupByResult[]>;
+};
+`;
+}
+
+// ─── ViewClient mapped type ───────────────────────────────────────
+
+function generateViewClientType(params: { schema: Schema }): string {
+  const { schema } = params;
+
+  const branches = schema.models.map((m) => {
+    const modelVar = toCamelCase({ str: m.name });
+    return `    K extends "${modelVar}"
+      ? ${m.name}ViewDelegate<
+          NonNullable<D["${modelVar}"]> extends Record<string, true> ? NonNullable<D["${modelVar}"]> : Record<string, true>,
+          D
+        >
+      :`;
+  });
+
+  return `
+// ─── View Result Type Computation ───────────────────────────────
+
+/**
+ * Computes the result type for a view query.
+ * Picks view fields from the model, adds revealed fields, handles select narrowing.
+ */
+type ViewSelectResult<
+  Model,
+  VF extends Record<string, true>,
+  Args,
+> =
+  // If user provided select, narrow to selected view fields
+  Args extends { select: infer S extends Record<string, boolean> }
+    ? Pick<Model, Extract<keyof S & keyof Model, { [K in keyof S]: S[K] extends true ? K : never }[keyof S]>>
+      & (Args extends { reveal: infer R extends Record<string, boolean> }
+        ? Pick<Model, Extract<keyof R & keyof Model, { [K in keyof R]: R[K] extends true ? K : never }[keyof R]>>
+        : unknown)
+    : // Default: pick view fields
+      Pick<Model, keyof VF & keyof Model>
+      & (Args extends { reveal: infer R extends Record<string, boolean> }
+        ? Pick<Model, Extract<keyof R & keyof Model, { [K in keyof R]: R[K] extends true ? K : never }[keyof R]>>
+        : unknown);
+
+// ─── View Client ────────────────────────────────────────────────
+
+/**
+ * A read-only scoped client created by \`defineView()\`.
+ * Only exposes models defined in the view, with field restrictions.
+ */
+export type ViewClient<D extends ViewDefinitionInput> = {
+  [K in keyof D & string]:
+${branches.join("\n")}
+    never;
+};
+`;
+}