update effect (#161)

.changeset/sweet-falcons-remember.md

@@ -0,0 +1,9 @@
+---
+"@effect/rpc-http-node": minor
+"@effect/rpc-workers": minor
+"@effect/rpc-nextjs": minor
+"@effect/rpc-http": minor
+"@effect/rpc": minor
+---
+
+update effect

package.json

@@ -24,7 +24,7 @@
     "@babel/plugin-transform-modules-commonjs": "^7.23.3",
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.1",
-    "@effect/build-utils": "^0.7.0",
+    "@effect/build-utils": "^0.7.1",
     "@effect/docgen": "^0.3.8",
     "@effect/eslint-plugin": "^0.1.2",
     "@effect/language-service": "^0.1.0",
@@ -33,18 +33,18 @@
     "@vitest/coverage-v8": "^1.0.4",
     "@vitest/web-worker": "^1.0.4",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
-    "eslint": "^8.55.0",
+    "eslint": "^8.56.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-codegen": "^0.21.0",
     "eslint-plugin-deprecation": "^2.0.0",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-sort-destructure-keys": "^1.5.0",
     "glob": "^10.3.10",
     "madge": "^6.1.0",
     "prettier": "^3.1.1",
     "typescript": "^5.3.3",
-    "vite": "^5.0.8",
+    "vite": "^5.0.10",
     "vitest": "^1.0.4"
   }
 }

packages/http-node/package.json

