effect 4.0.0-beta.43 → 4.0.0-beta.45

package/src/unstable/reactivity/AtomRpc.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Hash from "../../Hash.ts"
@@ -8,7 +9,6 @@ import * as Layer from "../../Layer.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type { Mutable, NoInfer } from "../../Types.ts"
 import * as Headers from "../http/Headers.ts"
@@ -27,17 +27,16 @@ import * as Reactivity from "./Reactivity.ts"
  * @category Models
  */
 export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> extends
-  ServiceMap.Service<
+  Context.Service<
     Self,
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >
 {
-  new(_: never): ServiceMap.ServiceClass.Shape<
+  new(_: never): Context.ServiceClass.Shape<
     Id,
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >
 
-  readonly layer: Layer.Layer<Self>
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(
@@ -120,7 +119,9 @@ export const Service = <Self>() =>
   id: Id,
   options: {
     readonly group: RpcGroup.RpcGroup<Rpcs>
-    readonly protocol: Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>
+    readonly protocol:
+      | Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>
+      | ((get: Atom.AtomContext) => Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>)
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
     readonly generateRequestId?: (() => RequestId) | undefined
@@ -135,12 +136,12 @@ export const Service = <Self>() =>
     readonly runtime?: Atom.RuntimeFactory | undefined
   }
 ): AtomRpcClient<Self, Id, Rpcs> => {
-  const self: Mutable<AtomRpcClient<Self, Id, Rpcs>> = ServiceMap.Service<
+  const self: Mutable<AtomRpcClient<Self, Id, Rpcs>> = Context.Service<
     Self,
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >()(id) as any
 
-  self.layer = Layer.effect(
+  const layer = Layer.effect(
     self,
     options.makeEffect ??
       (RpcClient.make(options.group, {
@@ -151,9 +152,19 @@ export const Service = <Self>() =>
         never,
         RM
       >)
-  ).pipe(Layer.provide(Layer.orDie(options.protocol)))
+  )
   const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(self.layer)
+  self.runtime = runtimeFactory(
+    typeof options.protocol === "function" ?
+      (get) =>
+        Layer.provide(
+          layer,
+          Layer.orDie(
+            (options.protocol as ((get: Atom.AtomContext) => Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>))(get)
+          )
+        ) :
+      Layer.provide(layer, Layer.orDie(options.protocol))
+  )
 
   self.mutation = Atom.family(<Tag extends Rpc.Tag<Rpcs>>(tag: Tag) => {
     const rpc = options.group.requests.get(tag)! as any as Rpc.AnyWithProps

package/src/unstable/reactivity/Reactivity.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -10,14 +11,13 @@ import * as Layer from "../../Layer.ts"
 import * as Queue from "../../Queue.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class Reactivity extends ServiceMap.Service<
+export class Reactivity extends Context.Service<
   Reactivity,
   {
     readonly invalidateUnsafe: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => void
@@ -62,7 +62,7 @@ export const make = Effect.sync(() => {
   const invalidate = (
     keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>
   ): Effect.Effect<void> =>
-    Effect.servicesWith((services) => {
+    Effect.contextWith((services) => {
       const pending = services.mapUnsafe.get(PendingInvalidation.key) as Set<string | number> | undefined
       if (pending) {
         keysToHashes(keys, (hash) => {
@@ -109,8 +109,8 @@ export const make = Effect.sync(() => {
     effect: Effect.Effect<A, E, R>
   ): Effect.Effect<Queue.Dequeue<A, E>, never, R | Scope.Scope> =>
     Effect.gen(function*() {
-      const services = yield* Effect.services<Scope.Scope | R>()
-      const scope = ServiceMap.get(services, Scope.Scope)
+      const services = yield* Effect.context<Scope.Scope | R>()
+      const scope = Context.get(services, Scope.Scope)
       const results = yield* Queue.make<A, E>()
       const runFork = flow(Effect.runForkWith(services), Fiber.runIn(scope))
 
@@ -183,7 +183,7 @@ export const make = Effect.sync(() => {
   })
 })
 
-class PendingInvalidation extends ServiceMap.Service<PendingInvalidation, Set<string | number>>()(
+class PendingInvalidation extends Context.Service<PendingInvalidation, Set<string | number>>()(
   "effect/reactivity/Reactivity/PendingInvalidation"
 ) {}
 

package/src/unstable/rpc/Rpc.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Exit as Exit_ } from "../../Exit.ts"
 import * as Option from "../../Option.ts"
@@ -10,9 +11,9 @@ import * as Predicate from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import type * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Stream } from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
+import type { NoInfer } from "../../Types.ts"
 import type { Headers } from "../http/Headers.ts"
 import type { RequestId } from "./RpcMessage.ts"
 import type * as RpcMiddleware from "./RpcMiddleware.ts"
@@ -32,9 +33,9 @@ export const isRpc = (u: unknown): u is Rpc<any, any, any> => Predicate.hasPrope
  */
 export interface DefectSchema extends Schema.Top {
   readonly Type: unknown
-  makeUnsafe(input: null, options?: Schema.MakeOptions): unknown
-  makeUnsafe(input: undefined, options?: Schema.MakeOptions): unknown
-  makeUnsafe(input: {}, options?: Schema.MakeOptions): unknown
+  make(input: null, options?: Schema.MakeOptions): unknown
+  make(input: undefined, options?: Schema.MakeOptions): unknown
+  make(input: {}, options?: Schema.MakeOptions): unknown
   readonly DecodingServices: never
   readonly EncodingServices: never
 }
@@ -63,7 +64,7 @@ export interface Rpc<
   readonly successSchema: Success
   readonly errorSchema: Error
   readonly defectSchema: Schema.Top
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Middleware>
   readonly "~requires": Requires
 
@@ -133,18 +134,38 @@ export interface Rpc<
    * Add an annotation on the rpc.
    */
   annotate<I, S>(
-    tag: ServiceMap.Key<I, S>,
-    value: S
+    tag: Context.Key<I, S>,
+    value: NoInfer<S>
   ): Rpc<Tag, Payload, Success, Error, Middleware, Requires>
 
   /**
    * Merge the annotations of the rpc with the provided annotations.
    */
   annotateMerge<I>(
-    annotations: ServiceMap.ServiceMap<I>
+    annotations: Context.Context<I>
   ): Rpc<Tag, Payload, Success, Error, Middleware, Requires>
 }
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export class ServerClient {
+  readonly id: number
+  annotations: Context.Context<never>
+  constructor(id: number) {
+    this.id = id
+    this.annotations = Context.empty()
+  }
+  annotate<I, S>(
+    tag: Context.Key<I, S>,
+    value: NoInfer<S>
+  ): ServerClient {
+    this.annotations = Context.add(this.annotations, tag, value)
+    return this
+  }
+}
+
 /**
  * Represents an implemented rpc.
  *
@@ -155,12 +176,12 @@ export interface Handler<Tag extends string> {
   readonly _: unique symbol
   readonly tag: Tag
   readonly handler: (request: any, options: {
-    readonly clientId: number
+    readonly client: ServerClient
     readonly requestId: RequestId
     readonly headers: Headers
     readonly rpc: Any
   }) => Effect<any, any> | Stream<any, any>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
 }
 
 /**
@@ -171,7 +192,7 @@ export interface Any extends Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly _tag: string
   readonly key: string
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -186,7 +207,7 @@ export interface AnyWithProps extends Pipeable {
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
   readonly defectSchema: Schema.Top
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<RpcMiddleware.AnyServiceWithProps>
   readonly "~requires": any
 }
@@ -394,7 +415,7 @@ export type Middleware<R> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ? ServiceMap.Service.Identifier<_Middleware>
+> ? Context.Service.Identifier<_Middleware>
   : never
 
 /**
@@ -475,12 +496,12 @@ export type ToHandler<R extends Any> = R extends Rpc<
 export type ToHandlerFn<Current extends Any, R = any> = (
   payload: Payload<Current>,
   options: {
-    readonly clientId: number
+    readonly client: ServerClient
     readonly requestId: RequestId
     readonly headers: Headers
     readonly rpc: Current
   }
-) => ResultFrom<Current, R> | Wrapper<ResultFrom<Current, R>>
+) => WrapperOr<ResultFrom<Current, R>>
 
 /**
  * @since 4.0.0
@@ -660,7 +681,7 @@ const Proto = {
       middlewares: this.middlewares
     })
   },
-  annotate(this: AnyWithProps, tag: ServiceMap.Key<any, any>, value: any) {
+  annotate(this: AnyWithProps, tag: Context.Key<any, any>, value: any) {
     return makeProto({
       _tag: this._tag,
       payloadSchema: this.payloadSchema,
@@ -668,10 +689,10 @@ const Proto = {
       errorSchema: this.errorSchema,
       defectSchema: this.defectSchema,
       middlewares: this.middlewares,
-      annotations: ServiceMap.add(this.annotations, tag, value)
+      annotations: Context.add(this.annotations, tag, value)
     })
   },
-  annotateMerge(this: AnyWithProps, context: ServiceMap.ServiceMap<any>) {
+  annotateMerge(this: AnyWithProps, context: Context.Context<any>) {
     return makeProto({
       _tag: this._tag,
       payloadSchema: this.payloadSchema,
@@ -679,7 +700,7 @@ const Proto = {
       errorSchema: this.errorSchema,
       defectSchema: this.defectSchema,
       middlewares: this.middlewares,
-      annotations: ServiceMap.merge(this.annotations, context)
+      annotations: Context.merge(this.annotations, context)
     })
   }
 }
@@ -697,7 +718,7 @@ const makeProto = <
   readonly successSchema: Success
   readonly errorSchema: Error
   readonly defectSchema: Schema.Top
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {
   function Rpc() {}
@@ -758,7 +779,7 @@ export const make = <
       successSchema,
     errorSchema: options?.stream ? Schema.Never : errorSchema,
     defectSchema,
-    annotations: ServiceMap.empty(),
+    annotations: Context.empty(),
     middlewares: new Set<never>()
   }) as any
 }
@@ -810,6 +831,12 @@ export interface Wrapper<A> {
   readonly uninterruptible: boolean
 }
 
+/**
+ * @since 4.0.0
+ * @category Wrapper
+ */
+export type WrapperOr<A> = A | Wrapper<A>
+
 /**
  * @since 4.0.0
  * @category Wrapper
@@ -839,6 +866,17 @@ export const wrap = (options: {
       uninterruptible: options.uninterruptible ?? false
     }
 
+/**
+ * @since 4.0.0
+ * @category Wrapper
+ */
+export const wrapMap = <A extends object, B extends object>(self: WrapperOr<A>, f: (value: A) => B): WrapperOr<B> => {
+  if (isWrapper(self)) {
+    return wrap(self)(f(self.value))
+  }
+  return f(self)
+}
+
 /**
  * You can use `fork` to wrap a response Effect or Stream, to ensure that the
  * response is executed concurrently regardless of the RpcServer concurrency