liminal 0.17.14 → 0.17.16

package/Actor.ts

@@ -1,15 +1,11 @@
 import { Context, Schema as S, Effect } from "effect"
+import * as Boundary from "liminal-util/Boundary"
+import type { TopFromString } from "liminal-util/schema"
 
-import type { TopFromString } from "./_util/schema.ts"
 import type * as ActorClient from "./Client.ts"
 import type { ClientHandle, Sender } from "./ClientHandle.ts"
-
-import { diagnostic } from "./_diagnostic.ts"
-import * as Method from "./Method.ts"
 import { type ProtocolDefinition } from "./Protocol.ts"
 
-const { span } = diagnostic("Actor")
-
 export const TypeId = "~liminal/Actor" as const
 
 export interface Service<
@@ -54,14 +50,9 @@ export interface Actor<
 
   readonly definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>
 
-  readonly all: Sender<ActorSelf, D>
-
-  readonly others: Sender<ActorSelf, D>
+  readonly all: Sender<D, ActorSelf>
 
-  readonly handler: <K extends keyof D["methods"], R>(
-    tag: K,
-    f: Method.Handler<D["methods"][K], R>,
-  ) => Method.Handler<D["methods"][K], R>
+  readonly others: Sender<D, ActorSelf>
 }
 
 export const Service =
@@ -79,45 +70,42 @@ export const Service =
   ): Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D> => {
     const tag = Context.Service<ActorSelf, Service<ActorSelf, Name, AttachmentFields, D>>()(id)
 
-    const all: Sender<ActorSelf, D> = {
+    const all: Sender<D, ActorSelf> = {
       send: (key, payload) =>
-        tag.asEffect().pipe(
+        tag.pipe(
           Effect.flatMap(({ clients }) =>
             Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
           ),
-          span("all.send"),
+          Boundary.span("send-all", import.meta.url),
         ),
-      disconnect: tag.asEffect().pipe(
+      disconnect: tag.pipe(
         Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)),
-        span("all.disconnect"),
+        Boundary.span("disconnect-all", import.meta.url),
       ),
     }
 
-    const others: Sender<ActorSelf, D> = {
-      send: Effect.fnUntraced(function* (key, payload) {
-        const { clients, currentClient } = yield* tag
-        yield* Effect.forEach(
-          clients,
-          (client) => (client === currentClient ? Effect.void : client.send(key, payload)),
-          { concurrency: "unbounded" },
-        )
-      }, span("others.send")),
+    const others: Sender<D, ActorSelf> = {
+      send: Effect.fnUntraced(
+        function* (key, payload) {
+          const { clients, currentClient } = yield* tag
+          yield* Effect.forEach(
+            clients,
+            (client) => (client === currentClient ? Effect.void : client.send(key, payload)),
+            { concurrency: "unbounded" },
+          )
+        },
+        Boundary.span("send-others", import.meta.url),
+      ),
       disconnect: Effect.gen(function* () {
         const { clients, currentClient } = yield* tag
         yield* Effect.forEach(clients, (client) => (client === currentClient ? Effect.void : client.disconnect))
-      }).pipe(span("others.disconnect")),
+      }).pipe(Boundary.span("disconnect-others", import.meta.url)),
     }
 
-    const handler = <K extends keyof D["methods"], R>(
-      _tag: K,
-      f: Method.Handler<D["methods"][K], R>,
-    ): Method.Handler<D["methods"][K], R> => f
-
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
       all,
       others,
-      handler,
     })
   }

package/ActorHandle.ts

