@an5/orm 1.3.2 → 1.3.3

package/generator/src/push-schema.ts

@@ -7,6 +7,14 @@
  * lands in. It is kept here rather than inline in `push.ts` so the mapping from
  * schema text to a column can be tested without a database.
  */
+import {
+  attributeArgs,
+  hasAttribute,
+  parseIndexDirective,
+  splitSchemaLines,
+  stringOption,
+  unquote,
+} from './attributes';
 import {
   FieldTypeIssue,
   Provider,
@@ -22,6 +30,8 @@ export interface PushField {
   isOptional: boolean;
   isId: boolean;
   isUnique: boolean;
+  /** `@unique(map: "…")`, so push and migrate create the same artifact name. */
+  uniqueName?: string | undefined;
   /** The `@default(...)` expression, not SQL: only the dialect knows the spelling. */
   defaultExpr?: string | undefined;
 }
@@ -40,6 +50,22 @@ export interface PushModel {
   indexes: PushIndex[];
 }
 
+/**
+ * A `view` block, as push needs it.
+ *
+ * `fields` describe the view's result columns for validation and generated
+ * clients; the DDL itself is `sql`, the `@@sql("...")` body.
+ */
+export interface PushView {
+  name: string;
+  /** The database view name; `@@map` may rename it independently. */
+  viewName: string;
+  schema: string;
+  declaredSchema?: string | undefined;
+  fields: PushField[];
+  sql: string;
+}
+
 /**
  * The schema a model lands in when the schema file does not say: none, for every
  * provider, so the name goes wherever the connection resolves.
@@ -71,25 +97,22 @@ export interface PushIndex {
 
 export interface PushSchema {
   models: PushModel[];
+  /** `view` blocks, applied after the tables they read from. */
+  views: PushView[];
   /** Field types the provider does not have; empty when the schema is valid. */
   issues: FieldTypeIssue[];
 }
 
-/** The field list of `@@unique([a, b], …)`, plus whatever options follow it. */
-const DIRECTIVE = /^@@(?:unique|index)\(\s*\[([\w\s,]+)\]([^)]*)\)/;
-
-function parseDirective(line: string, fields: string): PushIndex {
-  const options = line.match(DIRECTIVE)?.[2] ?? '';
-  const name = options.match(/\bmap\s*:\s*"([^"]+)"/)?.[1];
-  const include = options.match(/\binclude\s*:\s*\[([\w,\s]+)\]/)?.[1];
-  const filter = options.match(/\bfilter\s*:\s*"([^"]+)"/)?.[1];
-  const opts = options.match(/\boptions\s*:\s*"([^"]+)"/)?.[1];
+/** Reads `@@unique(…)`/`@@index(…)` into the shape push and migrate share. */
+function parseDirective(line: string, name: '@@unique' | '@@index'): PushIndex | null {
+  const parsed = parseIndexDirective(attributeArgs(line, name));
+  if (!parsed) return null;
   return {
-    fields: fields.split(',').map((field) => field.trim()).filter(Boolean),
-    ...(name ? { name } : {}),
-    ...(include ? { includeFields: include.split(',').map((field) => field.trim()).filter(Boolean) } : {}),
-    ...(filter ? { filter } : {}),
-    ...(opts ? { options: opts } : {}),
+    fields: parsed.fields,
+    ...(parsed.name ? { name: parsed.name } : {}),
+    ...(parsed.includeFields ? { includeFields: parsed.includeFields } : {}),
+    ...(parsed.filter !== undefined ? { filter: parsed.filter } : {}),
+    ...(parsed.options !== undefined ? { options: parsed.options } : {}),
   };
 }
 
