feat(codegen-ts): allow standalone read-only view-entities (no extends)

renderProjectionDecl only needed the view name from extractViewSpec, yet
extractViewSpec requires a base entity to extend (for join/DDL resolution).
That coupling forced every projection to extend a writable entity and inherit
ALL its fields — blocking views over non-entity-backed tables and views that
deliberately expose a narrowed/safe column set.

Decouple: derive the view name directly via the new projectionViewName() (reads
the read-only source @table), so the read model generates from the projection's
own fields. The join-backed view-DDL path (extractViewSpec) still requires
extends — standalone views hand-author (or separately generate) their SQL.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/codegen-ts/src/projection/extract-view-spec.ts

@@ -54,6 +54,23 @@ function viewName(projection: MetaObject, ctx: ExtractContext): string {
   return explicit ?? viewNameFromProjection(projection.name, ctx.columnNamingStrategy);
 }
 
+/**
+ * The physical view name for a projection — its read-only source `@table`, else
+ * derived from the projection name.
+ *
+ * Exposed for the read-model generator (`renderProjectionDecl`), which needs the
+ * view name but NOT the join/DDL resolution. Read-model generation works for a
+ * standalone read-only view-entity (explicit columns, no `extends`); only
+ * {@link extractViewSpec} — which generates the join-backed view DDL — requires a
+ * base entity to extend.
+ */
+export function projectionViewName(
+  projection: MetaObject,
+  columnNamingStrategy: ColumnNamingStrategy,
+): string {
+  return viewName(projection, { columnNamingStrategy });
+}
+
 function baseEntityFor(
   projection: MetaObject,
   root: MetaRoot,

server/typescript/packages/codegen-ts/src/templates/projection-decl.ts

@@ -9,7 +9,7 @@
 
 import { code, imp, joinCode, type Code } from "ts-poet";
 import { MetaField, MetaObject, type MetaRoot } from "@metaobjectsdev/metadata";
-import { extractViewSpec } from "../projection/extract-view-spec.js";
+import { projectionViewName } from "../projection/extract-view-spec.js";
 import { columnNameFromField, toSnakeCase, pluralize } from "../naming.js";
 import { GENERATED_HEADER } from "../constants.js";
 import type { ColumnNamingStrategy } from "../metaobjects-config.js";
@@ -72,7 +72,12 @@ export function renderProjectionDecl(
   const viewSym = imp(`${viewFn}@${viewModule}`);
   const z = imp("z@zod");
 
-  const spec = extractViewSpec(projection, root, { columnNamingStrategy });
+  // Read-model generation needs only the view name — NOT the join/DDL
+  // resolution. Deriving it directly (instead of via extractViewSpec) lets a
+  // standalone read-only view-entity — explicit columns, no `extends` — generate
+  // its read model. The join-backed view DDL (extractViewSpec) still requires a
+  // base; standalone views hand-author (or separately generate) their SQL.
+  const viewName = projectionViewName(projection, columnNamingStrategy);
 
   // Collect fields: inherited from extends parent first, then projection-declared.
   const allFields: MetaField[] = [];
@@ -107,7 +112,6 @@ export function renderProjectionDecl(
   const projName = projection.name;
   const camelName = projName.charAt(0).toLowerCase() + projName.slice(1);
   const path = pathFromProjectionName(projName);
-  const viewName = spec.viewName;
 
   const sections: Code[] = [
     code`

server/typescript/packages/codegen-ts/test/templates/projection-decl.test.ts

@@ -242,3 +242,64 @@ describe("renderProjectionDecl emits Drizzle view + Zod read schema + constants"
     expect(code).toContain("ProgramSummaryFilter");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Standalone read-only view-entity (NO `extends`).
+// The read model only needs the view name + the entity's own fields — not the
+// join/DDL resolution. A view whose base is not a writable metaobjects entity
+// (e.g. one over legacy tables), or one that maps a deliberately narrowed set of
+// columns (excluding a sensitive field), is authored as a standalone projection:
+// explicit columns + source.rdb kind=view, no extends. Its SQL is hand-authored.
+// ---------------------------------------------------------------------------
+async function loadStandaloneProjection() {
+  const json = JSON.stringify({
+    "metadata.root": {
+      package: "test",
+      children: [
+        {
+          "object.entity": {
+            name: "LobbyRoster",
+            children: [
+              { "source.rdb": { "@kind": "view", "@table": "v_lobby_roster" } },
+              { "field.string": { name: "sessionId" } },
+              { "field.string": { name: "displayName" } },
+              { "field.string": { name: "status" } },
+              { "identity.primary": { "@fields": "sessionId" } },
+              { "layout.dataGrid": { name: "default", "@fields": "displayName,status" } },
+            ],
+          },
+        },
+      ],
+    },
+  });
+  const result = await new MetaDataLoader().load([new InMemoryStringSource(json)]);
+  if (result.errors.length > 0) throw new Error(result.errors.map((e) => e.message).join("\n"));
+  const root = result.root;
+  const projection = root.objects().find((o) => o.name === "LobbyRoster")!;
+  return { root, projection };
+}
+
+describe("renderProjectionDecl — standalone view-entity (no extends)", () => {
+  test("generates the read model from own fields without throwing", async () => {
+    const { root, projection } = await loadStandaloneProjection();
+    const code = renderProjectionDecl(projection, root, {
+      columnNamingStrategy: "snake_case",
+      dialect: "postgres",
+    });
+
+    // View name comes from the read-only source @table (no join resolution).
+    expect(code).toContain("pgView");
+    expect(code).toContain('"v_lobby_roster"');
+    expect(code).toContain(".existing()");
+    // Own fields populate the schema + constants.
+    expect(code).toContain("export const LobbyRosterSchema");
+    expect(code).toContain("sessionId:");
+    expect(code).toContain("displayName:");
+    expect(code).toContain("status:");
+    expect(code).toContain('$entity: "LobbyRoster"');
+    expect(code).toContain('"/lobby-rosters"');
+    // Still read-only — no write artifacts.
+    expect(code).not.toContain("LobbyRosterInsert");
+    expect(code).not.toContain("LobbyRosterUpdate");
+  });
+});