@@ -27,9 +27,9 @@
     "@effect/rpc-http": "workspace:^"
   },
   "devDependencies": {
-    "@effect/platform": "^0.35.0",
-    "@effect/schema": "^0.53.1",
-    "@types/node": "^20.10.4"
+    "@effect/platform": "^0.38.0",
+    "@effect/schema": "^0.54.0",
+    "@types/node": "^20.10.5"
   },
   "peerDependencies": {
     "@effect/platform": "^0.35.0",

packages/http/examples/server.ts

@@ -2,7 +2,7 @@ import * as Http from "@effect/platform-node/HttpServer"
 import { runMain } from "@effect/platform-node/Runtime"
 import * as Router from "@effect/rpc-http/Router"
 import * as Server from "@effect/rpc-http/Server"
-import { Chunk, Console, Effect } from "effect"
+import { Chunk, Console, Effect, Layer } from "effect"
 import { createServer } from "http"
 import { schema, UserId } from "./schema.js"
 
@@ -12,18 +12,18 @@ const router = Router.make(schema, {
   getUser: (id) => Effect.succeed({ id, name: `User ${id}` })
 })
 
-const server = Http.router.empty.pipe(
+const HttpLive = Http.router.empty.pipe(
   Http.router.post("/rpc", Server.make(router)),
   Http.server.serve(Http.middleware.logger),
-  Effect.scoped
+  Layer.provide(
+    Http.server.layer(createServer, {
+      port: 3000
+    })
+  )
 )
 
 // Create the HTTP, which can be served with the platform HTTP server.
 Console.log("Listening on http://localhost:3000").pipe(
-  Effect.zipRight(server),
-  Effect.provide(Http.server.layer(createServer, {
-    port: 3000
-  })),
-  Effect.tapErrorCause(Effect.logError),
+  Effect.zipRight(Layer.launch(HttpLive)),
   runMain
 )

packages/http/package.json

@@ -26,10 +26,10 @@
     "@effect/rpc": "workspace:^"
   },
   "devDependencies": {
-    "@effect/platform": "^0.35.0",
-    "@effect/platform-node": "^0.35.1",
-    "@effect/schema": "^0.53.1",
-    "effect": "2.0.0-next.60"
+    "@effect/platform": "^0.38.0",
+    "@effect/platform-node": "^0.38.0",
+    "@effect/schema": "^0.54.0",
+    "effect": "2.0.0-next.61"
   },
   "peerDependencies": {
     "@effect/platform": "^0.35.0",

packages/http/test/Server.test.ts

@@ -5,6 +5,7 @@ import * as Router from "@effect/rpc-http/Router"
 import * as RS from "@effect/rpc-http/Schema"
 import * as _ from "@effect/rpc-http/Server"
 import * as S from "@effect/schema/Schema"
+import { Layer } from "effect"
 import * as Effect from "effect/Effect"
 import { createServer } from "http"
 import { assert, describe, it } from "vitest"
@@ -26,7 +27,7 @@ const router = Router.make(schema, {
   headers: Effect.map(Http.request.ServerRequest, (request) => request.headers)
 })
 
-const server = _.make(router).pipe(Http.server.serve())
+const HttpLive = Http.server.serve(_.make(router))
 const ServerLive = Http.server.layer(createServer, { port: 0 })
 const serverPort = Http.server.Server.pipe(Effect.map((_) => (_.address as Http.server.TcpAddress).port))
 
@@ -35,7 +36,7 @@ describe("Server", () => {
     Effect.gen(function*(_) {
       const port = yield* _(serverPort)
 
-      yield* _(Effect.fork(server))
+      yield* _(Effect.fork(Layer.launch(HttpLive)))
       yield* _(Effect.yieldNow())
 
       const client = Client.make(
@@ -49,7 +50,6 @@ describe("Server", () => {
       const headers = yield* _(client.headers)
       assert.strictEqual(headers["x-foo"], "bar")
     }).pipe(
-      Effect.scoped,
       Effect.provide(ServerLive),
       Effect.runPromise
     ), 10000)

packages/nextjs/package.json

@@ -27,9 +27,9 @@
     "@effect/rpc-http": "workspace:^"
   },
   "devDependencies": {
-    "@effect/platform": "^0.35.0",
-    "@effect/schema": "^0.53.1",
-    "effect": "2.0.0-next.60",
+    "@effect/platform": "^0.38.0",
+    "@effect/schema": "^0.54.0",
+    "effect": "2.0.0-next.61",
     "next": "^14.0.4"
   },
   "peerDependencies": {

packages/rpc/package.json

@@ -23,8 +23,8 @@
     "build-annotate": "babel build --plugins annotate-pure-calls --out-dir build --source-maps"
   },
   "devDependencies": {
-    "@effect/schema": "^0.53.1",
-    "effect": "2.0.0-next.60"
+    "@effect/schema": "^0.54.0",
+    "effect": "2.0.0-next.61"
   },
   "peerDependencies": {
     "@effect/schema": "^0.53.1",

packages/workers/package.json

@@ -26,10 +26,10 @@
     "@effect/rpc": "workspace:^"
   },
   "devDependencies": {
-    "@effect/platform": "^0.35.0",
-    "@effect/platform-browser": "^0.22.1",
-    "@effect/schema": "^0.53.1",
-    "effect": "2.0.0-next.60"
+    "@effect/platform": "^0.38.0",
+    "@effect/platform-browser": "^0.24.0",
+    "@effect/schema": "^0.54.0",
+    "effect": "2.0.0-next.61"
   },
   "peerDependencies": {
     "@effect/platform": "^0.35.0",

packages/workers/src/Server.ts

@@ -15,5 +15,5 @@ import * as internal from "./internal/server.js"
 export const make: <R extends RpcRouter.Base>(router: R) => Effect.Effect<
   Scope | Runner.PlatformRunner | RpcRouter.Services<R>,
   Error.WorkerError,
-  never
+  void
 > = internal.make

packages/workers/src/internal/resolver.ts

@@ -27,7 +27,7 @@ export const makePool = (
           return Effect.unit
         },
         encode(message) {
-          return message.payload
+          return Effect.succeed(message.payload)
         },
         transfers(message) {
           return "input" in message.schema

packages/workers/src/internal/server.ts

@@ -14,7 +14,7 @@ import { getTransferables } from "../Schema.js"
 export const make = <R extends RpcRouter.Base>(router: R): Effect.Effect<
   Scope.Scope | Runner.PlatformRunner | RpcRouter.Services<R>,
   Error.WorkerError,
-  never
+  void
 > => {
   const run = (handler: Server.RpcServerSingleWithSchema) =>
     Runner.make<
@@ -23,10 +23,14 @@ export const make = <R extends RpcRouter.Base>(router: R): Effect.Effect<
       RpcTransportError,
       readonly [RpcResponse, Option.Option<Schema.RpcSchema.Base>]
     >(handler, {
-      encode([response]) {
-        return response
+      encodeOutput(_request, [response]) {
+        return Effect.succeed(response)
       },
-      transfers([response, schema]) {
+      transfers(message) {
+        if ("_tag" in message) {
+          return []
+        }
+        const [response, schema] = message
         return Option.getOrElse(
           Option.map(schema, (schema) =>
             response._tag === "Success"

packages/workers/test/e2e.test.ts

@@ -2,6 +2,7 @@ import "@vitest/web-worker"
 import * as Worker from "@effect/platform-browser/Worker"
 import * as Client from "@effect/rpc-workers/Client"
 import * as Resolver from "@effect/rpc-workers/Resolver"
+import { Exit } from "effect"
 import * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
 import * as Duration from "effect/Duration"
@@ -35,21 +36,20 @@ const SharedPoolLive = Resolver.makePoolLayer({
 
 const client = Client.make(schema)
 
+const runPromise = <E, A>(effect: Effect.Effect<never, E, A>) =>
+  Effect.runPromiseExit(effect).then((exit) => {
+    if (Exit.isFailure(exit) && !Exit.isInterrupted(exit)) {
+      throw Cause.squash(exit.cause)
+    }
+  })
+
 describe("e2e", () => {
   it("Worker", () =>
     pipe(
       client.getBinary(new Uint8Array([1, 2, 3])),
       Effect.tap((_) => Effect.sync(() => expect(_).toEqual(new Uint8Array([1, 2, 3])))),
       Effect.provide(PoolLive),
-      Effect.runPromise
-    ))
-
-  it("SharedWorker", () =>
-    pipe(
-      client.getBinary(new Uint8Array([1, 2, 3])),
-      Effect.tap((_) => Effect.sync(() => expect(_).toEqual(new Uint8Array([1, 2, 3])))),
-      Effect.provide(SharedPoolLive),
-      Effect.runPromise
+      runPromise
     ))
 
   it("100x", () =>
@@ -60,7 +60,7 @@ describe("e2e", () => {
       ),
       Effect.tap((_) => Effect.sync(() => expect(_.length).toEqual(100))),
       Effect.provide(PoolLive),
-      Effect.runPromise
+      runPromise
     ))
 
   it("interruption", () => {
@@ -99,4 +99,12 @@ describe("e2e", () => {
 
     expect(await closedPromise).toEqual("closed")
   })
+
+  it("SharedWorker", () =>
+    pipe(
+      client.getBinary(new Uint8Array([1, 2, 3])),
+      Effect.tap((_) => Effect.sync(() => expect(_).toEqual(new Uint8Array([1, 2, 3])))),
+      Effect.provide(SharedPoolLive),
+      runPromise
+    ))
 }, 10000)

packages/workers/test/e2e/worker-setup.ts

@@ -1,3 +1,4 @@
+import { runMain } from "@effect/platform-browser/Runtime"
 import * as Runner from "@effect/platform-browser/WorkerRunner"
 import * as Router from "@effect/rpc-workers/Router"
 import * as Server from "@effect/rpc-workers/Server"
@@ -22,8 +23,8 @@ const router = Router.make(schemaWithSetup, {
 })
 
 Server.make(router).pipe(
-  Effect.scoped,
-  Effect.provide(Runner.layer),
-  Effect.catchAllCause(Effect.logError),
-  Effect.runPromise
+  Layer.scopedDiscard,
+  Layer.provide(Runner.layerPlatform),
+  Layer.launch,
+  runMain
 )

packages/workers/test/e2e/worker.ts

@@ -1,8 +1,10 @@
+import { runMain } from "@effect/platform-browser/Runtime"
 import * as Runner from "@effect/platform-browser/WorkerRunner"
 import * as Router from "@effect/rpc-workers/Router"
 import * as Server from "@effect/rpc-workers/Server"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
 import { schema } from "./schema.js"
 
 const router = Router.make(schema, {
@@ -13,8 +15,8 @@ const router = Router.make(schema, {
 })
 
 Server.make(router).pipe(
-  Effect.scoped,
-  Effect.provide(Runner.layer),
-  Effect.catchAllCause(Effect.logError),
-  Effect.runPromise
+  Layer.scopedDiscard,
+  Layer.provide(Runner.layerPlatform),
+  Layer.launch,
+  runMain
 )