create-nwire 0.9.1 → 0.10.0

package/README.md

@@ -15,11 +15,11 @@ yarn create nwire my-app --template service
 
 ## Templates
 
-| Name         | What you get                                                                                             |
-| ------------ | -------------------------------------------------------------------------------------------------------- |
-| `minimal`    | One POST route. `httpInterface` + `endpoint`. No app, no DI. ~30 LOC.                                    |
-| `service`    | Todo CRUD. Container, plugin lifecycle, structured errors, middleware, in-memory store.                  |
-| `enterprise` | Moderation queue. `createApp`, modules, actors, events, stateful workflow (saga), projection, resolvers. |
+| Name         | What you get                                                                                                |
+| ------------ | ----------------------------------------------------------------------------------------------------------- |
+| `minimal`    | One POST route. `createApp` + `httpKoa`. No DI, no forge. ~40 LOC.                                          |
+| `service`    | Todo CRUD. Container plugin, structured errors, route middleware, in-memory store.                          |
+| `enterprise` | Moderation queue. Forge: actions + events + actors + stateful workflow + projection, multi-app composable.  |
 
 Pick the smallest template that fits — graduating up is just re-scaffolding
 into a new folder and porting your code one file at a time.
@@ -29,9 +29,8 @@ deprecated synonyms for `minimal`, `service`, and `enterprise`.
 
 ## What ships with every template
 
-- **Zod-validated** route handlers, automatic OpenAPI at `/openapi.json`
-- **Graceful shutdown** via `@nwire/endpoint` (SIGTERM drain + lightship probes)
-- **K8s probes** on port 9000 (`/readyz`, `/healthz`)
+- **Zod-validated** route handlers, structured error envelopes
+- **Graceful shutdown** via `@nwire/endpoint` (SIGTERM drain + K8s probes)
 - **TypeScript strict** + Bundler module resolution for fast dev loops
 
 ## After scaffold

package/dist/index.d.ts

