@vibeorm/generator 1.1.4 → 1.1.6

package/package.json

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

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-view-types.ts

@@ -0,0 +1,446 @@
+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;
+};
+
+/** Flatten intersection types for cleaner hover tooltips and type resolution */
+type Compute<T> = T extends Function ? T : { [K in keyof T]: T[K] } & unknown;
+`);
+
+  // ─── 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 ViewIncludeResult ──────────────────────────────────
+
+  for (const model of schema.models) {
+    parts.push(generateViewIncludeResult({ model, schema }));
+  }
+
+  // ─── Per-model GetViewResult ────────────────────────────────────
+
+  for (const model of schema.models) {
+    parts.push(generateGetViewResult({ model, schema }));
+  }
+
+  // ─── 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");
+}
+
+// ─── ViewIncludeResult (per model) ────────────────────────────────
+
+/**
+ * Generates a mapped type that computes the result types for included
+ * relations on a view query. For each relation field:
+ *
+ * - If the related model is in VD: result is ViewResultWrapper<Pick<Model, viewFields>>
+ * - If the related model is NOT in VD: result is the full model type
+ * - Array relations get [], nullable singles get | null
+ */
+function generateViewIncludeResult(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+  const n = model.name;
+
+  const relationFields = model.fields.filter(
+    (f): f is RelationField => f.kind === "relation"
+  );
+
+  if (relationFields.length === 0) {
+    // No relations — include result is always empty
+    return `
+// ─── ${n} View Include Result ────────────────────────────────
+
+type ${n}ViewIncludeResult<
+  I extends Record<string, unknown>,
+  VD extends ViewDefinitionInput,
+> = {};
+`;
+  }
+
+  // Build nested conditional branches: K extends "relName" ? ... : K extends ... : never
+  const branches = relationFields.map((f) => {
+    const relModelVar = toCamelCase({ str: f.relatedModel });
+    const relModel = f.relatedModel;
+
+    // Type when the related model IS in the view definition
+    const viewRestricted = `ViewResultWrapper<Pick<${relModel}, keyof RF & keyof ${relModel}>>`;
+    // Type when the related model is NOT in the view definition
+    const fullType = relModel;
+
+    let inViewType: string;
+    let notInViewType: string;
+
+    if (f.isList) {
+      inViewType = `${viewRestricted}[]`;
+      notInViewType = `${fullType}[]`;
+    } else if (!f.isRequired) {
+      inViewType = `${viewRestricted} | null`;
+      notInViewType = `${fullType} | null`;
+    } else {
+      inViewType = viewRestricted;
+      notInViewType = fullType;
+    }
+
+    return `    K extends "${f.name}"
+      ? (VD extends { ${relModelVar}: infer RF extends Record<string, true> }
+        ? ${inViewType}
+        : ${notInViewType})`;
+  });
+
+  return `
+// ─── ${n} View Include Result ────────────────────────────────
+
+type ${n}ViewIncludeResult<
+  I extends Record<string, unknown>,
+  VD extends ViewDefinitionInput,
+> = {
+  [K in keyof I as I[K] extends false | undefined | null ? never : K]:
+${branches.join("\n    : ")}
+    : never;
+};
+`;
+}
+
+// ─── GetViewResult (per model) ────────────────────────────────────
+
+/**
+ * Generates a top-level conditional type that resolves the complete result
+ * type for a view query, including both scalar fields and included relations.
+ *
+ * The conditional is at the outermost position (matching how GetFindResult
+ * works in the regular client) so TypeScript evaluates it eagerly at call
+ * sites instead of deferring it inside ViewResultWrapper's type parameter.
+ */
+function generateGetViewResult(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+  const n = model.name;
+  const hasRelations = model.fields.some((f) => f.kind === "relation");
+
+  if (!hasRelations) return "";
+
+  return `
+// ─── ${n} Get View Result ───────────────────────────────────
+
+type ${n}GetViewResult<
+  VF extends Record<string, true>,
+  T,
+  VD extends ViewDefinitionInput,
+> =
+  T extends { include: infer I extends Record<string, unknown> }
+    ? ViewResultWrapper<Compute<
+        ViewSelectResult<${n}, VF, T>
+        & ${n}ViewIncludeResult<I, VD>
+      >>
+    : ViewResultWrapper<ViewSelectResult<${n}, VF, T>>;
+`;
+}
+
+// ─── 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;
+
+  const hasRelations = model.fields.some((f) => f.kind === "relation");
+
+  // Helper: builds the full result type including the include intersection.
+  // Models with relations use a dedicated GetViewResult type that places the
+  // conditional at the outermost position (matching GetFindResult in the regular
+  // client) so TypeScript evaluates it eagerly instead of deferring it inside
+  // ViewResultWrapper's type parameter.
+  const resultType = (argsType: string) => {
+    if (!hasRelations) {
+      return `ViewResultWrapper<ViewSelectResult<${n}, VF, ${argsType}>>`;
+    }
+    return `${n}GetViewResult<VF, ${argsType}, VD>`;
+  };
+
+  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<${resultType("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<${resultType("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<${resultType("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<${resultType("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<${resultType("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;
+};
+`;
+}