effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/unstable/rpc/RpcGroup.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
@@ -9,7 +10,6 @@ import type { Pipeable } from "../../Pipeable.ts"
 import type * as Queue from "../../Queue.ts"
 import type * as Record from "../../Record.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type { Headers } from "../http/Headers.ts"
 import * as Rpc from "./Rpc.ts"
@@ -27,7 +27,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
 
   readonly [TypeId]: typeof TypeId
   readonly requests: ReadonlyMap<string, R>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * Add one or more procedures to the group.
@@ -43,6 +43,13 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
     ...groups: Groups
   ): RpcGroup<R | Rpcs<Groups[number]>>
 
+  /**
+   * Omit one or more procedures from the group.
+   */
+  omit<const Tags extends ReadonlyArray<R["_tag"]>>(
+    ...tags: Tags
+  ): RpcGroup<Exclude<R, { readonly _tag: Tags[number] }>>
+
   /**
    * Add middleware to all the procedures added to the group until this point.
    */
@@ -66,7 +73,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
       | Handlers
       | Effect.Effect<Handlers, EX, RX>
   ): Effect.Effect<
-    ServiceMap.ServiceMap<Rpc.ToHandler<R>>,
+    Context.Context<Rpc.ToHandler<R>>,
     EX,
     | RX
     | HandlersServices<R, Handlers>
