liminal 0.17.5 → 0.17.6

package/Actor.ts

@@ -2,7 +2,7 @@ import { Context, Schema as S, Effect } from "effect"
 
 import type * as ActorClient from "./Client.ts"
 import type * as ClientHandle from "./ClientHandle.ts"
-import type { MethodDefinition } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 import type { Send } from "./Send.ts"
 
 import * as Diagnostic from "./_util/Diagnostic.ts"
@@ -12,17 +12,12 @@ const { span } = Diagnostic.module("Actor")
 
 export const TypeId = "~liminal/Actor" as const
 
-export interface Service<
-  ActorSelf,
-  NameA,
-  AttachmentFields extends S.Struct.Fields,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> {
+export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
   readonly name: NameA
 
-  readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>
+  readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
 
-  readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>
+  readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>>
 }
 
 export interface ActorDefinition<
@@ -30,14 +25,13 @@ export interface ActorDefinition<
   AttachmentFields extends S.Struct.Fields,
   ClientSelf,
   ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
+  D extends ProtocolDefinition,
 > {
   readonly name: S.Codec<NameA, string>
 
   readonly attachments: AttachmentFields
 
-  readonly client: ActorClient.Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>
+  readonly client: ActorClient.Client<ClientSelf, ClientId, D>
 }
 
 export interface Actor<
