@an5/orm 1.3.2 → 1.3.4

package/dist/generator/src/dotnet-generator.js

@@ -133,26 +133,27 @@ namespace An5Orm
                 content += `        public string ${this.capitalize(f.name)} { get; set; } // "asc" or "desc"\n`;
             }
             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`;
             content += `    public class ${name}FindManyArgs\n    {\n`;
@@ -175,10 +176,12 @@ namespace An5Orm
             content += `        public ${name}WhereInput Where { get; set; }\n`;
             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`;
             content += `    public class ${name}CountArgs\n    {\n`;
@@ -477,8 +480,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, "${(0, types_1.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, "${(0, types_1.dottedTableName)(model)}");\n`;
+            content += `        public ${client}<${model.name}> ${name} => ${name}s;\n`;
         }
         content += `    }
 
@@ -1172,6 +1176,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);
+    }
 }
 `;
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'An5DbContext.cs'), content);

package/dist/generator/src/golang-generator.d.ts

@@ -22,6 +22,14 @@ export declare class GolangGenerator {
     private generateBaseOrmTypes;
     private generateDbContext;
     private generateTableClientStruct;
+    /**
+     * 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;
     private generateQueryAndScan;
     /**
      * The vector codec the generated client needs on both sides of a query.

package/dist/generator/src/golang-generator.js

@@ -182,6 +182,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();
@@ -311,8 +312,9 @@ func SortOrderPtr(s SortOrder) *SortOrder { return &s }
         let content = `// An5DbContext represents the main ORM database context.\ntype An5DbContext struct {\n\tDB      *sql.DB\n\tDialect Dialect\n`;
         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 += `}
 
@@ -328,7 +330,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, "${(0, types_1.dottedTableName)(model)}", d)\n`;
+            const client = model.isView ? 'NewViewClient' : 'NewTableClient';
+            content += `\tclient${name} := ${client}[${model.name}](db, "${(0, types_1.dottedTableName)(model)}", d)\n`;
             content += `\tctx.${name}s = client${name}\n`;
             content += `\tctx.${name}  = client${name}\n`;
         }
@@ -380,6 +383,65 @@ 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.
+     */
+    generateViewClientStruct() {
+        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...)
+}
+
 `;
     }
     // ─── queryAndScan ──────────────────────────────────────────────────────────
@@ -1309,24 +1371,25 @@ var _ = time.Time{}
             content += `\t${this.capitalize(field.name)} *SortOrder\n`;
         }
         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`;
         content += `\tWhere   *${name}WhereInput\n`;
@@ -1346,9 +1409,11 @@ var _ = time.Time{}
         content += `\tWhere *${name}WhereInput\n`;
         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`;
         content += `\tWhere *${name}WhereInput\n`;

package/dist/generator/src/java-generator.d.ts

@@ -51,6 +51,14 @@ export declare class JavaGenerator {
     private generateMetadata;
     private generateConfig;
     private modelClientSource;
+    /**
+     * 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;
     private generateDbContext;
     private tableName;
 }

package/dist/generator/src/java-generator.js

@@ -1224,10 +1224,105 @@ public final class ModelClient<T> {
     return value instanceof Number ? ((Number) value).intValue() : 0;
   }
 }
+`;
+    }
+    /**
+     * 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.
+     */
+    viewClientSource() {
+        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);
+  }
+}
 `;
     }
     generateDbContext(models) {
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'ModelClient.java'), this.modelClientSource());
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'ViewClient.java'), this.viewClientSource());
         let content = `// This file is auto-generated. Do not edit directly.
 package an5.client;
 
@@ -1259,7 +1354,7 @@ public class An5DbContext implements AutoCloseable {
             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 += `
   /** Opens a context, registering this schema with the adapter. */
@@ -1273,6 +1368,11 @@ public class An5DbContext implements AutoCloseable {
             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`;
         }
@@ -1289,6 +1389,11 @@ public class An5DbContext implements AutoCloseable {
             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`;
         }
@@ -1312,8 +1417,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/dist/generator/src/kotlin-generator.js

@@ -663,6 +663,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.
  *
@@ -687,6 +728,16 @@ class An5Db internal constructor(private val an5: An5) : AutoCloseable {
             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}> =

package/dist/generator/src/parser.d.ts

@@ -13,6 +13,7 @@ export declare class SchemaParser {
     private schemaText;
     private issues;
     private modelRefs;
+    private viewRefs;
     private models;
     /**
      * @param schemaDir directory holding the `.an5` files