@@ -119,7 +126,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
     (
       payload: Rpc.Payload<Extract<R, { readonly _tag: Tag }>>,
       options: {
-        readonly clientId: number
+        readonly client: Rpc.ServerClient
         readonly requestId: RequestId
         readonly headers: Headers
       }
@@ -131,22 +138,22 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
   /**
    * Annotate the group with a value.
    */
-  annotate<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotate<I, S>(service: Context.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotateRpcs<I, S>(service: Context.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the group with the provided annotations.
    */
-  annotateMerge<S>(annotations: ServiceMap.ServiceMap<S>): RpcGroup<R>
+  annotateMerge<S>(annotations: Context.Context<S>): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with the provided annotations.
    */
-  annotateRpcsMerge<S>(annotations: ServiceMap.ServiceMap<S>): RpcGroup<R>
+  annotateRpcsMerge<S>(annotations: Context.Context<S>): RpcGroup<R>
 }
 
 /**
@@ -184,8 +191,8 @@ export type HandlersServices<Rpcs extends Rpc.Any, Handlers> = keyof Handlers ex
  * @since 4.0.0
  * @category groups
  */
-export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends
-  [true] ? Handler extends (...args: any) =>
+export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = true extends
+  Rpc.IsStream<Rpcs, K> ? Handler extends (...args: any) =>
     | Stream.Stream<infer _A, infer _E, infer _R>
     | Rpc.Wrapper<Stream.Stream<infer _A, infer _E, infer _R>>
     | Effect.Effect<
@@ -204,7 +211,7 @@ export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handle
   Handler extends (
     ...args: any
   ) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Wrapper<Effect.Effect<infer _A, infer _E, infer _R>> ?
-    Rpc.ExcludeProvides<_R, Rpcs, K> | Rpc.ExtractRequires<Rpcs, K>
+    Exclude<Rpc.ExcludeProvides<_R, Rpcs, K>, Scope> | Rpc.ExtractRequires<Rpcs, K>
   : never
 
 /**
@@ -239,7 +246,17 @@ const RpcGroupProto = {
 
     return makeProto({
       requests,
-      annotations: ServiceMap.makeUnsafe(annotations)
+      annotations: Context.makeUnsafe(annotations)
+    })
+  },
+  omit(this: RpcGroup<any>, ...tags: Array<string>) {
+    const requests = new Map(this.requests)
+    for (const tag of tags) {
+      requests.delete(tag)
+    }
+    return makeProto({
+      requests,
+      annotations: this.annotations
     })
   },
   middleware(this: RpcGroup<any>, middleware: RpcMiddleware.AnyService) {
@@ -256,7 +273,7 @@ const RpcGroupProto = {
     // oxlint-disable-next-line no-this-alias
     const self = this
     return Effect.gen(function*() {
-      const services = yield* Effect.services<never>()
+      const services = yield* Effect.context<never>()
       const handlers = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
       for (const [tag, handler] of Object.entries(handlers)) {
@@ -264,10 +281,10 @@ const RpcGroupProto = {
         contextMap.set(rpc.key, {
           tag: rpc._tag,
           handler,
-          services
+          context: services
         })
       }
-      return ServiceMap.makeUnsafe(contextMap)
+      return Context.makeUnsafe(contextMap)
     })
   },
   prefix<const Prefix extends string>(this: RpcGroup<any>, prefix: Prefix) {
@@ -282,57 +299,57 @@ const RpcGroupProto = {
     })
   },
   toLayer(this: RpcGroup<any>, build: Effect.Effect<Record<string, (request: any) => any>>) {
-    return Layer.effectServices(this.toHandlers(build))
+    return Layer.effectContext(this.toHandlers(build))
   },
   of: identity,
   toLayerHandler(this: RpcGroup<any>, service: string, build: Effect.Effect<Record<string, (request: any) => any>>) {
     // oxlint-disable-next-line no-this-alias
     const self = this
-    return Layer.effectServices(Effect.gen(function*() {
-      const services = yield* Effect.services<never>()
+    return Layer.effectContext(Effect.gen(function*() {
+      const services = yield* Effect.context<never>()
       const handler = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
       const rpc = self.requests.get(service)!
       contextMap.set(rpc.key, {
         handler,
-        services
+        context: services
       })
-      return ServiceMap.makeUnsafe(contextMap)
+      return Context.makeUnsafe(contextMap)
     }))
   },
   accessHandler(this: RpcGroup<any>, service: string) {
-    return Effect.servicesWith((parentServices: ServiceMap.ServiceMap<any>) => {
+    return Effect.contextWith((parentContext: Context.Context<any>) => {
       const rpc = this.requests.get(service)!
-      const { handler, services } = parentServices.mapUnsafe.get(rpc.key) as Rpc.Handler<any>
+      const { handler, context } = parentContext.mapUnsafe.get(rpc.key) as Rpc.Handler<any>
       return Effect.succeed((payload: Rpc.Payload<any>, options: any) => {
         options.rpc = rpc
         const result = handler(payload, options)
         const effectOrStream = Rpc.isWrapper(result) ? result.value : result
         return Effect.isEffect(effectOrStream)
-          ? Effect.provide(effectOrStream, services)
-          : Stream.provideServices(effectOrStream, services)
+          ? Effect.provide(effectOrStream, context)
+          : Stream.provideContext(effectOrStream, context)
       })
     })
   },
-  annotate(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: RpcGroup<any>, service: Context.Key<any, any>, value: any) {
     return makeProto({
       requests: this.requests,
-      annotations: ServiceMap.add(this.annotations, service, value)
+      annotations: Context.add(this.annotations, service, value)
     })
   },
-  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
-    return this.annotateRpcsMerge(ServiceMap.make(service, value))
+  annotateRpcs(this: RpcGroup<any>, service: Context.Key<any, any>, value: any) {
+    return this.annotateRpcsMerge(Context.make(service, value))
   },
-  annotateMerge(this: RpcGroup<any>, context: ServiceMap.ServiceMap<any>) {
+  annotateMerge(this: RpcGroup<any>, context: Context.Context<any>) {
     return makeProto({
       requests: this.requests,
-      annotations: ServiceMap.merge(this.annotations, context)
+      annotations: Context.merge(this.annotations, context)
     })
   },
-  annotateRpcsMerge(this: RpcGroup<any>, serviceMap: ServiceMap.ServiceMap<any>) {
+  annotateRpcsMerge(this: RpcGroup<any>, context: Context.Context<any>) {
     const requests = new Map<string, any>()
     for (const [tag, rpc] of this.requests) {
-      requests.set(tag, rpc.annotateMerge(ServiceMap.merge(serviceMap, rpc.annotations)))
+      requests.set(tag, rpc.annotateMerge(Context.merge(context, rpc.annotations)))
     }
     return makeProto({
       requests,
@@ -343,7 +360,7 @@ const RpcGroupProto = {
 
 const makeProto = <Rpcs extends Rpc.Any>(options: {
   readonly requests: ReadonlyMap<string, Rpcs>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }): RpcGroup<Rpcs> =>
   Object.assign(function() {}, RpcGroupProto, {
     requests: options.requests,
@@ -359,5 +376,5 @@ export const make = <const Rpcs extends ReadonlyArray<Rpc.Any>>(
 ): RpcGroup<Rpcs[number]> =>
   makeProto({
     requests: new Map(rpcs.map((rpc) => [rpc._tag, rpc])),
-    annotations: ServiceMap.empty()
+    annotations: Context.empty()
   })

package/src/unstable/rpc/RpcMiddleware.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Mutable, unhandled } from "../../Types.ts"
 import type { Headers } from "../http/Headers.ts"
 import type * as Rpc from "./Rpc.ts"
@@ -31,7 +31,7 @@ export interface RpcMiddleware<Provides, E, Requires> {
   (
     effect: Effect.Effect<SuccessValue, E | unhandled, Provides>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown
@@ -77,7 +77,7 @@ export interface Any {
   (
     effect: Effect.Effect<SuccessValue, any, any>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown
@@ -109,9 +109,10 @@ export interface ServiceClass<
   Provides,
   E extends Schema.Top,
   ClientError,
-  Requires
-> extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
-  new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
+  Requires,
+  RequiredForClient extends boolean
+> extends Context.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
+  new(_: never): Context.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
       readonly error: E
       readonly provides: Provides
@@ -121,7 +122,7 @@ export interface ServiceClass<
   }
   readonly [TypeId]: typeof TypeId
   readonly error: E
-  readonly requiredForClient: boolean
+  readonly requiredForClient: RequiredForClient
   readonly "~ClientError": ClientError
 }
 
@@ -173,7 +174,7 @@ export type ErrorServicesDecode<A> = ErrorSchema<A>["DecodingServices"]
  * @since 4.0.0
  * @category models
  */
-export interface AnyService extends ServiceMap.Service<any, any> {
+export interface AnyService extends Context.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -184,7 +185,7 @@ export interface AnyService extends ServiceMap.Service<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyServiceWithProps extends ServiceMap.Service<any, RpcMiddleware<any, any, any>> {
+export interface AnyServiceWithProps extends Context.Key<any, RpcMiddleware<any, any, any>> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -201,16 +202,20 @@ export const Service = <
     requires?: any
     provides?: any
     clientError?: any
-  } = { requires: never; provides: never; clientError: never }
+  } = {
+    requires: never
+    provides: never
+    clientError: never
+  }
 >(): <
   const Name extends string,
   Error extends Schema.Top = Schema.Never,
-  RequiredForClient extends boolean = false
+  const RequiredForClient extends boolean = false
 >(
   id: Name,
   options?: {
     readonly error?: Error | undefined
-    readonly requiredForClient: RequiredForClient | undefined
+    readonly requiredForClient?: RequiredForClient | undefined
   } | undefined
 ) => ServiceClass<
   Self,
@@ -218,7 +223,8 @@ export const Service = <
   "provides" extends keyof Config ? Config["provides"] : never,
   Error,
   "clientError" extends keyof Config ? Config["clientError"] : never,
-  "requires" extends keyof Config ? Config["requires"] : never
+  "requires" extends keyof Config ? Config["requires"] : never,
+  RequiredForClient
 > =>
 (
   id: string,
@@ -235,7 +241,7 @@ export const Service = <
 
   function ServiceClass() {}
   const ServiceClass_ = ServiceClass as any as Mutable<AnyService>
-  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(ServiceMap.Service<Self, any>(id)))
+  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(Context.Service<Self, any>(id)))
   ServiceClass.key = id
   Object.defineProperty(ServiceClass, "stack", {
     get() {
@@ -253,23 +259,23 @@ export const Service = <
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Service<Id, S>,
+  tag: Context.Key<Id, S>,
   service:
     | RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>
     | Effect.Effect<RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>, EX, RX>
 ): Layer.Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = (yield* Effect.services<R | Scope>()).pipe(
-      ServiceMap.omit(Scope)
-    ) as ServiceMap.ServiceMap<R>
+  Layer.effectContext(Effect.gen(function*() {
+    const services = (yield* Effect.context<R | Scope>()).pipe(
+      Context.omit(Scope)
+    ) as Context.Context<R>
     const middleware = Effect.isEffect(service) ? yield* service : service
-    return ServiceMap.makeUnsafe(
+    return Context.makeUnsafe(
       new Map([[
         `${tag.key}/Client`,
         (options: any) =>
-          Effect.updateServices(
+          Effect.updateContext(
             middleware(options),
-            (requestContext) => ServiceMap.merge(services, requestContext)
+            (requestContext) => Context.merge(services, requestContext)
           )
       ]])
     )

package/src/unstable/rpc/RpcSchema.ts

@@ -1,6 +1,10 @@
 /**
  * @since 4.0.0
  */
+import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
+import { constUndefined } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
@@ -17,16 +21,16 @@ export function isStreamSchema(schema: Schema.Top): schema is Stream<Schema.Top,
 }
 
 /** @internal */
-export function getStreamSchemas(schema: Schema.Top): {
+export function getStreamSchemas(schema: Schema.Top): Option.Option<{
   readonly success: Schema.Top
   readonly error: Schema.Top
-} | undefined {
+}> {
   return isStreamSchema(schema) ?
-    {
+    Option.some({
       success: schema.success,
       error: schema.error
-    } :
-    undefined
+    }) :
+    Option.none()
 }
 
 /**
@@ -43,7 +47,7 @@ export interface Stream<A extends Schema.Top, E extends Schema.Top> extends
     Stream<A, E>
   >
 {
-  readonly "~rebuild.out": this
+  readonly "Rebuild": Stream<A, E>
   readonly [StreamSchemaTypeId]: typeof StreamSchemaTypeId
   readonly success: A
   readonly error: E
@@ -58,3 +62,17 @@ const schema = Schema.declare(Stream_.isStream)
 export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
+
+/**
+ * @since 4.0.0
+ * @category Cause annotations
+ */
+export class ClientAbort extends Context.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.context(true).pipe(
+    Context.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}