@@ -47,34 +41,26 @@ export interface Actor<
   AttachmentFields extends S.Struct.Fields,
   ActorClientSelf,
   ActorClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> extends Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>> {
-  new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>
+  D extends ProtocolDefinition,
+> extends Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, D>> {
+  new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, NameA, AttachmentFields, D>>
 
   readonly [TypeId]: typeof TypeId
 
-  readonly definition: ActorDefinition<
-    NameA,
-    AttachmentFields,
-    ActorClientSelf,
-    ActorClientId,
-    MethodDefinitions,
-    EventDefinitions
-  >
-
-  readonly schema: {
-    readonly attachments: S.Codec<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>
+  readonly definition: ActorDefinition<NameA, AttachmentFields, ActorClientSelf, ActorClientId, D>
+
+  readonly protocol: {
+    readonly Attachments: S.Struct<AttachmentFields>
   }
 
-  readonly sendAll: Send<ActorSelf, EventDefinitions>
+  readonly sendAll: Send<ActorSelf, D>
 
   readonly disconnectAll: Effect.Effect<void, never, ActorSelf>
 
-  readonly handler: <K extends keyof MethodDefinitions, R>(
+  readonly handler: <K extends keyof D["methods"], R>(
     tag: K,
-    f: Method.Handler<MethodDefinitions[K], R>,
-  ) => Method.Handler<MethodDefinitions[K], R>
+    f: Method.Handler<D["methods"][K], R>,
+  ) => Method.Handler<D["methods"][K], R>
 }
 
 export const Service =
@@ -82,18 +68,17 @@ export const Service =
   <
     ActorId extends string,
     NameA,
+    D extends ProtocolDefinition,
     AttachmentFields extends S.Struct.Fields,
     ClientSelf,
     ClientId extends string,
-    MethodDefinitions extends Record<string, MethodDefinition.Any>,
-    EventDefinitions extends Record<string, S.Struct.Fields>,
   >(
     id: ActorId,
-    definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>,
-  ): Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions> => {
-    const tag = Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>()(id)
+    definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, D>,
+  ): Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, D> => {
+    const tag = Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, D>>()(id)
 
-    const sendAll: Send<ActorSelf, EventDefinitions> = (key, payload) =>
+    const sendAll: Send<ActorSelf, D> = (key, payload) =>
       tag.asEffect().pipe(
         Effect.flatMap(({ clients }) =>
           Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
@@ -106,16 +91,16 @@ export const Service =
       span("disconnectAll"),
     )
 
-    const handler = <K extends keyof MethodDefinitions, R>(
+    const handler = <K extends keyof D["methods"], R>(
       _tag: K,
-      f: Method.Handler<MethodDefinitions[K], R>,
-    ): Method.Handler<MethodDefinitions[K], R> => f
+      f: Method.Handler<D["methods"][K], R>,
+    ): Method.Handler<D["methods"][K], R> => f
 
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
-      schema: {
-        attachments: S.Struct(definition.attachments) as never,
+      protocol: {
+        Attachments: S.Struct(definition.attachments),
       },
       sendAll,
       disconnectAll,

package/Audition.ts

@@ -1,7 +1,7 @@
 import { Schema as S, Pipeable, Stream, Effect, Function } from "effect"
 
 import type { F } from "./F.ts"
-import type * as Method from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
 import * as Diagnostic from "./_util/Diagnostic.ts"
 import * as Client from "./Client.ts"
@@ -11,16 +11,19 @@ const { debug, span } = Diagnostic.module("Audition")
 
 const TypeId = "~liminal/Audition" as const
 
-export interface Audition<ClientSelf, MethodDefinitions extends Record<string, Method.MethodDefinition.Any>, Event>
-  extends Pipeable.Pipeable {
+export interface Audition<ClientSelf, D extends ProtocolDefinition> extends Pipeable.Pipeable {
   readonly [TypeId]: typeof TypeId
 
-  readonly events: Stream.Stream<Event, ClientError, ClientSelf>
+  readonly events: Stream.Stream<
+    ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
+    ClientError | S.SchemaError,
+    ClientSelf
+  >
 
-  readonly f: F<ClientSelf, MethodDefinitions>
+  readonly f: F<ClientSelf, D>
 }
 
-export const empty: Audition<never, never, never> = {
+export const empty: Audition<never, never> = {
   [TypeId]: TypeId,
   pipe() {
     return Pipeable.pipeArguments(this, arguments)
@@ -30,62 +33,38 @@ export const empty: Audition<never, never, never> = {
 }
 
 export const add: {
-  <
-    ClientSelf,
-    ClientId extends string,
-    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
-  >(
-    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
-  ): <AuditionSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent>(
-    audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
-  ) => Audition<
-    AuditionSelf | ClientSelf,
-    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
-  >
+  <ClientSelf, ClientId extends string, ClientD extends ProtocolDefinition>(
+    client: Client.Client<ClientSelf, ClientId, ClientD>,
+  ): <AuditionSelf, AuditionD extends ProtocolDefinition>(
+    audition: Audition<AuditionSelf, AuditionD>,
+  ) => Audition<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>
   <
     AuditionClientSelf,
-    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    AuditionEvent,
+    AuditionD extends ProtocolDefinition,
     ClientSelf,
     ClientId extends string,
-    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
+    ClientD extends ProtocolDefinition,
   >(
-    audition: Audition<AuditionClientSelf, AuditionMethodDefinitions, AuditionEvent>,
-    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
-  ): Audition<
-    AuditionClientSelf | ClientSelf,
-    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
-  >
+    audition: Audition<AuditionClientSelf, AuditionD>,
+    client: Client.Client<ClientSelf, ClientId, ClientD>,
+  ): Audition<AuditionClientSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>
 } = Function.dual(
   2,
   <
     AuditionSelf,
-    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    AuditionEvent,
+    AuditionD extends ProtocolDefinition,
     ClientSelf,
     ClientId extends string,
-    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
+    ClientD extends ProtocolDefinition,
   >(
-    audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
-    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
-  ): Audition<
-    AuditionSelf | ClientSelf,
-    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
-  > => {
-    const f: F<
-      AuditionSelf | ClientSelf,
-      Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>
-    > = (method) => (payload) =>
+    audition: Audition<AuditionSelf, AuditionD>,
+    client: Client.Client<ClientSelf, ClientId, ClientD>,
+  ): Audition<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>> => {
+    const f: F<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>> = (method) => (payload) =>
       audition
-        .f(method as never)(payload)
+        .f(method)(payload)
         .pipe(
-          Effect.catchTag("AuditionError", () => client.f(method as never)(payload)),
+          Effect.catchTag("AuditionError", () => client.f(method)(payload)),
           span("f"),
         )
 

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.17.6
+
+### Patch Changes
+
+- d7b1da3: Simplify type-level representation of client protocol.
+
 ## 0.17.5
 
 ### Patch Changes