@@ -24,4 +24,3 @@ export declare function scaffold(opts: ScaffoldOptions): {
 export declare function resolveTemplateName(raw: string): TemplateName | null;
 export declare function runCli(): Promise<void>;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -184,4 +184,3 @@ const main = defineCommand({
 export async function runCli() {
     await runMain(main);
 }
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nwire",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Scaffolder for new Nwire projects. Run `pnpm create nwire <name>` or `npm create nwire <name>` to bootstrap.",
   "keywords": [
     "nwire",

package/templates/enterprise/__tests__/auto-moderate.test.ts

@@ -10,27 +10,19 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import http from "node:http";
-import type { Server } from "node:http";
-import { app } from "../app/app";
-import { api } from "../app/api";
+import { bootstrap } from "../app/main";
 
-let server: Server;
+let running: Awaited<ReturnType<typeof bootstrap>>;
 let url: string;
 
 beforeAll(async () => {
-  await app.start();
-  server = http.createServer(api.compile());
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const addr = server.address() as { port: number };
-  url = `http://127.0.0.1:${addr.port}`;
+  running = await bootstrap({ port: 0, test: true });
+  url = `http://127.0.0.1:${running.koa.port()}`;
 });
 
 afterAll(async () => {
-  await new Promise<void>((resolve, reject) =>
-    server.close((err) => (err ? reject(err) : resolve())),
-  );
-  await app.stop();
+  await running.running.shutdown("test");
+  await running.app.stop();
 });
 
 const idle = () => new Promise<void>((resolve) => setImmediate(resolve));

package/templates/enterprise/__tests__/submit-flow.test.ts

@@ -4,27 +4,19 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import http from "node:http";
-import type { Server } from "node:http";
-import { app } from "../app/app";
-import { api } from "../app/api";
+import { bootstrap } from "../app/main";
 
-let server: Server;
+let running: Awaited<ReturnType<typeof bootstrap>>;
 let url: string;
 
 beforeAll(async () => {
-  await app.start();
-  server = http.createServer(api.compile());
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const addr = server.address() as { port: number };
-  url = `http://127.0.0.1:${addr.port}`;
+  running = await bootstrap({ port: 0, test: true });
+  url = `http://127.0.0.1:${running.koa.port()}`;
 });
 
 afterAll(async () => {
-  await new Promise<void>((resolve, reject) =>
-    server.close((err) => (err ? reject(err) : resolve())),
-  );
-  await app.stop();
+  await running.running.shutdown("test");
+  await running.app.stop();
 });
 
 const idle = () => new Promise<void>((resolve) => setImmediate(resolve));

package/templates/enterprise/app/api.ts

@@ -1,28 +1,21 @@
 /**
- * HTTP interface — one `.wire(Route, Handler)` per operation.
+ * Wires — the surface this app exposes.
  *
- * The route + handler pairs all live in `modules/posts/routes/`. The
- * interface stays a 1-line-per-route reducer.
- *
- * `.provide(app.runtime.getContainer())` hands the forge runtime's
- * container to the http layer so handlers can `resolve()` from any
- * binding the runtime registered (e.g. dispatch, query, the runtime
- * itself for ad-hoc reads).
+ * Every route file under `../modules/posts/routes/` exports a
+ * `{name}Route` (binding) + `{name}Handler` (function). The `wires`
+ * array is what main.ts feeds into `app.wire(...)`.
  */
 
-import { httpInterface } from "@nwire/http";
-import { app } from "./app";
-
 import { submitPostRoute, submitPostHandler } from "../modules/posts/routes/submit-post";
 import { approvePostRoute, approvePostHandler } from "../modules/posts/routes/approve-post";
 import { rejectPostRoute, rejectPostHandler } from "../modules/posts/routes/reject-post";
 import { listQueueRoute, listQueueHandler } from "../modules/posts/routes/list-queue";
 import { getPostRoute, getPostHandler } from "../modules/posts/routes/get-post";
 
-export const api = httpInterface({ prefix: "/api" })
-  .provide(app.runtime.getContainer())
-  .wire(submitPostRoute, submitPostHandler)
-  .wire(approvePostRoute, approvePostHandler)
-  .wire(rejectPostRoute, rejectPostHandler)
-  .wire(listQueueRoute, listQueueHandler)
-  .wire(getPostRoute, getPostHandler);
+export const wires = [
+  { binding: submitPostRoute, handler: submitPostHandler },
+  { binding: approvePostRoute, handler: approvePostHandler },
+  { binding: rejectPostRoute, handler: rejectPostHandler },
+  { binding: listQueueRoute, handler: listQueueHandler },
+  { binding: getPostRoute, handler: getPostHandler },
+] as const;

package/templates/enterprise/app/app.ts

@@ -1,28 +1,44 @@
 /**
- * `createApp` composes the posts module into a runnable app.
+ * `buildApp` composes the posts bounded context into a runnable App.
  *
- * Why createApp at L4 (when L2 skipped it):
+ * 0.10 shape — no modules. Each piece (events, actions, workflows,
+ * projections, queries) is imported directly; createApp installs a
+ * forge plugin with the workflows/projections/queries it needs, and
+ * registers the handlers via the `handlers` array.
  *
- *   - We have a workflow that subscribes to events on the bus. The
- *     workflow needs the runtime to register its subscription and
- *     fire it on PostWasSubmitted. That's what `createApp` orchestrates.
+ * For multi-BC apps, build each as its own App and compose:
  *
- *   - We have a projection that folds events into state. Same story —
- *     the runtime registers the projection's reducers and calls them
- *     on every matching event.
- *
- *   - We have actions that emit events. The runtime persists those
- *     events through the implicit bus and routes them to all subscribers.
- *
- * One module, no plugins yet — but the moment we add a Postgres-backed
- * projection store, a Redis cache, OTel tracing, an audit log plugin,
- * they all attach here via `.use(plugin)`. The same `createApp` API
- * scales from one module to dozens.
+ *   const monolith = appCompose(postsApp, ordersApp);
+ *   await endpoint("monolith", { port: 3000 }).use(httpKoa()).mount(monolith).run();
  */
 
-import { createApp } from "@nwire/forge";
-import { postsModule } from "../modules/posts/posts.module";
+import { createApp } from "@nwire/app";
+import { createForgePlugin } from "@nwire/forge";
+
+import { submitPost } from "../modules/posts/actions/submit-post";
+import { approvePost } from "../modules/posts/actions/approve-post";
+import { rejectPost } from "../modules/posts/actions/reject-post";
+import { autoModerate } from "../modules/posts/workflows/auto-moderate";
+import {
+  queueDashboard,
+  listPending,
+  queueTotals,
+  getPost,
+} from "../modules/posts/projections/queue-dashboard";
+import { postsByAuthor } from "../modules/posts/queries/posts-by-author";
+
+export function buildApp() {
+  return createApp({
+    appName: "{{PROJECT_NAME}}",
+    plugins: [
+      createForgePlugin({
+        workflows: [autoModerate],
+        projections: [queueDashboard],
+        queries: [listPending, queueTotals, getPost, postsByAuthor],
+      }),
+    ],
+    handlers: [submitPost.handler!, approvePost.handler!, rejectPost.handler!],
+  });
+}
 
-export const app = createApp({
-  modules: [postsModule],
-});
+export const app = buildApp();

package/templates/enterprise/app/main.ts

@@ -1,23 +1,18 @@
 /**
- * Entry — boot the forge app and run the http interface under endpoint().
+ * Entry — boot the app under HTTP.
  *
- * The lifecycle:
- *
- *   1. `app` (./app.ts) is a configured-but-unbooted forge app — modules
- *      registered, workflow subscribers wired, projection reducers
- *      attached, but nothing's running yet.
- *   2. `app.start()` boots the runtime — workflows subscribe to the bus,
- *      projection state initializes, framework events fire.
- *   3. `api.inspect(app)` mounts the `/_nwire/*` introspection surface
- *      that Studio's Live + Trace pages consume.
- *   4. `endpoint().serve(api).run()` starts the HTTP listener + K8s probes.
+ *   1. buildApp registers handlers + forge plugin (workflows, projections,
+ *      queries) on the container.
+ *   2. app.wire(...) pairs every route binding with its handler.
+ *   3. endpoint().use(httpKoa({prefix:"/api"})).mount(app).run() starts
+ *      the HTTP listener + graceful drain + K8s probes.
  *
  * Once running:
- *   - HTTP `POST /api/posts` → submitPost action → PostWasSubmitted event
- *   - `autoModerate` workflow picks up the event, runs auto-check, dispatches
+ *   - HTTP POST /api/posts → submitPost action → PostWasSubmitted event
+ *   - autoModerate workflow picks up the event, runs auto-check, dispatches
  *     approve/reject if obvious
- *   - `queueDashboard` projection picks up ALL three events, updates state
- *   - HTTP `GET /api/queue` reads from the projection
+ *   - queueDashboard projection folds all three events into state
+ *   - HTTP GET /api/queue reads from the projection
  *
  * Run:    pnpm dev
  * Try:    curl -X POST http://localhost:3000/api/posts \
@@ -27,12 +22,36 @@
  */
 
 import { endpoint } from "@nwire/endpoint";
-import { app } from "./app";
-import { api } from "./api";
+import { httpKoa } from "@nwire/koa";
+import { buildApp } from "./app";
+import { wires } from "./api";
+
+export interface BootstrapOptions {
+  readonly port?: number;
+  readonly test?: boolean;
+}
 
-await app.start();
+export async function bootstrap(opts: number | BootstrapOptions = 3000) {
+  const { port = 3000, test = false } =
+    typeof opts === "number" ? { port: opts, test: false } : opts;
 
-// Off-by-default in production; opt in here so Studio's Live page works.
-api.inspect(app);
+  const app = buildApp();
+  for (const { binding, handler } of wires) {
+    app.wire(binding, handler);
+  }
+  await app.start();
+  const koa = httpKoa({ port, prefix: "/api" });
+  const running = await endpoint("{{PROJECT_NAME}}", {
+    exitOnShutdown: !test,
+    banner: !test,
+    probes: { enabled: !test },
+  })
+    .use(koa)
+    .mount(app)
+    .run();
+  return { app, running, koa };
+}
 
-await endpoint("{{PROJECT_NAME}}", { port: 3000 }).serve(api).run();
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await bootstrap();
+}

package/templates/enterprise/modules/posts/routes/approve-post.ts

@@ -1,14 +1,14 @@
 /**
  * POST /api/posts/:postId/approve — human moderator approves a post.
  *
- * Dispatches the SAME action that the auto-moderate workflow dispatches
- * — that reuse is exactly why approvePost lives in `actions/` and not
+ * Dispatches the SAME action that the auto-moderate workflow dispatches —
+ * that reuse is exactly why approvePost lives in `actions/` and not
  * inline in the route handler.
  */
 
-import { post, type HttpHandler } from "@nwire/http";
+import { post } from "@nwire/wires/http";
+import type { ForgeDispatcher } from "@nwire/forge";
 import { z } from "zod";
-import { app } from "../../../app/app";
 import { approvePost } from "../actions/approve-post";
 
 const Params = z.object({ postId: z.string() });
@@ -17,8 +17,12 @@ type Input = z.infer<typeof Params> & z.infer<typeof Body>;
 
 export const approvePostRoute = post("/posts/:postId/approve", { params: Params, body: Body });
 
-export const approvePostHandler: HttpHandler<Input> = async ({ input }) => {
-  await app.runtime.dispatch(approvePost, {
+export const approvePostHandler = async (
+  input: Input,
+  ctx: { resolve: <T>(name: string) => T },
+) => {
+  const dispatcher = ctx.resolve<ForgeDispatcher>("forge.dispatcher");
+  await dispatcher.dispatch(approvePost, {
     postId: input.postId,
     approvedBy: input.moderatorId,
   });

package/templates/enterprise/modules/posts/routes/get-post.ts

@@ -5,16 +5,20 @@
  * dashboard (never submitted, or projection state was reset).
  */
 
-import { get, type HttpHandler } from "@nwire/http";
+import { get } from "@nwire/wires/http";
+import type { ForgeDispatcher } from "@nwire/forge";
 import { z } from "zod";
-import { app } from "../../../app/app";
 
 const Params = z.object({ postId: z.string() });
 
 export const getPostRoute = get("/posts/:postId", { params: Params });
 
-export const getPostHandler: HttpHandler<z.infer<typeof Params>> = async ({ input }) => {
-  const post = await app.runtime.query("posts.get-post", input);
+export const getPostHandler = async (
+  input: z.infer<typeof Params>,
+  ctx: { resolve: <T>(name: string) => T },
+) => {
+  const dispatcher = ctx.resolve<ForgeDispatcher>("forge.dispatcher");
+  const post = await dispatcher.query("posts.get-post", input);
   if (!post) return { $status: 404, body: { error: { code: "POST_NOT_FOUND" } } };
   return post;
 };

package/templates/enterprise/modules/posts/routes/list-queue.ts

@@ -6,9 +6,9 @@
  * straight state read, no recomputation.
  */
 
-import { get, type HttpHandler } from "@nwire/http";
+import { get } from "@nwire/wires/http";
+import type { ForgeDispatcher } from "@nwire/forge";
 import { z } from "zod";
-import { app } from "../../../app/app";
 
 const Query = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(20),
@@ -16,7 +16,13 @@ const Query = z.object({
 
 export const listQueueRoute = get("/queue", { query: Query });
 
-export const listQueueHandler: HttpHandler<z.infer<typeof Query>> = async ({ input }) => ({
-  items: await app.runtime.query("posts.list-pending", input),
-  totals: await app.runtime.query("posts.queue-totals", {}),
-});
+export const listQueueHandler = async (
+  input: z.infer<typeof Query>,
+  ctx: { resolve: <T>(name: string) => T },
+) => {
+  const dispatcher = ctx.resolve<ForgeDispatcher>("forge.dispatcher");
+  return {
+    items: await dispatcher.query("posts.list-pending", input),
+    totals: await dispatcher.query("posts.queue-totals", {}),
+  };
+};

package/templates/enterprise/modules/posts/routes/reject-post.ts

@@ -5,9 +5,9 @@
  * PostWasRejected event.
  */
 
-import { post, type HttpHandler } from "@nwire/http";
+import { post } from "@nwire/wires/http";
+import type { ForgeDispatcher } from "@nwire/forge";
 import { z } from "zod";
-import { app } from "../../../app/app";
 import { rejectPost } from "../actions/reject-post";
 
 const Params = z.object({ postId: z.string() });
@@ -19,8 +19,12 @@ type Input = z.infer<typeof Params> & z.infer<typeof Body>;
 
 export const rejectPostRoute = post("/posts/:postId/reject", { params: Params, body: Body });
 
-export const rejectPostHandler: HttpHandler<Input> = async ({ input }) => {
-  await app.runtime.dispatch(rejectPost, {
+export const rejectPostHandler = async (
+  input: Input,
+  ctx: { resolve: <T>(name: string) => T },
+) => {
+  const dispatcher = ctx.resolve<ForgeDispatcher>("forge.dispatcher");
+  await dispatcher.dispatch(rejectPost, {
     postId: input.postId,
     rejectedBy: input.moderatorId,
     reason: input.reason,

package/templates/enterprise/modules/posts/routes/submit-post.ts

@@ -1,18 +1,14 @@
 /**
  * POST /api/posts — author submits a draft for moderation.
  *
- * Returns 202 (Accepted) — the action recorded PostWasSubmitted; the
+ * Returns 202 (Accepted) — the action records PostWasSubmitted; the
  * auto-moderate workflow + dashboard projection run downstream. By the
  * time the client polls GET /api/queue the post may already be auto-decided.
- *
- * The route handler is a thin shim: translate request → action input,
- * dispatch, return the tagged response. All orchestration happens
- * downstream of the event the action emits — never inside the handler.
  */
 
-import { post, type HttpHandler } from "@nwire/http";
+import { post } from "@nwire/wires/http";
+import type { ForgeDispatcher } from "@nwire/forge";
 import { z } from "zod";
-import { app } from "../../../app/app";
 import { submitPost } from "../actions/submit-post";
 
 const Body = z.object({
@@ -22,7 +18,11 @@ const Body = z.object({
 
 export const submitPostRoute = post("/posts", { body: Body });
 
-export const submitPostHandler: HttpHandler<z.infer<typeof Body>> = async ({ input }) => {
-  await app.runtime.dispatch(submitPost, input);
+export const submitPostHandler = async (
+  input: z.infer<typeof Body>,
+  ctx: { resolve: <T>(name: string) => T },
+) => {
+  const dispatcher = ctx.resolve<ForgeDispatcher>("forge.dispatcher");
+  await dispatcher.dispatch(submitPost, input);
   return { $status: 202, body: { accepted: true } };
 };

package/templates/enterprise/package.json

@@ -8,15 +8,16 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@nwire/app": "^0.8.17",
-    "@nwire/endpoint": "^0.8.17",
-    "@nwire/forge": "^0.8.17",
-    "@nwire/http": "^0.8.17",
-    "@nwire/messages": "^0.8.17",
+    "@nwire/app": "^0.10.0",
+    "@nwire/endpoint": "^0.10.0",
+    "@nwire/forge": "^0.10.0",
+    "@nwire/wires": "^0.10.0",
+    "@nwire/koa": "^0.10.0",
+    "@nwire/messages": "^0.10.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@nwire/test-kit": "^0.8.17",
+    "@nwire/test-kit": "^0.10.0",
     "@types/node": "^22.19.9",
     "typescript": "^5.9.0",
     "vite-node": "^3.2.4",

package/templates/minimal/__tests__/hello.test.ts

@@ -2,31 +2,35 @@
  * Smoke test — POST /hello returns the personalized greeting, and an
  * empty `name` is rejected with a structured validation error.
  *
- * The test boots `api` (no full endpoint — no port binding) and dispatches
- * raw fetch requests against `api.compile()` mounted on a Node http server.
- * That's the same boot path as production, just without the lightship
- * probes and SIGTERM dance.
+ * Boots the app through endpoint + httpKoa on an ephemeral port.
  */
 
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import http from "node:http";
-import type { Server } from "node:http";
-import { api } from "../app/api";
+import { endpoint } from "@nwire/endpoint";
+import { httpKoa } from "@nwire/koa";
+import { buildApp } from "../app/main";
 
-let server: Server;
+let running: Awaited<ReturnType<ReturnType<typeof endpoint>["run"]>>;
+let app: ReturnType<typeof buildApp>;
 let url: string;
 
 beforeAll(async () => {
-  server = http.createServer(api.compile());
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const addr = server.address() as { port: number };
-  url = `http://127.0.0.1:${addr.port}`;
+  app = buildApp();
+  const koa = httpKoa({ port: 0 });
+  running = await endpoint("hello-test", {
+    exitOnShutdown: false,
+    banner: false,
+    probes: { enabled: false },
+  })
+    .use(koa)
+    .mount(app)
+    .run();
+  url = `http://127.0.0.1:${koa.port()}`;
 });
 
 afterAll(async () => {
-  await new Promise<void>((resolve, reject) =>
-    server.close((err) => (err ? reject(err) : resolve())),
-  );
+  await running.shutdown("test");
+  await app.stop();
 });
 
 describe("hello route", () => {

package/templates/minimal/app/api.ts

@@ -1,23 +1,20 @@
 /**
- * HTTP interface — the surface this app exposes.
+ * Wires — the surface this app exposes.
  *
- * The interface is built by wiring route bindings to handlers. Each route
- * lives under `./routes/` and exports a `{name}Route` + `{name}Handler`
- * pair. The interface stays a 1-line-per-route reducer; new routes drop in
- * with a single import + a single `.wire(...)` call.
+ * Each route lives under `./routes/` and exports a `{name}Route` +
+ * `{name}Handler` pair. `wires` is a flat array of `{ binding, handler }`
+ * pairs that `main.ts` feeds into `app.wire(...)`.
  *
- * Why a folder of routes for "just one route"?
- *
- *   - Adding route #2 is a single new file, not a rewrite of api.ts.
- *   - Each route's verb + path + schema + handler live together.
- *   - The pattern matches the service and enterprise templates, so
- *     graduating up is mechanical.
+ * Adding route #2 is one new file + one new entry in this array.
  *
  * When you outgrow inline handlers (multiple bounded contexts, domain
- * events, persistence) graduate via `pnpm create nwire <name> --template service`.
+ * events, persistence) graduate via:
+ *
+ *   pnpm create nwire <name> --template service
  */
 
-import { httpInterface } from "@nwire/http";
 import { helloRoute, helloHandler } from "./routes/hello";
 
-export const api = httpInterface().wire(helloRoute, helloHandler);
+export const wires = [
+  { binding: helloRoute, handler: helloHandler },
+] as const;

package/templates/minimal/app/main.ts

@@ -1,27 +1,38 @@
 /**
- * Entry point — boot the HTTP interface inside an endpoint.
+ * Entry — boot the app under HTTP.
  *
- * The lifecycle:
+ *   createApp(...)        — the bounded context (container + wires)
+ *   app.wire(...)         — pair a binding with its handler
+ *   endpoint().use(...)   — install a transport adopter (HTTP, queue, MCP, …)
+ *   .mount(app).run()     — boot the app under the adopters; ready for traffic
  *
- *   1. `api` (./api.ts) is a built interface — routes registered, schemas
- *      compiled, ready to serve.
- *   2. `endpoint(name, { port }).serve(api).run()` starts the HTTP listener
- *      AND wires graceful SIGTERM drain + K8s readiness/liveness probes.
- *
- * No createApp, no DI container, no domain primitives. Two packages,
- * three files of source code. The smallest possible Nwire shape.
+ * The minimal shape: no DI, no forge, no domain primitives. Two packages
+ * and three files. Graduate to `service` when you need a container, store,
+ * or structured errors.
  *
  * Run:    pnpm dev
  * Try:    curl -X POST http://localhost:3000/hello \
  *               -H "content-type: application/json" \
  *               -d '{"name":"Alice"}'
- *
- * Probes (K8s readiness/liveness):
- *   curl http://localhost:9400/ready
- *   curl http://localhost:9400/live
  */
 
+import { createApp } from "@nwire/app";
 import { endpoint } from "@nwire/endpoint";
-import { api } from "./api";
+import { httpKoa } from "@nwire/koa";
+import { wires } from "./api";
+
+export function buildApp() {
+  const app = createApp({ appName: "{{PROJECT_NAME}}" });
+  for (const { binding, handler } of wires) {
+    app.wire(binding, handler);
+  }
+  return app;
+}
 
-await endpoint("{{PROJECT_NAME}}", { port: 3000 }).serve(api).run();
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const app = buildApp();
+  await endpoint("{{PROJECT_NAME}}", { port: 3000 })
+    .use(httpKoa())
+    .mount(app)
+    .run();
+}