@@ -122,11 +145,14 @@ export function directiveName(
  */
 export function parsePushSchema(text: string, provider: Provider): PushSchema {
   const models: PushModel[] = [];
+  const views: PushView[] = [];
   const issues: FieldTypeIssue[] = [];
   const modelRefs: Array<{ model: string; field: string; type: string }> = [];
+  const viewRefs: Array<{ view: string; field: string; type: string }> = [];
   let current: PushModel | null = null;
+  let currentView: PushView | null = null;
 
-  for (const raw of text.split('\n')) {
+  for (const raw of splitSchemaLines(text)) {
     const line = raw.trim();
     if (!line || line.startsWith('//')) continue;
 
@@ -140,37 +166,92 @@ export function parsePushSchema(text: string, provider: Provider): PushSchema {
         compoundUniques: [],
         indexes: [],
       };
+      currentView = null;
       models.push(current);
       continue;
     }
 
+    const viewHeader = line.match(/^view\s+(\w+)\s*\{/);
+    if (viewHeader) {
+      currentView = {
+        name: viewHeader[1],
+        viewName: viewHeader[1].toLowerCase() + 's',
+        schema: defaultSchemaFor(provider),
+        fields: [],
+        sql: '',
+      };
+      current = null;
+      views.push(currentView);
+      continue;
+    }
+
     if (line === '}') {
       current = null;
+      currentView = null;
       continue;
     }
+
+    if (currentView) {
+      if (line.startsWith('@@sql') || line.startsWith('@@definition')) {
+        const attribute = line.startsWith('@@sql') ? '@@sql' : '@@definition';
+        const sql = unquote(attributeArgs(line, attribute));
+        if (sql !== undefined) currentView.sql = sql.trim();
+        continue;
+      }
+      if (line.startsWith('@@map')) {
+        const mapped = unquote(attributeArgs(line, '@@map'));
+        if (mapped) currentView.viewName = mapped;
+        continue;
+      }
+      if (line.startsWith('@@schema')) {
+        const declared = unquote(attributeArgs(line, '@@schema'));
+        if (declared !== undefined) {
+          currentView.schema = declared.trim();
+          currentView.declaredSchema = currentView.schema;
+        }
+        continue;
+      }
+      if (line.startsWith('@@')) continue;
+
+      const head = readFieldLineHead(line);
+      if (!head) continue;
+      if (!resolveFieldType(head.type, provider)) {
+        // A view's fields are columns of a result set, never relations.
+        viewRefs.push({ view: currentView.name, field: head.name, type: head.type });
+        continue;
+      }
+      currentView.fields.push({
+        name: head.name,
+        sqlType: head.type.toUpperCase(),
+        isOptional: head.isOptional,
+        isId: false,
+        isUnique: false,
+      });
+      continue;
+    }
+
     if (!current) continue;
 
     if (line.startsWith('@@map')) {
-      const match = line.match(/@@map\("(.+)"\)/);
-      if (match) current.tableName = match[1];
+      const mapped = unquote(attributeArgs(line, '@@map'));
+      if (mapped) current.tableName = mapped;
       continue;
     }
     if (line.startsWith('@@schema')) {
-      // `(.*)` rather than `(.+)`, because `@@schema("")` is how a model says "no
-      // schema" and has to survive as an empty string rather than being dropped as
-      // no match — which is how SQLite and MySQL schemas are written.
-      const match = line.match(/@@schema\("(.*)"\)/);
-      if (match) {
-        current.schema = match[1].trim();
+      // An empty string is meaningful — `@@schema("")` says "no schema" for databases
+      // that have none — so it has to survive as `''` rather than being dropped.
+      const declared = unquote(attributeArgs(line, '@@schema'));
+      if (declared !== undefined) {
+        current.schema = declared.trim();
         current.declaredSchema = current.schema;
       }
       continue;
     }
     if (line.startsWith('@@unique') || line.startsWith('@@index')) {
-      const match = line.match(DIRECTIVE);
-      if (match) {
-        const definition = parseDirective(line, match[1] ?? '');
-        if (line.startsWith('@@unique')) current.compoundUniques.push(definition);
+      const isUnique = line.startsWith('@@unique');
+      const definition = parseDirective(line, isUnique ? '@@unique' : '@@index');
+      if (definition) {
+        if (isUnique) current.compoundUniques.push(definition);
         else current.indexes.push(definition);
       }
       continue;
@@ -187,17 +268,19 @@ export function parsePushSchema(text: string, provider: Provider): PushSchema {
 
     // The type is kept as written (upper-cased) because that is what the database
     // is told; which types exist is what `resolveFieldType` just checked.
+    const uniqueArgs = attributeArgs(line, '@unique');
     current.fields.push({
       name: head.name,
       sqlType: head.type.toUpperCase(),
       isOptional: head.isOptional,
-      isId: line.includes('@id'),
-      isUnique: line.includes('@unique'),
+      isId: hasAttribute(line, '@id'),
+      isUnique: hasAttribute(line, '@unique'),
+      ...(uniqueArgs ? { uniqueName: stringOption(uniqueArgs, 'map') } : {}),
       // The expression rather than SQL: `uuid()` and `autoincrement()` are spelled
       // differently per provider, and only the dialect knows how. `@updatedAt` is
       // `now()` under another name.
-      defaultExpr: line.match(/@default\((.*)\)/)?.[1]
-        ?? (line.includes('@updatedAt') ? 'now()' : undefined),
+      defaultExpr: attributeArgs(line, '@default')
+        ?? (hasAttribute(line, '@updatedAt') ? 'now()' : undefined),
     });
   }
 
@@ -216,8 +299,42 @@ export function parsePushSchema(text: string, provider: Provider): PushSchema {
     }
   }
 
+  for (const view of views) {
+    if (view.declaredSchema === 'dbo' && provider !== 'mssql') {
+      issues.push({
+        path: view.name,
+        message:
+          `schema "dbo" does not exist in ${provider}; remove the @@schema directive or set it ` +
+          'to the schema this database uses',
+      });
+    }
+    if (!view.sql.trim()) {
+      issues.push({ path: view.name, message: 'a view needs @@sql("SELECT ...")' });
+    }
+  }
+
+  // A `@unique` without `map:` must still get the deterministic name `db:migrate`
+  // expects, or push leaves a database-named constraint that the next diff cannot
+  // recognise and adds a second one for the same column.
+  for (const model of models) {
+    const table = safeIdentifierName(model.tableName);
+    for (const field of model.fields) {
+      if (field.isUnique && !field.isId && !field.uniqueName) {
+        field.uniqueName = `UQ_${table}_${safeIdentifierName(field.name)}`;
+      }
+    }
+  }
+
   const modelNames = models.map((model) => model.name);
+  const viewNames = new Set(views.map((view) => view.name));
   for (const ref of modelRefs) {
+    if (viewNames.has(ref.type)) {
+      issues.push({
+        path: `${ref.model}.${ref.field}`,
+        message: `"${ref.type}" is a view and cannot be the target of a relation; select from it directly instead`,
+      });
+      continue;
+    }
     if (!modelNames.includes(ref.type)) {
       issues.push({
         path: `${ref.model}.${ref.field}`,
@@ -225,8 +342,14 @@ export function parsePushSchema(text: string, provider: Provider): PushSchema {
       });
     }
   }
+  for (const ref of viewRefs) {
+    issues.push({
+      path: `${ref.view}.${ref.field}`,
+      message: unknownFieldTypeMessage(ref.type, provider, modelNames),
+    });
+  }
 
-  return { models, issues };
+  return { models, views, issues };
 }
 
 /**
@@ -247,4 +370,9 @@ export function safeIdentifierName(raw: string): string {
 
 export function qualifiedTableName(model: PushModel): string {
   return model.schema ? `${model.schema}.${model.tableName}` : model.tableName;
+}
+
+/** The view name to create, qualified only when the view declared a schema. */
+export function qualifiedViewName(view: PushView): string {
+  return view.schema ? `${view.schema}.${view.viewName}` : view.viewName;
 }

package/generator/src/python-generator.ts

@@ -105,27 +105,28 @@ export class PythonGenerator {
       }
       content += '\n';
 
-      // CreateInput
-      const requiredFields = model.fields.filter(f => !f.isId && !f.isOptional && !f.hasDefault);
-      const optionalFields = model.fields.filter(f => !f.isId && (f.isOptional || f.hasDefault));
-      content += `@dataclass\nclass ${name}CreateInput:\n    """Typed data for creating a new ${name} record."""\n`;
-      for (const f of requiredFields) {
-        content += `    ${this.toSnakeCase(f.name)}: ${this.mapPyType(f)}\n`;
-      }
-      for (const f of optionalFields) {
-        content += `    ${this.toSnakeCase(f.name)}: Optional[${this.mapPyType(f)}] = None\n`;
-      }
-      if (requiredFields.length === 0 && optionalFields.length === 0) content += '    pass\n';
-      content += '\n';
+      // CreateInput / UpdateInput describe writes; a view has none.
+      if (!model.isView) {
+        const requiredFields = model.fields.filter(f => !f.isId && !f.isOptional && !f.hasDefault);
+        const optionalFields = model.fields.filter(f => !f.isId && (f.isOptional || f.hasDefault));
+        content += `@dataclass\nclass ${name}CreateInput:\n    """Typed data for creating a new ${name} record."""\n`;
+        for (const f of requiredFields) {
+          content += `    ${this.toSnakeCase(f.name)}: ${this.mapPyType(f)}\n`;
+        }
+        for (const f of optionalFields) {
+          content += `    ${this.toSnakeCase(f.name)}: Optional[${this.mapPyType(f)}] = None\n`;
+        }
+        if (requiredFields.length === 0 && optionalFields.length === 0) content += '    pass\n';
+        content += '\n';
 
-      // UpdateInput
-      const updateFields = model.fields.filter(f => !f.isId);
-      content += `@dataclass\nclass ${name}UpdateInput:\n    """Typed data for updating an existing ${name} record."""\n`;
-      for (const f of updateFields) {
-        content += `    ${this.toSnakeCase(f.name)}: Optional[${this.mapPyType(f)}] = None\n`;
+        const updateFields = model.fields.filter(f => !f.isId);
+        content += `@dataclass\nclass ${name}UpdateInput:\n    """Typed data for updating an existing ${name} record."""\n`;
+        for (const f of updateFields) {
+          content += `    ${this.toSnakeCase(f.name)}: Optional[${this.mapPyType(f)}] = None\n`;
+        }
+        if (updateFields.length === 0) content += '    pass\n';
+        content += '\n';
       }
-      if (updateFields.length === 0) content += '    pass\n';
-      content += '\n';
 
       // FindManyArgs
       content += `@dataclass\nclass ${name}FindManyArgs:\n    """ORM-style args for ${name}.find_many()."""\n`;
@@ -328,6 +329,7 @@ export class PythonGenerator {
   }
 
   private generateClient(models: Model[], outputDir: string) {
+    const hasViews = models.some((model) => model.isView);
     let content = '# This file is auto-generated. Do not edit directly.\n';
     content += 'import os\n';
     content += 'from typing import Dict, List, Optional, Any, Callable, TYPE_CHECKING\n\n';
@@ -337,7 +339,7 @@ export class PythonGenerator {
     // generated output dir, so no relative-import fallback here — a
     // relative fallback would be unresolvable and trip Pylance
     // `reportMissingImports` on every generated client.
-    content += 'from an5_adapter import An5Adapter, AdapterTableClient, create_an5_adapter, set_adapter_metadata\n\n';
+    content += `from an5_adapter import An5Adapter, AdapterTableClient${hasViews ? ', ViewClient' : ''}, create_an5_adapter, set_adapter_metadata\n\n`;
 
     const metadataModule = this.metadataModule();
     content += 'try:\n';
@@ -376,6 +378,17 @@ export class PythonGenerator {
     for (const model of models) {
       const propName = this.toSnakeCase(model.name) + 's';
       const singleName = this.toSnakeCase(model.name);
+      if (model.isView) {
+        // The adapter's ViewClient refuses writes; assigning it here is what makes
+        // `db.activeUsers.update(...)` fail with the read-only message instead of
+        // reaching the database as a table write.
+        content += `        client = self.adapter.view("${model.name}")\n`;
+        content += `        self.${model.name}: ViewClient = client\n`;
+        content += `        self.${model.name}s: ViewClient = client\n`;
+        content += `        self.${singleName}: ViewClient = client\n`;
+        content += `        self.${propName}: ViewClient = client\n`;
+        continue;
+      }
       content += `        client = AdapterTableClient(self.adapter, "${model.name}")\n`;
       content += `        self.${model.name}: AdapterTableClient["${model.name}Row"] = client\n`;
       content += `        self.${model.name}s: AdapterTableClient["${model.name}Row"] = client\n`;

package/generator/src/rust-generator.ts

@@ -441,34 +441,37 @@ pub struct DateTimeFilter {
       }
       s.push(`}\n`);
 
-      // CreateInput (skip @id auto fields from required set via hasDefault)
-      s.push(`/// Typed data for creating a new ${name} record.`);
-      s.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`);
-      s.push(`pub struct ${name}CreateInput {`);
-      for (const f of model.fields) {
-        if (f.isId && f.hasDefault) continue;
-        const snake = this.toSnakeCase(f.name);
-        const isOpt = f.isOptional || f.hasDefault;
-        const rsType = this.mapRustType(f, isOpt);
-        if (isOpt) {
+      // CreateInput / UpdateInput describe writes; a view has none.
+      if (!model.isView) {
+        // CreateInput (skip @id auto fields from required set via hasDefault)
+        s.push(`/// Typed data for creating a new ${name} record.`);
+        s.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`);
+        s.push(`pub struct ${name}CreateInput {`);
+        for (const f of model.fields) {
+          if (f.isId && f.hasDefault) continue;
+          const snake = this.toSnakeCase(f.name);
+          const isOpt = f.isOptional || f.hasDefault;
+          const rsType = this.mapRustType(f, isOpt);
+          if (isOpt) {
+            s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+          }
+          s.push(`    pub ${snake}: ${rsType},`);
+        }
+        s.push(`}\n`);
+
+        // UpdateInput (all non-id optional)
+        s.push(`/// Typed data for updating an existing ${name} record.`);
+        s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+        s.push(`pub struct ${name}UpdateInput {`);
+        for (const f of model.fields) {
+          if (f.isId) continue;
+          const snake = this.toSnakeCase(f.name);
+          const rsType = this.mapRustType(f, true);
           s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+          s.push(`    pub ${snake}: ${rsType},`);
         }
-        s.push(`    pub ${snake}: ${rsType},`);
-      }
-      s.push(`}\n`);
-
-      // UpdateInput (all non-id optional)
-      s.push(`/// Typed data for updating an existing ${name} record.`);
-      s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
-      s.push(`pub struct ${name}UpdateInput {`);
-      for (const f of model.fields) {
-        if (f.isId) continue;
-        const snake = this.toSnakeCase(f.name);
-        const rsType = this.mapRustType(f, true);
-        s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
-        s.push(`    pub ${snake}: ${rsType},`);
+        s.push(`}\n`);
       }
-      s.push(`}\n`);
 
       // FindManyArgs / FindFirstArgs / FindUniqueArgs / CountArgs
       s.push(`/// ORM-style args for ${name}.find_many().`);
@@ -518,14 +521,16 @@ pub struct DateTimeFilter {
       s.push(`}\n`);
 
       // UpdateArgs carries the typed input alongside the where clause.
-      s.push(`/// ORM-style args for ${name}.update().`);
-      s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
-      s.push(`pub struct ${name}UpdateArgs {`);
-      s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
-      s.push(`    pub where_: Option<${name}WhereInput>,`);
-      s.push(`    #[serde(default)]`);
-      s.push(`    pub data: ${name}UpdateInput,`);
-      s.push(`}\n`);
+      if (!model.isView) {
+        s.push(`/// ORM-style args for ${name}.update().`);
+        s.push(`#[derive(Debug, Clone, Default, Serialize, Deserialize)]`);
+        s.push(`pub struct ${name}UpdateArgs {`);
+        s.push(`    #[serde(default, skip_serializing_if = "Option::is_none")]`);
+        s.push(`    pub where_: Option<${name}WhereInput>,`);
+        s.push(`    #[serde(default)]`);
+        s.push(`    pub data: ${name}UpdateInput,`);
+        s.push(`}\n`);
+      }
     }
     return s.join('\n') + '\n';
   }
@@ -617,7 +622,7 @@ pub struct DateTimeFilter {
 
 use an5_adapters::{
     AdapterMetadata, An5Adapter, CountArgs, DeleteManyArgs, FindManyArgs, RowMap, TableClient,
-    UpdateArgs, VectorSearchArgs,
+    UpdateArgs, VectorSearchArgs${models.some((model) => model.isView) ? ', ViewClient' : ''},
 };
 use serde::de::DeserializeOwned;
 
@@ -805,6 +810,11 @@ impl SqlBuilder {
   private buildModelRuntimeHandle(model: Model): string {
     const name = this.capitalize(model.name);
     const snake = this.toSnakeCase(model.name);
+    // A view is read through the runtime's read-only ViewClient, so the handle
+    // for a view cannot expose write methods at all.
+    const reader = model.isView
+      ? `self.db.adapter().view("${model.name}")`
+      : `self.db.table("${model.name}")`;
     const lines: string[] = [];
 
     lines.push(`/// Typed queries for ${name}. Obtained via \`An5Client::${snake}()\`.`);
@@ -825,9 +835,7 @@ impl SqlBuilder {
     lines.push(`    pub fn adapter(&self) -> &An5Adapter { self.db.adapter() }`);
     lines.push(``);
     lines.push(`    pub async fn find_many(&self, args: &${name}FindManyArgs) -> Result<Vec<${name}>> {`);
-    lines.push(`        let rows = self`);
-    lines.push(`            .db`);
-    lines.push(`            .table("${model.name}")`);
+    lines.push(`        let rows = ${reader}`);
     lines.push(`            .find_many(&FindManyArgs {`);
     lines.push(`                r#where: to_value(&args.where_)?,`);
     lines.push(`                order_by: to_value(&args.order_by)?,`);
@@ -842,9 +850,7 @@ impl SqlBuilder {
     lines.push(``);
     lines.push(`    /// The rows nearest \`vector\`, each carrying a \`distance\`.`);
     lines.push(`    pub async fn vector_search(&self, args: &${name}VectorSearchArgs) -> Result<Vec<(${name}, f64)>> {`);
-    lines.push(`        let rows = self`);
-    lines.push(`            .db`);
-    lines.push(`            .table("${model.name}")`);
+    lines.push(`        let rows = ${reader}`);
     lines.push(`            .vector_search(&VectorSearchArgs {`);
     lines.push(`                vector: args.vector.iter().map(|v| *v as f64).collect(),`);
     lines.push(`                take: args.take.unwrap_or(0),`);
@@ -862,9 +868,7 @@ impl SqlBuilder {
     lines.push(`    }`);
     lines.push(``);
     lines.push(`    pub async fn find_first(&self, args: &${name}FindFirstArgs) -> Result<Option<${name}>> {`);
-    lines.push(`        let row = self`);
-    lines.push(`            .db`);
-    lines.push(`            .table("${model.name}")`);
+    lines.push(`        let row = ${reader}`);
     lines.push(`            .find_first(&FindManyArgs {`);
     lines.push(`                r#where: to_value(&args.where_)?,`);
     lines.push(`                order_by: to_value(&args.order_by)?,`);
@@ -878,9 +882,7 @@ impl SqlBuilder {
     lines.push(`    }`);
     lines.push(``);
     lines.push(`    pub async fn find_unique(&self, args: &${name}FindUniqueArgs) -> Result<Option<${name}>> {`);
-    lines.push(`        let row = self`);
-    lines.push(`            .db`);
-    lines.push(`            .table("${model.name}")`);
+    lines.push(`        let row = ${reader}`);
     lines.push(`            .find_unique(&FindManyArgs {`);
     lines.push(`                r#where: to_value(&args.where_)?,`);
     lines.push(`                ..Default::default()`);
@@ -893,37 +895,41 @@ impl SqlBuilder {
     lines.push(`    }`);
     lines.push(``);
     lines.push(`    pub async fn count(&self, args: &${name}FindUniqueArgs) -> Result<i64> {`);
-    lines.push(`        self.db`);
-    lines.push(`            .table("${model.name}")`);
+    lines.push(`        ${reader}`);
     lines.push(`            .count(&CountArgs { r#where: to_value(&args.where_)? })`);
     lines.push(`            .await`);
     lines.push(`    }`);
     lines.push(``);
-    lines.push(`    pub async fn create(&self, data: &${name}CreateInput) -> Result<${name}> {`);
-    lines.push(`        let row = self`);
-    lines.push(`            .db`);
-    lines.push(`            .table("${model.name}")`);
-    lines.push(`            .create(&to_map(data)?)`);
-    lines.push(`            .await?;`);
-    lines.push(`        deserialize_row(row)`);
-    lines.push(`    }`);
-    lines.push(``);
-    lines.push(`    pub async fn update(&self, args: &${name}UpdateArgs) -> Result<u64> {`);
-    lines.push(`        self.db`);
-    lines.push(`            .table("${model.name}")`);
-    lines.push(`            .update(&UpdateArgs {`);
-    lines.push(`                r#where: to_value(&args.where_)?,`);
-    lines.push(`                data: serde_json::to_value(&args.data)?,`);
-    lines.push(`            })`);
-    lines.push(`            .await`);
-    lines.push(`    }`);
-    lines.push(``);
-    lines.push(`    pub async fn delete(&self, args: &${name}FindUniqueArgs) -> Result<u64> {`);
-    lines.push(`        self.db`);
-    lines.push(`            .table("${model.name}")`);
-    lines.push(`            .delete_many(&DeleteManyArgs { r#where: to_value(&args.where_)? })`);
-    lines.push(`            .await`);
-    lines.push(`    }`);
+
+    // Writes are generated for tables only: a view has no CreateInput or
+    // UpdateInput, so these methods could not be called even if emitted.
+    if (!model.isView) {
+      lines.push(`    pub async fn create(&self, data: &${name}CreateInput) -> Result<${name}> {`);
+      lines.push(`        let row = self`);
+      lines.push(`            .db`);
+      lines.push(`            .table("${model.name}")`);
+      lines.push(`            .create(&to_map(data)?)`);
+      lines.push(`            .await?;`);
+      lines.push(`        deserialize_row(row)`);
+      lines.push(`    }`);
+      lines.push(``);
+      lines.push(`    pub async fn update(&self, args: &${name}UpdateArgs) -> Result<u64> {`);
+      lines.push(`        self.db`);
+      lines.push(`            .table("${model.name}")`);
+      lines.push(`            .update(&UpdateArgs {`);
+      lines.push(`                r#where: to_value(&args.where_)?,`);
+      lines.push(`                data: serde_json::to_value(&args.data)?,`);
+      lines.push(`            })`);
+      lines.push(`            .await`);
+      lines.push(`    }`);
+      lines.push(``);
+      lines.push(`    pub async fn delete(&self, args: &${name}FindUniqueArgs) -> Result<u64> {`);
+      lines.push(`        self.db`);
+      lines.push(`            .table("${model.name}")`);
+      lines.push(`            .delete_many(&DeleteManyArgs { r#where: to_value(&args.where_)? })`);
+      lines.push(`            .await`);
+      lines.push(`    }`);
+    }
     lines.push(`}`);
     lines.push(``);
     return lines.join('\n') + '\n';