@an5/orm 1.3.2 → 1.3.3

package/generator/src/dotnet-generator.ts

@@ -143,27 +143,28 @@ namespace An5Orm
       }
       content += `    }\n\n`;
 
-      // CreateInput
-      content += `    /// <summary>Typed data for creating a new ${name} record.</summary>\n`;
-      content += `    public class ${name}CreateInput\n    {\n`;
-      for (const f of model.fields) {
-        if (!f.isId) {
-          const ct = this.mapType(f, f.isOptional || f.hasDefault);
-          content += `        public ${ct} ${this.capitalize(f.name)} { get; set; }\n`;
+      // Create / update / delete inputs describe writes; a view has none.
+      if (!model.isView) {
+        content += `    /// <summary>Typed data for creating a new ${name} record.</summary>\n`;
+        content += `    public class ${name}CreateInput\n    {\n`;
+        for (const f of model.fields) {
+          if (!f.isId) {
+            const ct = this.mapType(f, f.isOptional || f.hasDefault);
+            content += `        public ${ct} ${this.capitalize(f.name)} { get; set; }\n`;
+          }
         }
-      }
-      content += `    }\n\n`;
-
-      // UpdateInput
-      content += `    /// <summary>Typed data for updating an existing ${name} record.</summary>\n`;
-      content += `    public class ${name}UpdateInput\n    {\n`;
-      for (const f of model.fields) {
-        if (!f.isId) {
-          const ut = this.mapType(f, true); // always nullable for update
-          content += `        public ${ut} ${this.capitalize(f.name)} { get; set; }\n`;
+        content += `    }\n\n`;
+
+        content += `    /// <summary>Typed data for updating an existing ${name} record.</summary>\n`;
+        content += `    public class ${name}UpdateInput\n    {\n`;
+        for (const f of model.fields) {
+          if (!f.isId) {
+            const ut = this.mapType(f, true); // always nullable for update
+            content += `        public ${ut} ${this.capitalize(f.name)} { get; set; }\n`;
+          }
         }
+        content += `    }\n\n`;
       }
-      content += `    }\n\n`;
 
       // FindManyArgs
       content += `    /// <summary>ORM-style args for ${name}.FindMany().</summary>\n`;
@@ -190,10 +191,12 @@ namespace An5Orm
       content += `    }\n\n`;
 
       // DeleteManyArgs
-      content += `    /// <summary>ORM-style args for ${name}.DeleteMany().</summary>\n`;
-      content += `    public class ${name}DeleteManyArgs\n    {\n`;
-      content += `        public ${name}WhereInput Where { get; set; }\n`;
-      content += `    }\n\n`;
+      if (!model.isView) {
+        content += `    /// <summary>ORM-style args for ${name}.DeleteMany().</summary>\n`;
+        content += `    public class ${name}DeleteManyArgs\n    {\n`;
+        content += `        public ${name}WhereInput Where { get; set; }\n`;
+        content += `    }\n\n`;
+      }
 
       // CountArgs
       content += `    /// <summary>ORM-style args for ${name}.Count().</summary>\n`;
@@ -494,8 +497,9 @@ namespace An5Orm
 
     for (const model of models) {
       const name = this.capitalize(model.name);
-      content += `        public TableClient<${model.name}> ${name}s => new TableClient<${model.name}>(ConnectionString, "${dottedTableName(model)}");\n`;
-      content += `        public TableClient<${model.name}> ${name} => ${name}s;\n`;
+      const client = model.isView ? 'ViewClient' : 'TableClient';
+      content += `        public ${client}<${model.name}> ${name}s => new ${client}<${model.name}>(ConnectionString, "${dottedTableName(model)}");\n`;
+      content += `        public ${client}<${model.name}> ${name} => ${name}s;\n`;
     }
 
     content += `    }
@@ -1190,6 +1194,46 @@ namespace An5Orm
             return false;
         }
     }
+
+    /// <summary>
+    /// Read-only client for a database view.
+    ///
+    /// It exposes the same read methods as <see cref="TableClient{T}"/> and no
+    /// write methods, so attempting to write a view fails at compile time rather
+    /// than in the database. The view's rows still map onto the generated entity
+    /// class, which is why the queries delegate instead of being duplicated.
+    /// </summary>
+    public class ViewClient<T> where T : new()
+    {
+        private readonly TableClient<T> _table;
+
+        public ViewClient(string connectionString, string viewName)
+        {
+            _table = new TableClient<T>(connectionString, viewName);
+        }
+
+        public string ConnectionString => _table.ConnectionString;
+        public string ViewName => _table.TableName;
+        public An5Dialect Dialect => _table.Dialect;
+
+        public List<T> QueryRaw(string query, Dictionary<string, object> parameters = null)
+            => _table.QueryRaw(query, parameters);
+
+        public List<T> FindMany(string whereClause = null, Dictionary<string, object> parameters = null)
+            => _table.FindMany(whereClause, parameters);
+
+        public T FindFirst(string whereClause = null, Dictionary<string, object> parameters = null)
+            => _table.FindFirst(whereClause, parameters);
+
+        public T FindUnique(object id)
+            => _table.FindUnique(id);
+
+        public int Count(string whereClause = null, Dictionary<string, object> parameters = null)
+            => _table.Count(whereClause, parameters);
+
+        public List<T> VectorSearch(List<double> vector, int take = 10, string whereClause = null, Dictionary<string, object> parameters = null, string vectorField = "Embedding", string distanceMetric = "cosine")
+            => _table.VectorSearch(vector, take, whereClause, parameters, vectorField, distanceMetric);
+    }
 }
 `;
 

package/generator/src/golang-generator.ts

@@ -185,6 +185,7 @@ func GetDefaultConnectionString() string {
     content += this.generateBaseOrmTypes();
     content += this.generateDbContext(models);
     content += this.generateTableClientStruct();
+    content += this.generateViewClientStruct();
     content += this.generateQueryAndScan();
     content += this.generateWhereBuilder();
     content += this.generateCrudMethods();
@@ -321,8 +322,9 @@ func SortOrderPtr(s SortOrder) *SortOrder { return &s }
 
     for (const model of models) {
       const name = this.capitalize(model.name);
-      content += `\t${name}s *TableClient[${model.name}]\n`;
-      content += `\t${name}  *TableClient[${model.name}]\n`;
+      const client = model.isView ? 'ViewClient' : 'TableClient';
+      content += `\t${name}s *${client}[${model.name}]\n`;
+      content += `\t${name}  *${client}[${model.name}]\n`;
     }
 
     content += `}
@@ -339,7 +341,8 @@ func NewAn5DbContextWithConnStr(db *sql.DB, connStr string) *An5DbContext {
 `;
     for (const model of models) {
       const name = this.capitalize(model.name);
-      content += `\tclient${name} := NewTableClient[${model.name}](db, "${dottedTableName(model)}", d)\n`;
+      const client = model.isView ? 'NewViewClient' : 'NewTableClient';
+      content += `\tclient${name} := ${client}[${model.name}](db, "${dottedTableName(model)}", d)\n`;
       content += `\tctx.${name}s = client${name}\n`;
       content += `\tctx.${name}  = client${name}\n`;
     }
@@ -394,6 +397,67 @@ func (c *TableClient[T]) ph(n int) string {
 \treturn "?"
 }
 
+`;
+  }
+
+  // ─── ViewClient ────────────────────────────────────────────────────────────
+
+  /**
+   * The read-only client used for views.
+   *
+   * Go has no way to hide methods from an embedded value, so wrapping rather
+   * than embedding is what makes a write to a view a compile error. The read
+   * methods delegate, which keeps a view's rows scanning exactly like a table's.
+   */
+  private generateViewClientStruct(): string {
+    return `// ViewClient provides read-only access to a database view.
+type ViewClient[T any] struct {
+\tDB       *sql.DB
+\tDialect  Dialect
+\tViewName string
+\ttable    *TableClient[T]
+}
+
+// NewViewClient creates a typed read-only client for a view.
+func NewViewClient[T any](db *sql.DB, viewName string, dialect Dialect) *ViewClient[T] {
+\treturn &ViewClient[T]{
+\t\tDB:       db,
+\t\tDialect:  dialect,
+\t\tViewName: viewName,
+\t\ttable:    NewTableClient[T](db, viewName, dialect),
+\t}
+}
+
+// FindMany queries the view with ORM-style args.
+func (c *ViewClient[T]) FindMany(ctx context.Context, args interface{}) ([]T, error) {
+\treturn c.table.FindMany(ctx, args)
+}
+
+// FindFirst returns the first matching row of the view.
+func (c *ViewClient[T]) FindFirst(ctx context.Context, args interface{}) (*T, error) {
+\treturn c.table.FindFirst(ctx, args)
+}
+
+// FindUnique returns one row of the view by primary key.
+func (c *ViewClient[T]) FindUnique(ctx context.Context, args interface{}) (*T, error) {
+\treturn c.table.FindUnique(ctx, args)
+}
+
+// Count returns how many rows of the view match.
+func (c *ViewClient[T]) Count(ctx context.Context, args interface{}) (int64, error) {
+\treturn c.table.Count(ctx, args)
+}
+
+// QueryRaw runs a raw SELECT against the view.
+func (c *ViewClient[T]) QueryRaw(ctx context.Context, query string, args ...interface{}) ([]T, error) {
+\treturn c.table.QueryRaw(ctx, query, args...)
+}
+
+// VectorSearch searches a vector column of the view.
+func (c *ViewClient[T]) VectorSearch(ctx context.Context, vector []float64, opts ...VectorSearchOptions) ([]T, error) {
+\treturn c.table.VectorSearch(ctx, vector, opts...)
+}
+
 `;
   }
 
@@ -1339,25 +1403,26 @@ var _ = time.Time{}
     }
     content += `}\n\n`;
 
-    // CreateInput
-    content += `// ${name}CreateInput holds data for creating a new ${name} record.\ntype ${name}CreateInput struct {\n`;
-    for (const field of model.fields) {
-      if (!field.isId) {
-        const goType = this.mapGoType(field, field.isOptional || field.hasDefault);
-        content += `\t${this.capitalize(field.name)} ${goType}\n`;
+    // CreateInput / UpdateInput / DeleteManyArgs describe writes; a view has none.
+    if (!model.isView) {
+      content += `// ${name}CreateInput holds data for creating a new ${name} record.\ntype ${name}CreateInput struct {\n`;
+      for (const field of model.fields) {
+        if (!field.isId) {
+          const goType = this.mapGoType(field, field.isOptional || field.hasDefault);
+          content += `\t${this.capitalize(field.name)} ${goType}\n`;
+        }
       }
-    }
-    content += `}\n\n`;
-
-    // UpdateInput
-    content += `// ${name}UpdateInput holds data for updating an existing ${name} record.\ntype ${name}UpdateInput struct {\n`;
-    for (const field of model.fields) {
-      if (!field.isId) {
-        const goType = this.mapGoType(field, true); // always pointer so we can detect zero
-        content += `\t${this.capitalize(field.name)} ${goType}\n`;
+      content += `}\n\n`;
+
+      content += `// ${name}UpdateInput holds data for updating an existing ${name} record.\ntype ${name}UpdateInput struct {\n`;
+      for (const field of model.fields) {
+        if (!field.isId) {
+          const goType = this.mapGoType(field, true); // always pointer so we can detect zero
+          content += `\t${this.capitalize(field.name)} ${goType}\n`;
+        }
       }
+      content += `}\n\n`;
     }
-    content += `}\n\n`;
 
     // FindManyArgs
     content += `// ${name}FindManyArgs provides ORM-style args for FindMany queries on ${name}.\ntype ${name}FindManyArgs struct {\n`;
@@ -1381,9 +1446,11 @@ var _ = time.Time{}
     content += `}\n\n`;
 
     // DeleteManyArgs
-    content += `// ${name}DeleteManyArgs provides ORM-style args for DeleteMany queries on ${name}.\ntype ${name}DeleteManyArgs struct {\n`;
-    content += `\tWhere *${name}WhereInput\n`;
-    content += `}\n\n`;
+    if (!model.isView) {
+      content += `// ${name}DeleteManyArgs provides ORM-style args for DeleteMany queries on ${name}.\ntype ${name}DeleteManyArgs struct {\n`;
+      content += `\tWhere *${name}WhereInput\n`;
+      content += `}\n\n`;
+    }
 
     // CountArgs
     content += `// ${name}CountArgs provides ORM-style args for Count queries on ${name}.\ntype ${name}CountArgs struct {\n`;

package/generator/src/java-generator.ts

@@ -1266,8 +1266,104 @@ public final class ModelClient<T> {
   }
 
 
+  /**
+   * The typed client used for views.
+   *
+   * <p>It repeats {@link ModelClient}'s read signatures and stops there: with no
+   * {@code create}/{@code update}/{@code delete} to call, writing a view is a
+   * compile error rather than a runtime refusal.
+   */
+  private viewClientSource(): string {
+    return `// This file is auto-generated. Do not edit directly.
+package an5.client;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import an5.adapters.An5Aggregate;
+import an5.adapters.An5GroupBy;
+import an5.adapters.An5Query;
+import an5.adapters.An5ViewClient;
+
+/** A read-only, typed client for one database view. */
+public final class ViewClient<T> {
+
+  private final An5ViewClient view;
+  private final Function<Map<String, Object>, T> fromRow;
+
+  ViewClient(An5ViewClient view, Function<Map<String, Object>, T> fromRow) {
+    this.view = view;
+    this.fromRow = fromRow;
+  }
+
+  /** The view name this client reads. */
+  public String view() {
+    return view.viewName();
+  }
+
+  public List<T> findMany() throws SQLException {
+    return findMany(new An5Query());
+  }
+
+  public List<T> findMany(An5Query query) throws SQLException {
+    return map(view.findMany(query));
+  }
+
+  public T findFirst(An5Query query) throws SQLException {
+    return one(view.findFirst(query));
+  }
+
+  public T findFirst(Map<String, Object> where) throws SQLException {
+    return one(view.findFirst(where));
+  }
+
+  public T findUnique(Map<String, Object> where) throws SQLException {
+    return one(view.findUnique(where));
+  }
+
+  public long count(Map<String, Object> where) throws SQLException {
+    return view.count(where);
+  }
+
+  public Map<String, Object> aggregate(An5Aggregate aggregate) throws SQLException {
+    return view.aggregate(aggregate);
+  }
+
+  public List<Map<String, Object>> groupBy(An5GroupBy group) throws SQLException {
+    return view.groupBy(group);
+  }
+
+  public List<T> vectorSearch(
+      double[] vector, Integer take, Map<String, Object> where, String vectorField, String metric)
+      throws SQLException {
+    return map(view.vectorSearch(vector, take, where, vectorField, metric));
+  }
+
+  public List<T> vectorSearch(double[] vector, Integer take) throws SQLException {
+    return vectorSearch(vector, take, null, "embedding", "cosine");
+  }
+
+  private List<T> map(List<Map<String, Object>> rows) {
+    List<T> mapped = new ArrayList<T>();
+    for (Map<String, Object> row : rows) {
+      mapped.add(fromRow.apply(row));
+    }
+    return mapped;
+  }
+
+  private T one(Map<String, Object> row) {
+    return row == null ? null : fromRow.apply(row);
+  }
+}
+`;
+  }
+
   private generateDbContext(models: Model[]): void {
     fs.writeFileSync(path.join(this.outputDir, 'ModelClient.java'), this.modelClientSource());
+    fs.writeFileSync(path.join(this.outputDir, 'ViewClient.java'), this.viewClientSource());
 
     let content = `// This file is auto-generated. Do not edit directly.
 package an5.client;
@@ -1299,7 +1395,7 @@ public class An5DbContext implements AutoCloseable {
       const property = this.propertyNames(model.name)[0]!;
       if (declared.has(property)) continue;
       declared.add(property);
-      content += `  private final ModelClient<${model.name}> ${property}Client;\n`;
+      content += `  private final ${model.isView ? 'ViewClient' : 'ModelClient'}<${model.name}> ${property}Client;\n`;
     }
 
     content += `
@@ -1314,6 +1410,11 @@ public class An5DbContext implements AutoCloseable {
       const property = this.propertyNames(model.name)[0]!;
       if (assigned.has(property)) continue;
       assigned.add(property);
+      if (model.isView) {
+        content += `    this.${property}Client = new ViewClient<${model.name}>(\n`;
+        content += `        adapter.view("${model.name}"), ${model.name}::fromRow);\n`;
+        continue;
+      }
       content += `    this.${property}Client = new ModelClient<${model.name}>(\n`;
       content += `        adapter.table("${model.name}"), ${model.name}::fromRow, ${model.name}::toValues);\n`;
     }
@@ -1331,6 +1432,11 @@ public class An5DbContext implements AutoCloseable {
       const property = this.propertyNames(model.name)[0]!;
       if (wrapped.has(property)) continue;
       wrapped.add(property);
+      if (model.isView) {
+        content += `    this.${property}Client = new ViewClient<${model.name}>(\n`;
+        content += `        adapter.view("${model.name}"), ${model.name}::fromRow);\n`;
+        continue;
+      }
       content += `    this.${property}Client = new ModelClient<${model.name}>(\n`;
       content += `        adapter.table("${model.name}"), ${model.name}::fromRow, ${model.name}::toValues);\n`;
     }
@@ -1355,8 +1461,8 @@ public class An5DbContext implements AutoCloseable {
       exposed.add(property);
       const accessor = `get${this.capitalize(property)}`;
       content += `
-  /** Queries for \`${model.name}\`. */
-  public ModelClient<${model.name}> ${accessor}() {
+  /** ${model.isView ? 'Reads' : 'Queries'} for \`${model.name}\`. */
+  public ${model.isView ? 'ViewClient' : 'ModelClient'}<${model.name}> ${accessor}() {
     return this.${property}Client;
   }
 `;

package/generator/src/kotlin-generator.ts

@@ -704,6 +704,47 @@ class ModelClient<T : Any>(
     ): List<T> = delegate.vectorSearch(vector, take, filter, vectorField, metric).map(read)
 }
 
+/**
+ * A read-only, typed client for one view.
+ *
+ * It mirrors [ModelClient]'s read methods and stops there, so a write to a view does
+ * not compile. The runtime's read-only client does the actual work.
+ */
+class ViewClient<T : Any>(
+    private val delegate: an5.adapters.ViewClient,
+    private val read: (Row) -> T,
+) {
+
+    /** The view this client reads. */
+    val name: String get() = delegate.name
+
+    fun findMany(): List<T> = delegate.findMany().map(read)
+
+    fun findMany(block: QueryBuilder.() -> Unit): List<T> = delegate.findMany(block).map(read)
+
+    fun findFirst(filter: Where): T? = delegate.findFirst(filter)?.let(read)
+
+    fun findUnique(filter: Where): T? = delegate.findUnique(filter)?.let(read)
+
+    fun count(filter: Where? = null): Long = delegate.count(filter)
+
+    /** One row of aggregate values, keyed \`_count\`, \`_sum_<field>\` and so on. */
+    fun aggregate(block: AggregateBuilder.() -> Unit): Row = delegate.aggregate(block)
+
+    /** One row per group, each carrying the group's count and aggregates. */
+    fun groupBy(vararg by: String, block: AggregateBuilder.() -> Unit = {}): List<Row> =
+        delegate.groupBy(*by, block = block)
+
+    /** The rows nearest [vector]. */
+    fun vectorSearch(
+        vector: DoubleArray,
+        take: Int = 10,
+        filter: Where? = null,
+        vectorField: String = "embedding",
+        metric: DistanceMetric = DistanceMetric.COSINE,
+    ): List<T> = delegate.vectorSearch(vector, take, filter, vectorField, metric).map(read)
+}
+
 /**
  * The AN5 entry point: one typed client per model, over one connection.
  *
@@ -728,6 +769,16 @@ class An5Db internal constructor(private val an5: An5) : AutoCloseable {
       const property = KotlinGenerator.toLowerCamelCase(model.name);
       if (seen.has(property)) continue;
       seen.add(property);
+      if (model.isView) {
+        content += `    /** Reads for \`${model.name}\`. */
+`;
+        content += `    val ${property}: ViewClient<${model.name}> =
+`;
+        content += `        ViewClient(an5.view("${model.name}"), ${model.name}::fromRow)
+
+`;
+        continue;
+      }
       content += `    /** Queries for \`${model.name}\`. */
 `;
       content += `    val ${property}: ModelClient<${model.name}> =