create-effect-project 0.1.0

package/templates/http-server/runtime/node/client.ts

@@ -0,0 +1,40 @@
+/**
+ * Client entrypoint — exercises the running server with the generated client.
+ *
+ *   {{runCmd}} dev      # in one terminal
+ *   {{runCmd}} client   # in another
+ */
+import { NodeRuntime } from "@effect/platform-node"
+import { Effect, Layer } from "effect"
+import { ApiClient } from "./client/ApiClient.ts"
+import { NoteId } from "./domain/Note.ts"
+import * as Observability from "./observability.ts"
+
+const program = Effect.gen(function*() {
+  const client = yield* ApiClient
+
+  // `system` is a top level group, so its endpoints sit at the root.
+  yield* client.health()
+  yield* Effect.logInfo("health: ok")
+
+  const created = yield* client.notes.create({ payload: { title: "first", body: "hello" } })
+  yield* Effect.logInfo("created", created)
+
+  const fetched = yield* client.notes.getById({ params: { id: created.id } })
+  yield* Effect.logInfo("getById", fetched)
+
+  const all = yield* client.notes.list()
+  yield* Effect.logInfo("list", all)
+
+  // Errors are typed too: an unknown id fails with `NoteNotFound`, which the
+  // server returns as a 404.
+  const missing = yield* client.notes.getById({ params: { id: NoteId.make("nope") } }).pipe(
+    Effect.catchTag("NoteNotFound", () => Effect.succeed("NoteNotFound (404) as expected"))
+  )
+  yield* Effect.logInfo("getById?id=nope", missing)
+}).pipe(
+  Effect.withSpan("client-demo"),
+  Effect.provide(Layer.mergeAll(ApiClient.layer, Observability.layer("notes-client")))
+)
+
+program.pipe(NodeRuntime.runMain)

package/templates/http-server/runtime/node/http.test.ts

@@ -0,0 +1,48 @@
+import { assert, describe, it } from "@effect/vitest"
+import type { Scope } from "effect"
+import { Effect, Layer, References } from "effect"
+import { HttpServer } from "effect/unstable/http"
+import { HttpApiTest } from "effect/unstable/httpapi"
+import { Api } from "../../api/Api.ts"
+import { NoteId } from "../../domain/Note.ts"
+import { Notes } from "../Notes.ts"
+import { NotesApiHandlersNoDeps } from "./http.ts"
+
+// Handlers wired to the in-memory Notes, so the whole HTTP pipeline runs
+// without a server: same encoding, routing and decoding as production.
+const TestLayer = Layer.mergeAll(
+  NotesApiHandlersNoDeps.pipe(Layer.provide(Notes.layerMemory)),
+  HttpServer.layerServices
+)
+
+const makeClient = HttpApiTest.groups(Api, ["notes"])
+
+const run = <A, E, R>(layer: Layer.Layer<R>, effect: Effect.Effect<A, E, R | Scope.Scope>) =>
+  effect.pipe(
+    Effect.scoped,
+    Effect.provide(layer),
+    // Keep the test output to the assertions; raise this to see app logs.
+    Effect.provideService(References.MinimumLogLevel, "None")
+  )
+
+describe("notes api", () => {
+  it.effect("creates then lists a note", () =>
+    run(TestLayer, Effect.gen(function*() {
+      const client = yield* makeClient
+      const created = yield* client.notes.create({ payload: { title: "first", body: "hello" } })
+      assert.strictEqual(created.title, "first")
+
+      const listed = yield* client.notes.list()
+      assert.strictEqual(listed.length, 1)
+      assert.strictEqual(listed[0]?.id, created.id)
+    })))
+
+  it.effect("fails with NoteNotFound for an unknown id", () =>
+    run(TestLayer, Effect.gen(function*() {
+      const client = yield* makeClient
+      const error = yield* Effect.flip(
+        client.notes.getById({ params: { id: NoteId.make("nope") } })
+      )
+      assert.strictEqual(error._tag, "NoteNotFound")
+    })))
+})

package/templates/http-server/runtime/node/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Server entrypoint.
+ *
+ * A schema-first API (`src/api`) is implemented by handlers (`src/server`),
+ * served over Node, and consumed by a generated typed client (`src/client`).
+ *
+ *   {{runCmd}} dev     # http://localhost:3000/docs
+ */
+import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
+import { Layer } from "effect"
+import { HttpRouter } from "effect/unstable/http"
+import { createServer } from "node:http"
+import { port } from "./config.ts"
+import * as Observability from "./observability.ts"
+import { AllRoutes } from "./server/http.ts"
+
+const HttpServerLayer = HttpRouter.serve(AllRoutes).pipe(
+  Layer.provide(NodeHttpServer.layerConfig(createServer, { port }))
+)
+
+const Main = HttpServerLayer.pipe(
+  // Provided at the very end, so every span the app creates is exported.
+  Layer.provide(Observability.layer("{{name}}"))
+)
+
+Layer.launch(Main).pipe(NodeRuntime.runMain)