effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/rpc/Rpc.ts

@@ -2,16 +2,19 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
+import type { Deferred } from "../../Deferred.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Exit as Exit_ } from "../../Exit.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 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"
@@ -31,9 +34,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
 }
@@ -61,8 +64,8 @@ export interface Rpc<
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly defectSchema: Schema.Top
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Middleware>
   readonly "~requires": Requires
 
@@ -132,18 +135,38 @@ export interface Rpc<
    * Add an annotation on the rpc.
    */
   annotate<I, S>(
-    tag: ServiceMap.Service<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.
  *
@@ -154,12 +177,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>
+  }) => Effect<{} | Deferred<any, any>, any> | Stream<any, any>
+  readonly context: Context.Context<never>
 }
 
 /**
@@ -170,6 +193,7 @@ export interface Any extends Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly _tag: string
   readonly key: string
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -183,8 +207,8 @@ export interface AnyWithProps extends Pipeable {
   readonly payloadSchema: Schema.Top
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
-  readonly defectSchema: DefectSchema
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly defectSchema: Schema.Top
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<RpcMiddleware.AnyServiceWithProps>
   readonly "~requires": any
 }
@@ -392,7 +416,7 @@ export type Middleware<R> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ? ServiceMap.Service.Identifier<_Middleware>
+> ? Context.Service.Identifier<_Middleware>
   : never
 
 /**
@@ -406,9 +430,7 @@ export type MiddlewareClient<R> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ?
-  _Middleware extends { readonly requiredForClient: true }
-    ? RpcMiddleware.ForClient<ServiceMap.Service.Identifier<_Middleware>>
+> ? _Middleware extends { readonly requiredForClient: true } ? RpcMiddleware.ForClient<_Middleware["Identifier"]>
   : never
   : never
 
@@ -475,12 +497,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
@@ -521,7 +543,7 @@ export type ExtractProvides<R extends Any, Tag extends string> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ? RpcMiddleware.Provides<_Middleware> :
+> ? RpcMiddleware.Provides<_Middleware["Identifier"]> :
   never
 
 /**
@@ -570,7 +592,7 @@ export type ResultFrom<R extends Any, Services> = R extends Rpc<
         Services
       > :
   Effect<
-    _Success["Type"],
+    _Success["Type"] | Deferred<_Success["Type"], _Error["Type"]>,
     _Error["Type"],
     Services
   > :
@@ -660,7 +682,7 @@ const Proto = {
       middlewares: this.middlewares
     })
   },
-  annotate(this: AnyWithProps, tag: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: AnyWithProps, tag: Context.Key<any, any>, value: any) {
     return makeProto({
       _tag: this._tag,
       payloadSchema: this.payloadSchema,
@@ -668,10 +690,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 +701,7 @@ const Proto = {
       errorSchema: this.errorSchema,
       defectSchema: this.defectSchema,
       middlewares: this.middlewares,
-      annotations: ServiceMap.merge(this.annotations, context)
+      annotations: Context.merge(this.annotations, context)
     })
   }
 }
@@ -696,8 +718,8 @@ const makeProto = <
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly defectSchema: Schema.Top
+  readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {
   function Rpc() {}
@@ -758,11 +780,146 @@ export const make = <
       successSchema,
     errorSchema: options?.stream ? Schema.Never : errorSchema,
     defectSchema,
-    annotations: ServiceMap.empty(),
+    annotations: Context.empty(),
     middlewares: new Set<never>()
   }) as any
 }
 
+/**
+ * Create a custom Rpc constructor, that can transform the output schemas.
+ *
+ * ```typescript
+ * import { Schema } from "effect"
+ * import { Rpc } from "effect/unstable/rpc"
+ *
+ * // Create a custom Rpc wrapper definition by transforming the success and error
+ * // schemas.
+ * export interface RpcWithPagination extends Rpc.Custom {
+ *   readonly out: Rpc.Custom.Out<
+ *     Paginated<this["success"]>,
+ *     this["error"]
+ *   >
+ * }
+ *
+ * // The type definition for the transformed success schema.
+ * export interface Paginated<S extends Schema.Top> extends
+ *   Schema.Struct<{
+ *     readonly offset: Schema.Number
+ *     readonly total: Schema.Number
+ *     readonly results: Schema.$Array<S>
+ *   }>
+ * {}
+ *
+ * // You can then implement the schema transformation using `Rpc.custom`
+ * export const makePaginated = Rpc.custom<RpcWithPagination>((schemas) => ({
+ *   ...schemas,
+ *   success: Schema.Struct({
+ *     offset: Schema.Number,
+ *     total: Schema.Number,
+ *     results: Schema.Array(schemas.success)
+ *   })
+ * }))
+ *
+ * // You can then use the custom constructor in the same way `Rpc.make` is used.
+ * export const listAllRpc = makePaginated("listAll", {
+ *   success: Schema.String
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export const custom = <Def extends Custom>(
+  f: (options: Custom.OutDefault) => (Def & Custom.OutDefault)["out"]
+) =>
+<
+  const Tag extends string,
+  Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+  Success extends Schema.Top = Schema.Void,
+  Error extends Schema.Top = Schema.Never,
+  const Stream extends boolean = false,
+  Out extends Custom.OutDefault = Custom.Kind<Def, Success, Error>
+>(tag: Tag, options?: {
+  readonly payload?: Payload
+  readonly success?: Success
+  readonly error?: Error
+  readonly defect?: DefectSchema
+  readonly stream?: Stream
+  readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
+      payload: Payload extends Schema.Struct.Fields ? Struct.Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+    ) => string) :
+    never
+}): Rpc<
+  Tag,
+  Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+  Stream extends true ? RpcSchema.Stream<Out["success"], Out["error"]> : Out["success"],
+  Stream extends true ? typeof Schema.Never : Out["error"]
+> => {
+  const success = options?.success ?? Schema.Void
+  const error = options?.error ?? Schema.Never
+  const defect = options?.defect ?? Schema.Defect
+  const out = f({
+    success,
+    error,
+    defect
+  })
+  return make(tag, {
+    ...out,
+    primaryKey: options?.primaryKey,
+    payload: options?.payload,
+    stream: options?.stream
+  }) as any
+}
+
+/**
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export interface Custom {
+  readonly out: Custom.OutDefault
+  readonly success: Schema.Top
+  readonly error: Schema.Top
+  readonly defect: DefectSchema
+}
+
+/**
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export declare namespace Custom {
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export interface Out<
+    Success extends Schema.Top,
+    Error extends Schema.Top
+  > {
+    readonly success: Success
+    readonly error: Error
+    readonly defect: DefectSchema
+  }
+
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export type OutDefault = Out<Schema.Top, Schema.Top>
+
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export type Kind<
+    Def extends Custom,
+    Success extends Schema.Top,
+    Error extends Schema.Top
+  > = (Def & {
+    readonly success: Success
+    readonly error: Error
+  })["out"]
+}
+
 const exitSchemaCache = new WeakMap<Any, Schema.Exit<Schema.Top, Schema.Top, DefectSchema>>()
 
 /**
@@ -782,14 +939,14 @@ export const exitSchema = <R extends Any>(
   const rpc = self as any as AnyWithProps
   const failures = new Set<Schema.Top>([rpc.errorSchema])
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
-  if (streamSchemas) {
-    failures.add(streamSchemas.error)
+  if (Option.isSome(streamSchemas)) {
+    failures.add(streamSchemas.value.error)
   }
   for (const middleware of rpc.middlewares) {
     failures.add(middleware.error)
   }
   const schema = Schema.Exit(
-    streamSchemas ? Schema.Void : rpc.successSchema,
+    Option.isSome(streamSchemas) ? Schema.Void : rpc.successSchema,
     Schema.Union([...failures]),
     rpc.defectSchema
   )
@@ -810,6 +967,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 +1002,23 @@ export const wrap = (options: {
       uninterruptible: options.uninterruptible ?? false
     }
 
+/**
+ * @since 4.0.0
+ * @category Wrapper
+ */
+export const unwrap = <A extends object>(value: WrapperOr<A>): A => isWrapper(value) ? value.value : value
+
+/**
+ * @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