@vibeorm/generator 2.2.3 → 3.0.0

package/dist/index.js

@@ -1,4 +1,6 @@
 // @bun
+// packages/generator/src/module-schema.ts
+import { prepareDatabaseModuleSchema } from "@vibeorm/schema";
 // packages/generator/src/emit-module.ts
 import { createHash } from "crypto";
 import { VibeError as VibeError2, providerToDialect } from "@vibeorm/schema";
@@ -30,10 +32,13 @@ function maybeParens(params) {
   return type.includes("|") ? `(${type})` : type;
 }
 function stableStringify(params) {
-  return renderValue({ value: params.value, indent: "" });
+  return renderValue({ value: params.value, indent: "", javascript: false });
+}
+function stableJs(params) {
+  return renderValue({ value: params.value, indent: "", javascript: true });
 }
 function renderValue(params) {
-  const { value, indent } = params;
+  const { value, indent, javascript } = params;
   if (value === null)
     return "null";
   const kind = typeof value;
@@ -43,7 +48,7 @@ function renderValue(params) {
     if (value.length === 0)
       return "[]";
     const inner = `${indent}  `;
-    const items = value.map((item) => inner + renderValue({ value: item, indent: inner }));
+    const items = value.map((item) => inner + renderValue({ value: item, indent: inner, javascript }));
     return `[
 ${items.join(`,
 `)}
@@ -55,7 +60,7 @@ ${indent}]`;
     if (keys.length === 0)
       return "{}";
     const inner = `${indent}  `;
-    const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderValue({ value: record[key], indent: inner })}`);
+    const items = keys.map((key) => `${inner}${javascript && key === "__proto__" ? `[${JSON.stringify(key)}]` : JSON.stringify(key)}: ${renderValue({ value: record[key], indent: inner, javascript })}`);
     return `{
 ${items.join(`,
 `)}
@@ -117,7 +122,7 @@ export { sql, decode, sqlModels, sqlProjection } from "./index.js";
 export const databaseModule = defineDatabaseModule({ ...${JSON.stringify(module)}, schema, manifest: ${JSON.stringify(manifest)} });
 ` },
     { name: "schema.js", content: `// Generated data-only schema and runtime manifest.
-export const schema = ${serialized};
+export const schema = ${stableJs({ value: view.schema })};
 export const moduleManifest = ${JSON.stringify(manifest)};
 ` },
     { name: "schema.d.ts", content: `import type { SchemaIR, DatabaseModuleManifest } from "@vibeorm/schema";
@@ -369,7 +374,7 @@ ${validatorLines}
 function serializeSchema(params) {
   const { schema } = params;
   if (schema.rls === undefined)
-    return stableStringify({ value: schema });
+    return stableJs({ value: schema });
   return renderIr({ value: schema, indent: "", ordered: false });
 }
 function renderIr(params) {
@@ -398,7 +403,7 @@ ${indent}]`;
   if (keys.length === 0)
     return "{}";
   const inner = `${indent}  `;
-  const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderIr({ value: record[key], indent: inner, ordered: ordered || key === "rls" })}`);
+  const items = keys.map((key) => `${inner}${key === "__proto__" ? `[${JSON.stringify(key)}]` : JSON.stringify(key)}: ${renderIr({ value: record[key], indent: inner, ordered: ordered || key === "rls" })}`);
   return `{
 ${items.join(`,
 `)}
@@ -439,7 +444,7 @@ ${view.models.map((model) => `  [${tsString({ value: model.clientName })}]: (opt
   }
   if (!baked.empty) {
     parts.push(`/** Extension manifest \u2014 verified against the live extension list (VIBE_STALE_CLIENT). */
-` + `const extensionManifest = ${stableStringify({ value: baked.manifest })};`);
+` + `const extensionManifest = ${stableJs({ value: baked.manifest })};`);
     parts.push(`/** Baked extension surfaces (extensions.md D9). */
 ` + `const extensionMounts = [
 ${baked.mounts.map((mount) => `  ${mount},`).join(`
@@ -448,7 +453,7 @@ ${baked.mounts.map((mount) => `  ${mount},`).join(`
   }
   if (hasComputed) {
     parts.push(`/** Computed-field manifest \u2014 verified against the live computed config (VIBE_STALE_CLIENT). */
-` + `const computedManifest = ${stableStringify({ value: computed })};`);
+` + `const computedManifest = ${stableJs({ value: computed })};`);
   }
   const destructured = [
     "adapter",
@@ -534,6 +539,15 @@ function inputBaseType(params) {
     return "Date | string";
   return field.enumName ?? INPUT_TYPES[field.scalar];
 }
+function aggregateOperandType(params) {
+  const { field, key } = params;
+  if (key === "_count")
+    return "number";
+  if (key === "_avg")
+    return "number";
+  const value = field.scalar === "DateTime" ? "Date | string" : inputBaseType({ field });
+  return value;
+}
 function filterName(params) {
   const { field } = params;
   const prefix = field.enumName ?? FILTER_PREFIX[field.scalar];
@@ -589,6 +603,12 @@ function orMany(params) {
   const { type } = params;
   return `${type} | readonly ${maybeParens({ type })}[]`;
 }
+function aggregatePredicateType(params) {
+  const { value } = params;
+  const skip = params.skippable === false ? "" : " | Skip";
+  const operators = ["equals", "not", "gt", "gte", "lt", "lte"];
+  return `${value} | { ${operators.map((operator) => `readonly ${operator}?: ${value}${skip}`).join("; ")} }`;
+}
 function payloadFieldType(params) {
   const { field } = params;
   const base = payloadBaseType({ field });
@@ -638,16 +658,25 @@ export type RelationStrategy = "query" | "join";
  * query still applies its own where/scoped/policy/RLS filters.
  */
 export type KeysetToken = string;
+/** A bounded page; the continuation is null when no lookahead row exists. */
+export type KeysetPage<T> = { readonly items: T[]; readonly nextCursor: KeysetToken | null };
 
 /** Per-query keyset options. */
 export type KeysetOptions = {
   /**
    * Asserts that every DateTime ordering column in this query holds
-   * millisecond-exact values. Required on postgres and mysql, whose timestamps
-   * may be finer than a JavaScript Date; NOT safe for \`@default(now())\`
-   * columns on postgres, which are microsecond-precise.
+   * millisecond-exact values. Needed on postgres and mysql only for a column
+   * that may be finer than a JavaScript Date \u2014 one without a declared
+   * precision of 0-3; a column declared \`@db.Timestamptz(3)\` needs none. NOT
+   * safe for a microsecond \`@default(now())\` column.
    */
   readonly timestampPrecision?: "milliseconds";
+  /**
+   * The owner a page token belongs to (a user or tenant id). Mixed into the
+   * token's query binding beside the filters, so a token minted for one scope
+   * is refused for another. Encoded, not secret.
+   */
+  readonly scope?: string;
 };
 
 /** Result of createMany/updateMany/deleteMany. */
@@ -675,6 +704,21 @@ export type UpsertManyPayload = { readonly count: number; readonly affectedRows:
  */
 type Provided<T> = Exclude<T, Skip | undefined>;
 
+/** An absent projection member supplies the inactive fallback value. */
+type SelectionMember<S, K> = K extends keyof S ? S[K] : undefined;
+
+/** Object-bag keys only; primitive SKIP contributes no Symbol members. */
+type BagKeys<S> = S extends object ? keyof S : never;
+
+/** Read only object bags, preserving unions and optional bag omission. */
+type SelectionValue<S, K> = S extends object ? SelectionMember<S, K> : undefined;
+
+/** Only an active included relation replaces the selected relation. */
+type IncludedRelation<S, I> = I extends false | undefined | Skip ? S : I;
+
+/** Count include overrides even with false; omitted/nullish values fall back. */
+type IncludedCount<S, I> = I extends null | undefined | Skip ? S : I;
+
 /** Keys of an omit object whose value is exactly true \u2014 the scalars the result drops. */
 type OmittedKeys<O> = keyof { [K in keyof O as O[K] extends true ? K : never]: 0 };
 
@@ -935,7 +979,13 @@ function checkedCreateLines(params) {
 function uncheckedCreateLines(params) {
   const { model, omitRelation } = params;
   const omitted = new Set(omitRelation === undefined ? [] : model.relations.find((relation) => relation.name === omitRelation)?.fkFields ?? []);
-  return model.fields.filter((field) => !omitted.has(field.name)).map((field) => createFieldProp({ field }));
+  return [
+    ...model.fields.filter((field) => !omitted.has(field.name)).map((field) => createFieldProp({ field })),
+    ...model.relations.map((relation) => {
+      const value = params.scalarOnly !== true && relation.fkFields.length === 0 && relation.name !== omitRelation ? nestedRefName({ relation, verb: "Create" }) : "never";
+      return `  readonly ${propKey({ name: relation.name })}?: ${value};`;
+    })
+  ];
 }
 function checkedUpdateLines(params) {
   const { model, omitRelation } = params;
@@ -955,7 +1005,13 @@ function checkedUpdateLines(params) {
 function uncheckedUpdateLines(params) {
   const { model, omitRelation } = params;
   const omitted = new Set(omitRelation === undefined ? [] : model.relations.find((relation) => relation.name === omitRelation)?.fkFields ?? []);
-  return model.fields.filter((field) => !omitted.has(field.name)).map((field) => updateFieldProp({ field }));
+  return [
+    ...model.fields.filter((field) => !omitted.has(field.name)).map((field) => updateFieldProp({ field })),
+    ...model.relations.map((relation) => {
+      const value = params.scalarOnly !== true && relation.fkFields.length === 0 && relation.name !== omitRelation ? nestedRefName({ relation, verb: "Update" }) : "never";
+      return `  readonly ${propKey({ name: relation.name })}?: ${value};`;
+    })
+  ];
 }
 function register(params) {
   const { registry, name, text } = params;
@@ -1032,7 +1088,7 @@ function registerNestedContext(params) {
       lines: [`  readonly where: ${t}WhereUniqueInput;`, `  readonly create: ${createUnion};`]
     })
   });
-  const createManyData = inverse === null ? `readonly ${t}CreateManyInput[]` : `readonly ${t}UncheckedCreate${suffix}Input[]`;
+  const createManyData = inverse === null ? `readonly ${t}CreateManyInput[]` : `readonly { ${uncheckedCreateLines({ model: target, omitRelation: inverse, scalarOnly: true }).map((line) => skippableMembers({ block: line }).trim()).join(" ")} }[]`;
   if (many) {
     register({
       registry,
@@ -1123,7 +1179,7 @@ function registerNestedContext(params) {
           `  readonly connectOrCreate?: ${connectOrCreateName};`,
           `  readonly update?: ${updateUnion};`,
           `  readonly upsert?: { readonly create: ${createUnion}; readonly update: ${updateUnion} };`,
-          ...allowDetach ? [`  readonly disconnect?: boolean;`, `  readonly delete?: boolean;`] : []
+          ...allowDetach ? [`  readonly disconnect?: boolean | ${t}WhereInput;`, `  readonly delete?: boolean | ${t}WhereInput;`] : []
         ]
       })
     });
@@ -1145,7 +1201,7 @@ ${[
   ].join(`
 `)}
 };`);
-  parts.push(`export type ${n}ScalarFieldEnum = ${model.fields.map((field) => tsString({ value: field.name })).join(" | ")};`);
+  parts.push(`export type ${n}ScalarFieldEnum = ${literalUnion({ members: model.fields.map((field) => field.name) }) || "never"};`);
   if (computedEntries.length > 0) {
     parts.push(`export type ${n}SelectableFieldEnum = ${n}ScalarFieldEnum | ${computedEntries.map((entry) => tsString({ value: entry.field })).join(" | ")};`);
   }
@@ -1265,12 +1321,12 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   }));
   parts.push(inputAlias({ name: `${n}CreateInput`, lines: checkedCreateLines({ model }) }));
   parts.push(inputAlias({ name: `${n}UncheckedCreateInput`, lines: uncheckedCreateLines({ model }) }));
-  parts.push(`export type ${n}CreateManyInput = ${n}UncheckedCreateInput;`);
+  parts.push(inputAlias({ name: `${n}CreateManyInput`, lines: uncheckedCreateLines({ model, scalarOnly: true }) }));
   parts.push(inputAlias({ name: `${n}UpdateInput`, lines: checkedUpdateLines({ model }) }));
   parts.push(inputAlias({ name: `${n}UncheckedUpdateInput`, lines: uncheckedUpdateLines({ model }) }));
-  parts.push(`export type ${n}UpdateManyInput = ${n}UncheckedUpdateInput;`);
+  parts.push(inputAlias({ name: `${n}UpdateManyInput`, lines: uncheckedUpdateLines({ model, scalarOnly: true }) }));
   const numericFields = model.fields.filter((field) => !field.isList && field.scalar !== null && NUMERIC_SCALARS.has(field.scalar));
-  const minmaxFields = model.fields.filter((field) => !field.isList && field.scalar !== null && MINMAX_SCALARS.has(field.scalar));
+  const minmaxFields = model.fields.filter((field) => !field.isList && (field.enumName !== null || field.scalar !== null && MINMAX_SCALARS.has(field.scalar)));
   parts.push(inputAlias({
     name: `${n}CountAggregateInput`,
     lines: [
@@ -1297,6 +1353,44 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
     aggregateOpProps.push(`  readonly _min?: ${n}MinAggregateInput;`);
     aggregateOpProps.push(`  readonly _max?: ${n}MaxAggregateInput;`);
   }
+  const groupAggregates = [
+    { key: "_count", prefix: "Count", fields: model.fields },
+    ...numericFields.length > 0 ? [
+      { key: "_avg", prefix: "Avg", fields: numericFields },
+      { key: "_sum", prefix: "Sum", fields: numericFields }
+    ] : [],
+    ...minmaxFields.length > 0 ? [
+      { key: "_min", prefix: "Min", fields: minmaxFields },
+      { key: "_max", prefix: "Max", fields: minmaxFields }
+    ] : []
+  ];
+  const groupAggregateFields = new Map(groupAggregates.map((aggregate) => [aggregate, new Set(aggregate.fields)]));
+  const havingLines = [
+    `  readonly AND?: ${orMany({ type: `${n}HavingInput` })};`,
+    `  readonly OR?: ${orMany({ type: `${n}HavingInput` })};`,
+    `  readonly NOT?: ${orMany({ type: `${n}HavingInput` })};`
+  ];
+  const groupOrderLines = [...scalarOrderLines];
+  for (const aggregate of groupAggregates) {
+    const havingFields = aggregate.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: ${aggregatePredicateType({ value: aggregateOperandType({ field, key: aggregate.key }) })};`);
+    const orderFields = aggregate.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: SortOrder;`);
+    if (aggregate.key === "_count") {
+      havingFields.push(`  readonly _all?: ${aggregatePredicateType({ value: "number" })};`);
+      orderFields.push(`  readonly _all?: SortOrder;`);
+    }
+    parts.push(inputAlias({ name: `${n}${aggregate.prefix}AggregateHavingInput`, lines: havingFields }));
+    parts.push(inputAlias({ name: `${n}${aggregate.prefix}AggregateOrderByInput`, lines: orderFields }));
+    havingLines.push(`  readonly ${aggregate.key}?: ${n}${aggregate.prefix}AggregateHavingInput;`);
+    groupOrderLines.push(`  readonly ${aggregate.key}?: ${n}${aggregate.prefix}AggregateOrderByInput;`);
+  }
+  for (const field of model.fields) {
+    const aggregates = groupAggregates.filter((aggregate) => groupAggregateFields.get(aggregate).has(field)).map((aggregate) => `readonly ${aggregate.key}?: ${aggregatePredicateType({ value: aggregateOperandType({ field, key: aggregate.key }), skippable: field.scalar !== "Json" })} | Skip`);
+    const filter = `(${filterName({ field })} & { ${aggregates.join("; ")} })`;
+    const value = field.isList || field.scalar === "Json" ? filter : `${inputBaseType({ field })} | ${filter}${field.isOptional ? " | null" : ""}`;
+    havingLines.push(`  readonly ${propKey({ name: field.name })}?: ${value};`);
+  }
+  parts.push(inputAlias({ name: `${n}HavingInput`, lines: havingLines }));
+  parts.push(inputAlias({ name: `${n}GroupByOrderByInput`, lines: groupOrderLines }));
   for (const nested of [false, true]) {
     parts.push(inputAlias({
       name: `${n}${nested ? "RelationFindManyArgs" : "FindManyArgs"}`,
@@ -1319,6 +1413,21 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
       ]
     }));
   }
+  parts.push(inputAlias({
+    name: `${n}FindPageArgs`,
+    lines: [
+      `  readonly where?: ${n}WhereInput;`,
+      `  readonly orderBy: ${orMany({ type: `${n}ScalarOrderByInput` })};`,
+      `  readonly take: number;`,
+      `  readonly after?: KeysetToken;`,
+      `  readonly keyset?: KeysetOptions;`,
+      `  readonly select?: ${n}Select;`,
+      `  readonly include?: ${n}Include;`,
+      `  readonly omit?: ${n}OmitInput;`,
+      `  readonly relationStrategy?: RelationStrategy;`,
+      ...["skip", "cursor", "distinct", "lock"].map((key) => `  readonly ${key}?: never;`)
+    ]
+  }));
   parts.push(`export type ${n}FindFirstArgs = ${n}FindManyArgs;`);
   parts.push(inputAlias({
     name: `${n}FindUniqueArgs`,
@@ -1334,6 +1443,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   parts.push(inputAlias({
     name: `${n}CreateArgs`,
     lines: [
+      `  readonly relationStrategy?: never;`,
       `  readonly onConflict?: never;`,
       `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
       `  readonly select?: ${n}Select;`,
@@ -1348,6 +1458,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   parts.push(inputAlias({
     name: `${n}CreateOrSkipArgs`,
     lines: [
+      `  readonly relationStrategy?: never;`,
       `  readonly data: ${n}CreateInput | ${n}UncheckedCreateInput;`,
       `  readonly onConflict: ${n}CreateOnConflictInput;`,
       `  readonly select?: ${n}Select;`,
@@ -1358,6 +1469,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   parts.push(inputAlias({
     name: `${n}CreateManyArgs`,
     lines: [
+      `  readonly relationStrategy?: never;`,
       `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
       `  readonly skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`
     ]
@@ -1365,6 +1477,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   parts.push(inputAlias({
     name: `${n}CreateManyAndReturnArgs`,
     lines: [
+      `  readonly relationStrategy?: never;`,
       `  readonly data: ${orMany({ type: `${n}CreateManyInput` })};`,
       `  readonly skipDuplicates?: boolean | { readonly target?: ${n}ConflictTarget; readonly where?: string };`,
       `  readonly select?: ${n}Select;`,
@@ -1403,13 +1516,19 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
       `  readonly skipUpdatedAt?: boolean;`
     ]
   }));
+  const returningSelect = [
+    ...model.fields.map((field) => `readonly ${propKey({ name: field.name })}?: boolean | Skip`),
+    ...computedEntries.map((entry) => `readonly ${propKey({ name: entry.field })}?: boolean | Skip`),
+    ...model.relations.map((relation) => `readonly ${propKey({ name: relation.name })}?: false | Skip`),
+    ...hasCounts ? ["readonly _count?: false | Skip"] : []
+  ].join("; ");
   parts.push(inputAlias({
     name: `${n}UpdateManyAndReturnArgs`,
     lines: [
       `  readonly include?: never;`,
       `  readonly where?: ${n}WhereInput;`,
       `  readonly data: ${n}UpdateManyInput;`,
-      `  readonly select?: ${n}Select;`,
+      `  readonly select?: { ${returningSelect} };`,
       `  readonly omit?: ${n}OmitInput;`,
       `  readonly skipUpdatedAt?: boolean;`
     ]
@@ -1461,8 +1580,8 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
     lines: [
       `  readonly by: readonly ${n}ScalarFieldEnum[];`,
       `  readonly where?: ${n}WhereInput;`,
-      `  readonly orderBy?: ${orMany({ type: `${n}ScalarOrderByInput` })};`,
-      `  readonly having?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}GroupByOrderByInput` })};`,
+      `  readonly having?: ${n}HavingInput;`,
       `  readonly take?: number;`,
       `  readonly skip?: number;`,
       ...aggregateOpProps
@@ -1481,9 +1600,9 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
 ` + `    { [K in keyof CS & (${listUnion}) as ${uncertainPart("CS")}]?: number }
 ` + `  : C extends { readonly select: Skip } ? { ${allCounts} }
 ` + `  : "select" extends keyof C ? Partial<{ ${allCounts} }> : { ${allCounts} };`);
-    parts.push(`type ${n}CountPayload<S> = S extends { readonly _count: infer C extends true | object } ? { _count: ${n}CountResult<C> }
-` + `  : S extends { readonly _count: false | undefined | Skip } ? unknown
-` + `  : S extends { readonly _count?: infer C extends boolean | object | Skip } ? { _count?: ${n}CountResult<Provided<C>> } : unknown;`);
+    parts.push(`type ${n}CountPayload<C> = [C] extends [true | object] ? { _count: ${n}CountResult<C> }
+` + `  : [C] extends [false | undefined | Skip] ? unknown
+` + `  : { _count?: ${n}CountResult<Exclude<C, false | undefined | Skip>> };`);
   }
   if (hasRelations) {
     const relationCases = model.relations.map((relation) => {
@@ -1503,20 +1622,23 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
     parts.push(`type ${n}RelationPayload<K extends keyof ${n}Relations, A> = {
 ${relationCases}
 }[K];`);
-    parts.push(`type ${n}IncludePayload<A> = A extends { readonly include: infer I extends object }
-` + `  ? { [K in keyof I & keyof ${n}Relations as ${exactPart("I")}]: ${n}RelationPayload<K, I[K]> } &
-` + `    { [K in keyof I & keyof ${n}Relations as ${uncertainPart("I")}]?: ${n}RelationPayload<K, I[K]> }${hasCounts ? ` &
-    ${n}CountPayload<I>` : ""}
-` + `  : "include" extends keyof A ? Partial<${n}IncludePayload<{ include: Provided<A["include"]> }>> : unknown;`);
+    parts.push(`type ${n}ResolvedSelection<A, S = SelectionValue<A, "select">, I = SelectionValue<A, "include">> = {
+` + `  [K in (BagKeys<S> | BagKeys<I>) & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})]: ${hasCounts ? `K extends "_count" ? IncludedCount<SelectionValue<S, K>, SelectionValue<I, K>> : ` : ""}IncludedRelation<SelectionValue<S, K>, SelectionValue<I, K>>;
+` + `};`);
+    parts.push(`type ${n}IncludePayload<A, I = "include" extends keyof A ? "select" extends keyof A ? ${n}ResolvedSelection<A> : SelectionValue<A, "include"> : SelectionValue<A, "select">> =
+` + `  [Exclude<SelectionValue<I, BagKeys<I> & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})>, false | undefined | Skip>] extends [never] ? unknown :
+` + `  { [K in BagKeys<I> & keyof ${n}Relations as ${exactPart("I").replaceAll("I[K]", "SelectionValue<I, K>")}]: ${n}RelationPayload<K, Exclude<SelectionValue<I, K>, false | undefined | Skip>> } &
+` + `  { [K in BagKeys<I> & keyof ${n}Relations as ${uncertainPart("I").replaceAll("I[K]", "SelectionValue<I, K>")}]?: ${n}RelationPayload<K, Exclude<SelectionValue<I, K>, false | undefined | Skip>> }${hasCounts ? ` &
+  ${n}CountPayload<SelectionValue<I, "_count">>` : ""};`);
     parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
 ` + `  ? { [K in keyof S & ${selectableEnum} as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
 ` + `    { [K in keyof S & ${selectableEnum} as ${uncertainPart("S")}]?: ${n}[K & keyof ${n}] } &
-` + `    { [K in keyof S & keyof ${n}Relations as ${exactPart("S")}]: ${n}RelationPayload<K, S[K]> } &
-` + `    { [K in keyof S & keyof ${n}Relations as ${uncertainPart("S")}]?: ${n}RelationPayload<K, S[K]> }${hasCounts ? ` &
-    ${n}CountPayload<S>` : ""}
+` + `    ("include" extends keyof A ? ${n}IncludePayload<A> :
+` + `      [Exclude<SelectionValue<S, BagKeys<S> & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})>, false | undefined | Skip>] extends [never] ? unknown : ${n}IncludePayload<A>)
 ` + `  : A extends { readonly select: Skip } ? ${n}OmitBase<A> & ${n}IncludePayload<A>
-` + `  : "select" extends keyof A ? Partial<${n}>
-` + `  : ${n}OmitBase<A> & ${n}IncludePayload<A>;`);
+` + `  : "select" extends keyof A ? Partial<${n}> & ${n}IncludePayload<A>
+` + `  : "include" extends keyof A ? ${n}OmitBase<A> & ${n}IncludePayload<A>
+` + `  : ${n}OmitBase<A>;`);
   } else {
     parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
 ` + `  ? { [K in keyof S & ${selectableEnum} as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
@@ -1525,7 +1647,7 @@ ${relationCases}
 ` + `  : "select" extends keyof A ? Partial<${n}> : ${n}OmitBase<A>;`);
   }
   const aggregateFields = (fields, value) => `{ ${fields.map((field) => `${propKey({ name: field.name })}: ${value(field)}`).join("; ")} }`;
-  const countValues = aggregateFields(model.fields, () => "number").replace(" }", "; _all: number }");
+  const countValues = `{ ${[...model.fields.map((field) => `${propKey({ name: field.name })}: number`), "_all: number"].join("; ")} }`;
   parts.push(`type ${n}AggregateValues = {
 ` + `  _count: ${countValues};
 ` + `  _avg: ${aggregateFields(numericFields, () => "number | null")};
@@ -1546,6 +1668,7 @@ ${relationCases}
 ` + `  (number extends A["by"]["length"] ? Partial<Pick<${n}, A["by"][number]>> : Pick<${n}, A["by"][number]>) & ${n}AggregateResult<A>;`);
   const readMethods = [
     `  findMany<A extends ${n}FindManyArgs = {}>(args?: A): VibeQueryPromise<${n}GetPayload<A>[]>;`,
+    `  findPage<A extends ${n}FindPageArgs>(args: A): VibeQueryPromise<KeysetPage<${n}GetPayload<A>>>;`,
     `  findFirst<A extends ${n}FindFirstArgs = {}>(args?: A): VibeQueryPromise<${n}GetPayload<A> | null>;`,
     `  findFirstOrThrow<A extends ${n}FindFirstArgs = {}>(args?: A): VibeQueryPromise<${n}GetPayload<A>>;`,
     `  findUnique<A extends ${n}FindUniqueArgs>(args: A): VibeQueryPromise<${n}GetPayload<A> | null>;`,
@@ -1656,7 +1779,7 @@ function emitViewTypesForModel(params) {
       const target = relation.target;
       const targetClientKey = view.modelByName.get(target)?.clientName ?? target;
       const guard = `D extends { readonly ${propKey({ name: targetClientKey })}: infer RF extends object }`;
-      const masked = `ViewRow<${target}ViewSelectScalars<RF, A> & ${target}ViewReveal<A>>`;
+      const masked = `${target}ViewResult<RF, Exclude<A, false | undefined | Skip>, D>`;
       const unmasked = `(A extends object ? ${target}GetPayload<A> : ${target})`;
       let expression;
       if (relation.isList) {
@@ -1881,8 +2004,9 @@ var CONNECTION_SURFACE_LINES = `  readonly $connect: () => Promise<void>;
 var DEFINE_VIEW_LINE = `  /** Field-masking views (v1 defineView parity): a read-only masked projection of models. */
 ` + `  readonly $defineView: <D extends ViewDefinitionInput>(options: { readonly name: string; readonly definition: D }) => ViewClient<D>;
 `;
-var READ_ONLY_LINE = `  /** A read-only handle over this one: reads pass through, and every write, raw-SQL and control method is refused with \`VIBE_READ_ONLY\`. Closed under composition \u2014 transactions, views, scoped and policy handles built from it stay read-only. */
-` + `  readonly $readOnly: () => ReadOnlyClientInstance;
+var READ_ONLY_DOC = `  /** A read-only handle over this one: reads pass through, and every write, raw-SQL and control method is refused with \`VIBE_READ_ONLY\`. Closed under composition \u2014 transactions, views, scoped and policy handles built from it stay read-only. */
+`;
+var READ_ONLY_LINE = READ_ONLY_DOC + `  readonly $readOnly: () => ReadOnlyClientInstance;
 `;
 function instanceSurfaceLines(params) {
   const { view, transactionType, inTransaction, selfLabel } = params;
@@ -2064,7 +2188,7 @@ function emitClient(params) {
 ` + `  // Deliberately ABSENT: model delegates, $models, $transaction, $queryRaw / $executeRaw / $queryRawUnsafe / $executeRawUnsafe, $advisoryLock / $tryAdvisoryLock, $defineView, $readOnly and every extension mount \u2014 an unbound client has no identity, so it cannot read or write a row. Bind one with $withContext.
 ` + `};`);
   } else {
-    parts.push(`export type VibeClientInstance = ClientContext<"root"> & {
+    parts.push(`export type VibeClientInstance = ClientContext<${tsString({ value: view.models.some((model) => model.policy !== undefined) ? "restricted" : "root" })}> & {
 ` + instanceSurfaceLines({
       view,
       transactionType: "VibeTransactionClientInstance",
@@ -2072,7 +2196,7 @@ function emitClient(params) {
       selfLabel: "db"
     }) + policyClientLines({ view, selfType: "VibeClientInstance" }) + scopedClientLines({ view, scopedType: "ScopedClientInstance" }) + READ_ONLY_LINE + clientExtensionLines + `};`);
     parts.push(`/** The handle \`$transaction\` gives its callback. A helper that REQUIRES a transaction takes this type, and an ordinary client no longer satisfies it. */
-` + `export type VibeTransactionClientInstance = ClientContext<"transaction"> & {
+` + `export type VibeTransactionClientInstance = ClientContext<${tsString({ value: view.models.some((model) => model.policy !== undefined) ? "restricted" : "transaction" })}> & {
 ` + instanceSurfaceLines({
       view,
       transactionType: "VibeTransactionClientInstance",
@@ -2135,7 +2259,8 @@ ${modelsProps.join(`
 ` + `  };
 ` + (params2.inTransaction ? advisoryLockLines({ view, selfLabel: "tx" }) : CONNECTION_SURFACE_LINES) + `  /** Field-masking views compose over the scoped handle (columns \xD7 rows). */
 ` + `  readonly $defineView: <D extends ViewDefinitionInput>(options: { readonly name: string; readonly definition: D }) => ViewClient<D>;
-` + READ_ONLY_LINE;
+` + READ_ONLY_DOC + `  readonly $readOnly: () => ReadOnlyClientInstance<"restricted">;
+`;
   return [
     banner({ title: "Tenant scoping ($scoped)" }),
     `/** What a scoped handle does when this model appears INSIDE another model's nested write: "verify" (default) rewrites reference verbs into tenant-verified lookups; "refuse" rejects them. */
@@ -2145,11 +2270,11 @@ export type ScopedModelsConfig = {
 ${entries.join(`
 `)}
 };`,
-    `export type ScopedClientInstance = {
+    `export type ScopedClientInstance = ClientContext<"restricted"> & {
 ` + scopedSurface({ transactionType: "ScopedTransactionClientInstance", inTransaction: false }) + `  // Deliberately ABSENT: $queryRaw / $executeRaw / $queryRawUnsafe / $executeRawUnsafe (raw SQL cannot be tenant-verified \u2014 use the base client) and $scoped (scope once, from the base client).
 ` + `};`,
     `/** The scoped handle inside \`$transaction\`: same scope, plus the locks that require a transaction. */
-` + `export type ScopedTransactionClientInstance = {
+` + `export type ScopedTransactionClientInstance = ClientContext<"restricted"> & {
 ` + scopedSurface({ transactionType: "ScopedTransactionClientInstance", inTransaction: true }) + `  // Deliberately ABSENT: the raw-SQL doors, $scoped, and $connect / $disconnect (the open transaction owns the connection).
 ` + `};`
   ];
@@ -2186,6 +2311,9 @@ function emitReadOnlySection(params) {
   const extensionLines = baked.readOnlyClientDts.length === 0 ? "" : `${baked.readOnlyClientDts.join(`
 `)}
 `;
+  const scopeLines = scopedClientLines({ view, scopedType: 'ReadOnlyClientInstance<"restricted">' });
+  const scopeSurface = scopeLines.length === 0 ? "" : `(ContextKind extends "readOnly" ? {
+${scopeLines}} : {}) & `;
   return [
     banner({ title: "Read-only clients ($readOnly)" }),
     `/**
@@ -2199,24 +2327,66 @@ function emitReadOnlySection(params) {
 ` + ` * await reader.user.findMany();          // fine
 ` + ` * await reader.user.upsertMany({ \u2026 });   // VIBE_READ_ONLY, and a compile error
 ` + ` */
-` + `export type ReadOnlyClientInstance = ClientContext<"readOnly"> & {
-` + delegateSurfaceLines({ view, delegateSuffix: "ReadOnlyDelegate" }) + transactionLines({ transactionType: "ReadOnlyClientInstance", reads: true }) + DEFINE_VIEW_LINE + policyClientLines({ view, selfType: "ReadOnlyClientInstance" }) + scopedClientLines({ view, scopedType: "ReadOnlyClientInstance" }) + `  /** Idempotent \u2014 restricting an already-restricted handle returns the same handle. */
-` + `  readonly $readOnly: () => ReadOnlyClientInstance;
+` + `export type ReadOnlyClientInstance<ContextKind extends "readOnly" | "restricted" = ${tsString({ value: hasNativeRls({ view }) || view.models.some((model) => model.policy !== undefined) ? "restricted" : "readOnly" })}> = ClientContext<ContextKind> & ${scopeSurface}{
+` + delegateSurfaceLines({ view, delegateSuffix: "ReadOnlyDelegate" }) + transactionLines({ transactionType: "ReadOnlyClientInstance<ContextKind>", reads: true }) + DEFINE_VIEW_LINE + policyClientLines({ view, selfType: "ReadOnlyClientInstance<ContextKind>" }) + `  /** Idempotent: the same read-only restriction and underlying context are retained. */
+` + `  readonly $readOnly: () => ReadOnlyClientInstance<ContextKind>;
 ` + extensionLines + `  // Deliberately ABSENT: every write method, $queryRaw / $executeRaw / $queryRawUnsafe / $executeRawUnsafe, $connect / $disconnect, $advisoryLock / $tryAdvisoryLock, $withContext, and every extension surface its author did not classify as a read.
 ` + `};`
   ];
 }
-function emitDts(params) {
+var UNSUPPORTED_INPUT_MEMBER_NAMES = new Set([
+  "toString",
+  "valueOf",
+  "constructor",
+  "toLocaleString",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable"
+]);
+function groupComputed(params) {
+  const byModel = new Map;
+  for (const entry of params.computed) {
+    const model = entry.model;
+    const list = byModel.get(model);
+    if (list === undefined)
+      byModel.set(model, [entry]);
+    else
+      list.push(entry);
+  }
+  return byModel;
+}
+function assertGeneratedInputNames(params) {
+  const check = (member) => {
+    if (!UNSUPPORTED_INPUT_MEMBER_NAMES.has(member.name))
+      return;
+    const hint = member.kind === "field" ? "Rename the logical field and preserve its database column with @map or DSL .map()." : member.kind === "relation" ? "Rename the logical relation while keeping its FK fields, references, relation pairing name and constraint mapping. Relation fields do not have a column @map." : "Rename the computed alias in the computed configuration; it has no database column to map.";
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `Generated TypeScript inputs cannot represent logical ${member.kind} "${member.model}.${member.name}" safely because it conflicts with an inherited Object member. ${hint} SchemaIR and the dynamic client still accept this name.`,
+      meta: { reason: "generated_input_member", model: member.model, member: member.name, kind: member.kind }
+    });
+  };
+  const computedByModel = groupComputed({ computed: params.computed ?? [] });
+  for (const model of params.view.models) {
+    for (const field of model.fields)
+      check({ model: model.name, name: field.name, kind: "field" });
+    for (const relation of model.relations)
+      check({ model: model.name, name: relation.name, kind: "relation" });
+    for (const entry of computedByModel.get(model.name) ?? []) {
+      check({ model: model.name, name: entry.field, kind: "computed" });
+    }
+  }
+}
+function prepareDts(params) {
+  assertGeneratedInputNames({ view: params.view, computed: params.computed ?? [] });
+  return () => emitPreparedDts(params);
+}
+function emitPreparedDts(params) {
   const { view } = params;
   const baked = params.baked ?? EMPTY_BAKED_EXTENSIONS;
   const computed = params.computed ?? [];
   const hasComputed = computed.length > 0;
-  const computedByModel = new Map;
-  for (const entry of computed) {
-    const list = computedByModel.get(entry.model) ?? [];
-    list.push(entry);
-    computedByModel.set(entry.model, list);
-  }
+  const computedByModel = groupComputed({ computed });
   const parts = [];
   parts.push(GENERATED_HEADER);
   const schemaTypeImports = [
@@ -2451,7 +2621,8 @@ var README = `# Generated VibeORM client
 This directory was generated by \`@vibeorm/generator\` from your VibeORM schema \u2014 do not edit it by hand, any change is overwritten on the next generate. After every schema change, regenerate with \`vibeorm generate\` (or programmatically via \`generateClient({ schema, outDir })\` from \`@vibeorm/generator\`).
 `;
 async function generateClient(params) {
-  const { schema, outDir } = params;
+  const { outDir } = params;
+  const schema = params.module === undefined ? params.schema : prepareDatabaseModuleSchema({ schema: params.schema, module: params.module });
   const view = buildSchemaView({ schema });
   const baked = bakeExtensions({ schema: view.schema, extensions: params.extensions ?? [] });
   let computed = [];
@@ -2459,11 +2630,12 @@ async function generateClient(params) {
     validateComputedConfig({ schema, computed: params.computed });
     computed = buildComputedManifest({ computed: params.computed });
   }
+  const declarations = prepareDts({ view, baked, computed });
   if (params.module !== undefined && (!baked.empty || computed.length > 0))
     throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Package modules do not support computed fields or extension mounts in this protocol", meta: { reason: "module_schema_feature", moduleId: params.module.id } });
   const outputs = [
     { name: "index.js", content: emitJs({ view, baked, computed }) },
-    { name: "index.d.ts", content: emitDts({ view, baked, computed }) },
+    { name: "index.d.ts", content: declarations() },
     { name: "enums.js", content: emitEnumsJs({ view }) },
     { name: "enums.d.ts", content: emitEnumsDts({ view }) },
     { name: "README.md", content: README },
@@ -2480,7 +2652,8 @@ async function generateClient(params) {
 }
 export {
   bakeExtensions,
-  generateClient
+  generateClient,
+  prepareDatabaseModuleSchema
 };
 
-//# debugId=BC4813FB63493C9C64756E2164756E21
+//# debugId=0EF8A4E0C9CC959A64756E2164756E21