@@ -0,0 +1,34 @@
+import { Schema as S, Effect, Cause, Encoding } from "effect"
+import { NativeRequest } from "effect-workerd"
+import { HttpServerResponse } from "effect/unstable/http"
+import type { TopFromString } from "liminal-util/schema"
+
+import type { Send } from "./ClientHandle.ts"
+import type { Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+export interface ActorHandle<
+  NamespaceSelf,
+  Internal extends Methods,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  D extends ProtocolDefinition,
+> {
+  readonly upgrade: (
+    attachments: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<
+    HttpServerResponse.HttpServerResponse,
+    S.SchemaError | Encoding.EncodingError | Cause.NoSuchElementError,
+    | NamespaceSelf
+    | NativeRequest.NativeRequest
+    | Name["EncodingServices"]
+    | S.Struct<AttachmentFields>["EncodingServices"]
+  >
+
+  readonly call: <K extends keyof Internal, M extends Internal[K]>(
+    method: K,
+    payload: M["payload"]["Type"],
+  ) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf>
+
+  readonly proxySendAll: Send<D, NamespaceSelf>
+}

package/ActorNamespace.ts

@@ -0,0 +1,188 @@
+import { Layer, Effect, Schema as S, Context, flow, String, Array, Encoding, Exit } from "effect"
+import { Binding, Env, NativeRequest } from "effect-workerd"
+import { SecWebSocketProtocol, close } from "effect-workerd/socket_util"
+import { HttpServerResponse, HttpTraceContext } from "effect/unstable/http"
+import * as Boundary from "liminal-util/Boundary"
+import { type TopFromString, encodeJsonString } from "liminal-util/schema"
+
+import type { Actor } from "./Actor.ts"
+import type { ActorHandle } from "./ActorHandle.ts"
+import type { Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+export interface ActorNamespaceDefinition<
+  Internal extends Methods,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+> {
+  readonly binding: string
+
+  readonly internal: Internal
+
+  readonly actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
+}
+
+export interface ActorNamespace<
+  NamespaceSelf,
+  NamespaceId extends string,
+  Internal extends Methods,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+> {
+  new (
+    _: never,
+  ): Context.ServiceClass.Shape<
+    NamespaceId,
+    DurableObjectNamespace<Rpc.DurableObjectBranded & ActorNamespace.MakeRpc<Internal, D>>
+  >
+
+  readonly definition: ActorNamespaceDefinition<
+    Methods,
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D
+  >
+
+  readonly bind: (name: Name["Type"]) => ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields, D>
+
+  readonly layer: Layer.Layer<NamespaceSelf, S.SchemaError, Env>
+}
+
+export declare namespace ActorNamespace {
+  export type MakeRpc<Internal extends Methods, D extends ProtocolDefinition> = {
+    rpc: <K extends keyof Internal>(
+      method: K,
+      payload: Internal[K]["payload"]["Type"],
+    ) => Promise<Exit.Exit<Internal[K]["success"]["Type"], Internal[K]["failure"]["Type"]>>
+
+    proxySendAll<K extends keyof D["events"]>(event: K, payload: S.Struct<D["events"][K]>["Type"]): void
+  }
+}
+
+export const Service =
+  <NamespaceSelf>() =>
+  <
+    NamespaceId extends string,
+    Internal extends Methods,
+    ActorSelf,
+    ActorId extends string,
+    Name extends TopFromString,
+    AttachmentFields extends S.Struct.Fields,
+    ClientSelf,
+    ClientId extends string,
+    D extends ProtocolDefinition,
+  >(
+    id: NamespaceId,
+    definition: ActorNamespaceDefinition<Internal, ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
+  ): ActorNamespace<
+    NamespaceSelf,
+    NamespaceId,
+    Internal,
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D
+  > => {
+    const { binding, actor } = definition
+    const {
+      definition: {
+        name: Name,
+        client: { key: clientId, protocol: P },
+        attachments: AttachmentFields,
+      },
+    } = actor
+
+    const tag = Context.Service<
+      NamespaceSelf,
+      DurableObjectNamespace<Rpc.DurableObjectBranded & ActorNamespace.MakeRpc<Internal, D>>
+    >()(id)
+
+    const encodeName = S.encodeEffect(Name)
+    const Attachments = S.Struct(AttachmentFields)
+    const encodeAttachmentsString = encodeJsonString(Attachments)
+    const encodeAuditionFailure = encodeJsonString(P.Audition.Failure)
+
+    const bind = (name: Name["Type"]): ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields, D> => {
+      const getStub = Effect.gen(function* () {
+        const namespace = yield* tag
+        const nameEncoded = yield* encodeName(name)
+        return namespace.getByName(nameEncoded)
+      })
+
+      const upgrade = (attachments: S.Struct<AttachmentFields>["Type"]) =>
+        Effect.gen({ self: this }, function* () {
+          const request = yield* NativeRequest.NativeRequest
+          const protocols = yield* Effect.fromNullishOr(request.headers.get(SecWebSocketProtocol)).pipe(
+            Effect.map(flow(String.split(","), Array.map(String.trim))),
+          )
+          const liminalTokenI = yield* Array.findFirstIndex(protocols, (v) => v === "liminal").pipe(Effect.fromOption)
+          const liminalClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 1])
+          const requestClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 2]).pipe(
+            Effect.flatMap((v) => Encoding.decodeBase64UrlString(v).pipe(Effect.fromResult)),
+          )
+          if (requestClientId !== clientId) {
+            return close(
+              yield* encodeAuditionFailure({
+                _tag: "Audition.Failure",
+                expected: clientId,
+                actual: requestClientId,
+              }),
+            )
+          }
+          const url = new URL(request.url)
+          url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
+          url.searchParams.set("__liminal_client_id", liminalClientId)
+          const actorRequest = new Request(url, request)
+          const traceHeaders = yield* Effect.currentSpan.pipe(Effect.map(HttpTraceContext.toHeaders))
+          for (const [key, value] of Object.entries(traceHeaders)) {
+            actorRequest.headers.set(key, value)
+          }
+          const stub = yield* getStub
+          return yield* Effect.promise(() => stub.fetch(actorRequest)).pipe(Effect.map(HttpServerResponse.raw))
+        }).pipe(Boundary.span("upgrade", import.meta.url, { kind: "client" }))
+
+      const call = Effect.fnUntraced(
+        function* <K extends keyof Internal, M extends Internal[K]>(
+          method: K,
+          payload: M["payload"]["Type"],
+        ): Effect.fn.Return<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf> {
+          const stub = yield* getStub
+          const exit = yield* Effect.promise(() => stub.rpc(method as never, payload as never))
+          return yield* exit as any
+        },
+        Boundary.span("call", import.meta.url),
+      )
+
+      // TODO:
+      const proxySendAll = Effect.fnUntraced(
+        function* <K extends keyof D["events"]>(event: K, payload: S.Struct<D["events"][K]>["Type"]) {
+          const stub = yield* getStub
+          yield* Effect.promise(() => stub.proxySendAll(event as never, payload as never))
+        },
+        Boundary.span("proxySendAll", import.meta.url),
+      ) as never
+
+      return { upgrade, call, proxySendAll }
+    }
+
+    const layer = Binding.layer(tag, ["idFromName", "idFromString", "newUniqueId", "get", "getByName"])(binding)
+
+    return Object.assign(tag, { definition, bind, layer })
+  }