liminal 0.17.1 → 0.17.2

package/Accumulator.ts

@@ -1,4 +1,8 @@
-import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer } from "effect"
+import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer, Semaphore } from "effect"
+
+import * as Diagnostic from "./_util/Diagnostic.ts"
+
+const { debug } = Diagnostic.module("Accumulator")
 
 const TypeId = "~liminal/Accumulator" as const
 
@@ -20,8 +24,8 @@ export type Reduce<State, Item, K extends Types.Tags<Item> = Types.Tags<Item>, E
   item: Types.ExtractTag<Item, K>,
 ) => (accumulator: State) => Effect.Effect<State, E, R>
 
-export interface Accumulator<Self, Id extends string, State> extends Context.Tag<Self, Service<State>> {
-  new (_: never): Context.TagClassShape<Id, Service<State>>
+export interface Accumulator<Self, Id extends string, State> extends Context.Service<Self, Service<State>> {
+  new (_: never): Context.ServiceClass.Shape<Id, Service<State>>
 
   readonly [TypeId]: typeof TypeId
 
@@ -42,14 +46,14 @@ export interface Accumulator<Self, Id extends string, State> extends Context.Tag
 export const Service =
   <Self, State>() =>
   <Id extends string>(id: Id): Accumulator<Self, Id, State> => {
-    const tag = Context.Tag(id)<Self, Service<State>>()
+    const tag = Context.Service<Self, Service<State>>()(id)
 
-    const get = tag.pipe(
+    const get = tag.asEffect().pipe(
       Effect.map(({ ref }) => ref),
       Effect.flatMap(Ref.get),
     )
 
-    const stream = tag.pipe(
+    const stream = tag.asEffect().pipe(
       Effect.map(({ pubsub }) => Stream.fromPubSub(pubsub)),
       Stream.unwrap,
     )
@@ -65,7 +69,7 @@ export const Service =
       reduce,
     }: AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3>): Layer.Layer<Self, E | E2 | E3, R | R2 | R3> =>
       Effect.gen(function* () {
-        const semaphore = yield* Effect.makeSemaphore(1)
+        const semaphore = yield* Semaphore.make(1)
         const deferred = yield* Deferred.make<State>()
         const pubsub = yield* PubSub.unbounded<State>({ replay: 1 })
         yield* source.pipe(
@@ -76,22 +80,24 @@ export const Service =
                 if (Option.isSome(match)) {
                   const { value } = match
                   yield* Deferred.succeed(deferred, value)
+                  yield* debug("InitializedState", { state: value })
                 }
                 return
               }
               const current = yield* Ref.get(ref)
               const reduced = yield* reduce(item)(current)
               yield* Ref.set(ref, reduced)
-              yield* pubsub.publish(reduced)
+              yield* PubSub.publish(pubsub, reduced)
+              yield* debug("ReducedState", { item, previous: current, current: reduced })
             }, semaphore.withPermits(1)),
           ),
           Effect.forkScoped,
         )
         const initial_ = yield* Deferred.await(deferred)
         const ref = yield* Ref.make(initial_)
-        yield* pubsub.publish(initial_)
+        yield* PubSub.publish(pubsub, initial_)
         return { ref, pubsub }
-      }).pipe(Layer.scoped(tag))
+      }).pipe(Layer.effect(tag))
 
     return Object.assign(tag, { [TypeId]: TypeId, get, stream, reducer, layer })
   }

package/Actor.ts

@@ -1,15 +1,23 @@
 import { Context, Schema as S, Effect } from "effect"
 
-import type { FieldsRecord, Fields } from "./_types.ts"
 import type * as ActorClient from "./Client.ts"
 import type * as ClientHandle from "./ClientHandle.ts"
 import type { MethodDefinition } from "./Method.ts"
-import * as Method from "./Method.ts"
 import type { Send } from "./Send.ts"
 
+import * as Diagnostic from "./_util/Diagnostic.ts"
+import * as Method from "./Method.ts"
+
+const { span } = Diagnostic.module("Actor")
+
 export const TypeId = "~liminal/Actor" as const
 
