feat(runtime-ts): mount GET /_meta on fastify and hono

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015NrWUxA6euwvnFcwKxcK6A

Author: dmealing

server/typescript/packages/runtime-ts/src/fastify/index.ts

@@ -256,3 +256,43 @@ export function mountDeleteRoute(opts: SingleVerbOptions): void {
 // shared (deprecated) helper so the three adapters can't silently diverge.
 // The mounts above no longer use it: ObjectManager coerces ids per metadata.
 export { parseId } from "../drizzle-fastify/util.js";
+
+// ---------------------------------------------------------------------------
+// Metadata endpoint
+// ---------------------------------------------------------------------------
+
+import type { MetaData } from "@metaobjectsdev/metadata";
+import { META_ROUTE_PATH, metaJson } from "../meta-endpoint.js";
+
+export interface MetaRouteOptions {
+  fastify: FastifyInstance;
+  /** The loaded model root. */
+  root: MetaData;
+  /** Mounted under this prefix; defaults to "" (the bare `/_meta`). */
+  prefix?: string;
+}
+
+/**
+ * Mount `GET {prefix}/_meta`, serving the model as effective canonical JSON.
+ *
+ * Opt-in by design. `/_meta` publishes the SHAPE of the model — entity and field
+ * names, types, validators, layouts — though no row data. Guard it with your own
+ * middleware exactly as you would the generated routes (#367):
+ *
+ *     app.register(async (s) => {
+ *       s.addHook("preHandler", requireAuth);
+ *       mountMetaRoute({ fastify: s, root, prefix: "/api" });
+ *     });
+ *
+ * The body is serialized once per call. If that ever matters, cache it in the
+ * host — the model is immutable after load.
+ */
+export function mountMetaRoute(opts: MetaRouteOptions): void {
+  const path = `${opts.prefix ?? ""}${META_ROUTE_PATH}`;
+  opts.fastify.get(path, async (_req, reply) => {
+    return reply
+      .code(200)
+      .header("content-type", "application/json; charset=utf-8")
+      .send(metaJson(opts.root));
+  });
+}

server/typescript/packages/runtime-ts/src/hono/index.ts

@@ -320,3 +320,30 @@ function extractRowCount(result: unknown): number {
 }
 
 export { mountReadOnlyCrudRoutes, type MountReadOnlyOptions } from "./mount-read-only.js";
+
+// ---------------------------------------------------------------------------
+// Metadata endpoint
+// ---------------------------------------------------------------------------
+
+import type { MetaData } from "@metaobjectsdev/metadata";
+import { META_ROUTE_PATH, metaJson } from "../meta-endpoint.js";
+
+export interface HonoMetaRouteOptions {
+  app: AnyHono;
+  root: MetaData;
+  prefix?: string;
+}
+
+/**
+ * Mount `GET {prefix}/_meta` on Hono. Same contract and same opt-in caveat as
+ * the Fastify twin; guard the mount path with middleware before calling this:
+ *
+ *     app.use(`/api${META_ROUTE_PATH}`, requireAuth);
+ *     mountMetaRouteHono({ app, root, prefix: "/api" });
+ */
+export function mountMetaRouteHono(opts: HonoMetaRouteOptions): void {
+  const path = `${opts.prefix ?? ""}${META_ROUTE_PATH}`;
+  opts.app.get(path, (c) =>
+    c.body(metaJson(opts.root), 200, { "content-type": "application/json; charset=utf-8" }),
+  );
+}

server/typescript/packages/runtime-ts/test/meta-route.test.ts

@@ -0,0 +1,44 @@
+import { describe, test, expect } from "bun:test";
+import Fastify from "fastify";
+import { Hono } from "hono";
+import { metaJson } from "../src/meta-endpoint.js";
+import { mountMetaRoute } from "../src/fastify/index.js";
+import { mountMetaRouteHono } from "../src/hono/index.js";
+import { loadTestModel } from "./helpers/load-test-model.js";
+
+describe("GET /_meta (fastify)", () => {
+  test("serves the effective canonical JSON under the prefix", async () => {
+    const root = await loadTestModel();
+    const app = Fastify();
+    mountMetaRoute({ fastify: app, root, prefix: "/api" });
+    await app.ready();
+
+    const res = await app.inject({ method: "GET", url: "/api/_meta" });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.headers["content-type"]).toContain("application/json");
+    expect(res.body).toBe(metaJson(root));
+  });
+
+  test("mounts at the bare path when no prefix is given", async () => {
+    const root = await loadTestModel();
+    const app = Fastify();
+    mountMetaRoute({ fastify: app, root });
+    await app.ready();
+
+    expect((await app.inject({ method: "GET", url: "/_meta" })).statusCode).toBe(200);
+  });
+});
+
+describe("GET /_meta (hono)", () => {
+  test("serves the same bytes as the fastify mount", async () => {
+    const root = await loadTestModel();
+    const app = new Hono();
+    mountMetaRouteHono({ app, root, prefix: "/api" });
+
+    const res = await app.request("/api/_meta");
+
+    expect(res.status).toBe(200);
+    expect(await res.text()).toBe(metaJson(root));
+  });
+});