-export interface Service<ActorSelf, NameA, AttachmentFields extends Fields, EventDefinitions extends FieldsRecord> {
+export interface Service<
+  ActorSelf,
+  NameA,
+  AttachmentFields extends S.Struct.Fields,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
+> {
   readonly name: NameA
 
   readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>
@@ -19,13 +27,13 @@ export interface Service<ActorSelf, NameA, AttachmentFields extends Fields, Even
 
 export interface ActorDefinition<
   NameA,
-  AttachmentFields extends Fields,
+  AttachmentFields extends S.Struct.Fields,
   ClientSelf,
   ClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 > {
-  readonly name: S.Schema<NameA, string>
+  readonly name: S.Codec<NameA, string>
 
   readonly attachments: AttachmentFields
 
@@ -36,13 +44,13 @@ export interface Actor<
   ActorSelf,
   ActorId extends string,
   NameA,
-  AttachmentFields extends Fields,
+  AttachmentFields extends S.Struct.Fields,
   ActorClientSelf,
   ActorClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
-> extends Context.Tag<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>> {
-  new (_: never): Context.TagClassShape<ActorId, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>
+  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>>
 
   readonly [TypeId]: typeof TypeId
 
@@ -56,12 +64,12 @@ export interface Actor<
   >
 
   readonly schema: {
-    readonly attachments: S.Schema<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>
+    readonly attachments: S.Codec<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>
   }
 
   readonly sendAll: Send<ActorSelf, EventDefinitions>
 
-  readonly evict: Effect.Effect<void, never, ActorSelf>
+  readonly disconnectAll: Effect.Effect<void, never, ActorSelf>
 
   readonly handler: <K extends keyof MethodDefinitions, R>(
     tag: K,
@@ -74,31 +82,29 @@ export const Service =
   <
     ActorId extends string,
     NameA,
-    AttachmentFields extends Fields,
+    AttachmentFields extends S.Struct.Fields,
     ClientSelf,
     ClientId extends string,
     MethodDefinitions extends Record<string, MethodDefinition.Any>,
-    EventDefinitions extends FieldsRecord,
+    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.Tag(id)<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>()
+    const tag = Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>()(id)
 
-    const sendAll: Send<ActorSelf, EventDefinitions> = Effect.fnUntraced(function* (key, payload) {
-      const { clients } = yield* tag
-      yield* Effect.forEach(clients, (client) => client.send(key, payload), {
-        concurrency: "unbounded",
-      })
-    })
+    const sendAll: Send<ActorSelf, EventDefinitions> = (key, payload) =>
+      tag.asEffect().pipe(
+        Effect.flatMap(({ clients }) =>
+          Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
+        ),
+        span("sendAll"),
+      )
 
-    // TODO: more eviction
-    const evict = Effect.gen(function* () {
-      const { clients } = yield* tag
-      for (const client of clients) {
-        yield* client.disconnect
-      }
-    })
+    const disconnectAll = tag.asEffect().pipe(
+      Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)),
+      span("disconnectAll"),
+    )
 
     const handler = <K extends keyof MethodDefinitions, R>(
       _tag: K,
@@ -112,7 +118,7 @@ export const Service =
         attachments: S.Struct(definition.attachments) as never,
       },
       sendAll,
-      evict,
+      disconnectAll,
       handler,
     })
   }

package/Audition.ts

@@ -1,12 +1,14 @@
-import { Pipeable, Stream, Effect, Function, Console } from "effect"
+import { Schema as S, Pipeable, Stream, Effect, Function } from "effect"
 
-import type { FieldsRecord } from "./_types.ts"
 import type { F } from "./F.ts"
 import type * as Method from "./Method.ts"
 
+import * as Diagnostic from "./_util/Diagnostic.ts"
 import * as Client from "./Client.ts"
 import { type ClientError, AuditionError } from "./errors.ts"
 
+const { debug, span } = Diagnostic.module("Audition")
+
 const TypeId = "~liminal/Audition" as const
 
 export interface Audition<ClientSelf, MethodDefinitions extends Record<string, Method.MethodDefinition.Any>, Event>
@@ -23,8 +25,8 @@ export const empty: Audition<never, never, never> = {
   pipe() {
     return Pipeable.pipeArguments(this, arguments)
   },
-  events: Stream.fail(AuditionError.make()),
-  f: () => () => AuditionError.make(),
+  events: Stream.fail(new AuditionError()),
+  f: () => () => new AuditionError().asEffect(),
 }
 
 export const add: {
@@ -32,7 +34,7 @@ export const add: {
     ClientSelf,
     ClientId extends string,
     ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends FieldsRecord,
+    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
   >(
     client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
   ): <AuditionSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent>(
@@ -40,7 +42,7 @@ export const add: {
   ) => Audition<
     AuditionSelf | ClientSelf,
     Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
   >
   <
     AuditionClientSelf,
@@ -49,14 +51,14 @@ export const add: {
     ClientSelf,
     ClientId extends string,
     ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends FieldsRecord,
+    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
   >(
     audition: Audition<AuditionClientSelf, AuditionMethodDefinitions, AuditionEvent>,
     client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
   ): Audition<
     AuditionClientSelf | ClientSelf,
     Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
   >
 } = Function.dual(
   2,
@@ -67,14 +69,14 @@ export const add: {
     ClientSelf,
     ClientId extends string,
     ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends FieldsRecord,
+    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
   >(
     audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
     client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
   ): Audition<
     AuditionSelf | ClientSelf,
     Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
   > => {
     const f: F<
       AuditionSelf | ClientSelf,
@@ -82,12 +84,15 @@ export const add: {
     > = (method) => (payload) =>
       audition
         .f(method as never)(payload)
-        .pipe(Effect.catchTag("AuditionError", () => client.f(method as never)(payload)))
+        .pipe(
+          Effect.catchTag("AuditionError", () => client.f(method as never)(payload)),
+          span("f"),
+        )
 
     const events = audition.events.pipe(
       Stream.catchTag("AuditionError", () =>
         Effect.succeed(client.events).pipe(
-          Effect.tap(() => Console.log(`Auditioning ${client.key}`)),
+          Effect.tap(() => debug("AuditionStaged", { client: client.key })),
           Stream.unwrap,
         ),
       ),

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.17.2
+
+### Patch Changes
+
+- 366c080: Migrate to Effect v4.
+
 ## 0.17.1
 
 ### Patch Changes