effect 4.0.0-beta.49 → 4.0.0-beta.50

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -4,7 +4,6 @@
 import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import * as Hash from "../../Hash.ts"
 import * as Layer from "../../Layer.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
@@ -105,6 +104,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
           readonly timeToLive?: Duration.Input | undefined
+          readonly serializationKey?: string | undefined
         }
       >
       : never
@@ -239,10 +239,10 @@ export const Service = <Self>() =>
         HttpClientError.HttpClientError | SchemaError
       >)
     }))
-    if (opts.responseMode === "decoded-only") {
+    if (opts.responseMode === "decoded-only" && opts.serializationKey) {
       const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
       atom = Atom.serializable(atom, {
-        key: makeSerializableKey(opts),
+        key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
         schema: AsyncResult.Schema({
           success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
           error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
@@ -270,9 +270,10 @@ export const Service = <Self>() =>
       readonly responseMode?: HttpApiEndpoint.ClientResponseMode
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
       readonly timeToLive?: Duration.Input | undefined
+      readonly serializationKey?: string | undefined
     }
-  ) =>
-    queryFamily({
+  ) => {
+    const key: QueryKey = {
       group,
       endpoint,
       params: request.params,
@@ -283,8 +284,11 @@ export const Service = <Self>() =>
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
         ? Duration.fromInputUnsafe(request.timeToLive)
-        : undefined
-    })) as any
+        : undefined,
+      serializationKey: request.serializationKey
+    }
+    return queryFamily(key)
+  }) as any
 
   return self as AtomHttpApiClient<Self, Id, Groups>
 }
@@ -303,15 +307,12 @@ interface QueryKey {
   headers: any
   payload: any
   responseMode: HttpApiEndpoint.ClientResponseMode
-  reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-  timeToLive?: Duration.Duration | undefined
+  reactivityKeys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+  timeToLive: Duration.Duration | undefined
+  serializationKey: string | undefined
 }
 
 type ResponseByMode<Success, ResponseMode extends HttpApiEndpoint.ClientResponseMode> = [ResponseMode] extends
   ["decoded-and-response"] ? [Success, HttpClientResponse]
   : [ResponseMode] extends ["response-only"] ? HttpClientResponse
   : Success
-
-const makeSerializableKey = (
-  key: QueryKey
-): string => `AtomHttpApi:${key.group}:${key.endpoint}:${Hash.hash(key)}`

package/src/unstable/reactivity/AtomRpc.ts

@@ -4,7 +4,6 @@
 import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import * as Hash from "../../Hash.ts"
 import * as Layer from "../../Layer.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
@@ -73,6 +72,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
       readonly timeToLive?: Duration.Input | undefined
+      readonly serializationKey?: string | undefined
     }
   ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
     infer _Tag,
@@ -212,9 +212,9 @@ export const Service = <Self>() =>
         : self.runtime.atom(
           self.use((client) => client(tag, payload, { headers } as any)) as any
         )
-      if (!isStream) {
+      if (!isStream && key.serializationKey) {
         atom = Atom.serializable(atom, {
-          key: makeSerializableKey(key),
+          key: `AtomRpc:${key.tag}:${key.serializationKey}`,
           schema: AsyncResult.Schema({
             success: rpc.successSchema,
             error: makeErrorSchema(rpc)
@@ -242,9 +242,10 @@ export const Service = <Self>() =>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
       readonly timeToLive?: Duration.Input | undefined
+      readonly serializationKey?: string | undefined
     }
-  ) =>
-    queryFamily({
+  ) => {
+    const key: QueryKey = {
       tag,
       payload,
       headers: options?.headers
@@ -253,8 +254,11 @@ export const Service = <Self>() =>
       reactivityKeys: options?.reactivityKeys,
       timeToLive: options?.timeToLive
         ? Duration.fromInputUnsafe(options.timeToLive)
-        : undefined
-    }) as any
+        : undefined,
+      serializationKey: options?.serializationKey
+    }
+    return queryFamily(key) as any
+  }
 
   return self as AtomRpcClient<Self, Id, Rpcs>
 }
@@ -262,12 +266,13 @@ export const Service = <Self>() =>
 interface QueryKey {
   tag: string
   payload: any
-  headers?: Headers.Headers | undefined
-  reactivityKeys?:
+  headers: Headers.Headers | undefined
+  reactivityKeys:
     | ReadonlyArray<unknown>
     | ReadonlyRecord<string, ReadonlyArray<unknown>>
     | undefined
-  timeToLive?: Duration.Duration | undefined
+  timeToLive: Duration.Duration | undefined
+  serializationKey: string | undefined
 }
 
 const makeErrorSchema = (rpc: Rpc.AnyWithProps): Schema.Top =>
@@ -276,5 +281,3 @@ const makeErrorSchema = (rpc: Rpc.AnyWithProps): Schema.Top =>
     ...Array.from(rpc.middlewares, (middleware) => middleware.error),
     RpcClientError
   ])
-
-const makeSerializableKey = (key: QueryKey): string => `AtomRpc:${key.tag}:${Hash.hash(key)}`

package/src/unstable/rpc/Rpc.ts

@@ -3,6 +3,7 @@
  */
 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"
@@ -180,7 +181,7 @@ export interface Handler<Tag extends string> {
     readonly requestId: RequestId
     readonly headers: Headers
     readonly rpc: Any
-  }) => Effect<any, any> | Stream<any, any>
+  }) => Effect<{} | Deferred<any, any>, any> | Stream<any, any>
   readonly context: Context.Context<never>
 }
 
@@ -591,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
   > :
@@ -866,6 +867,12 @@ 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

package/src/unstable/rpc/RpcServer.ts

@@ -252,28 +252,45 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     // unwrap the fork data type
     const streamOrEffect = isWrapper ? result.value : result
     const handler = isStream
-      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<any>)
-      : (streamOrEffect as Effect.Effect<any>)
+      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<{} | Deferred.Deferred<any, any>>)
+      : (streamOrEffect as Effect.Effect<{} | Deferred.Deferred<any, any>>)
 
     const withMiddleware = rpc.middlewares.size > 0
       ? applyMiddleware(services, handler, metadata)
       : handler
     let responded = false
     const scope = Scope.makeUnsafe()
+    let deferred: Deferred.Deferred<unknown, unknown> | undefined = undefined
     let effect = Effect.onExit(withMiddleware, (exit) => {
       responded = true
-      const close = Scope.closeUnsafe(scope, exit)
-      const write = exit._tag === "Failure" &&
-          !disableFatalDefects &&
-          Cause.hasDies(exit.cause) &&
-          !Cause.hasInterrupts(exit.cause)
-        ? sendDefect(client, Cause.squash(exit.cause))
-        : options.onFromServer({
+      let write: Effect.Effect<void>
+      if (exit._tag === "Success") {
+        if (Deferred.isDeferred(exit.value)) {
+          deferred = exit.value
+          write = Effect.void
+        } else {
+          write = options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          })
+        }
+      } else if (
+        !disableFatalDefects &&
+        Cause.hasDies(exit.cause) &&
+        !Cause.hasInterrupts(exit.cause)
+      ) {
+        write = sendDefect(client, Cause.squash(exit.cause))
+      } else {
+        write = options.onFromServer({
           _tag: "Exit",
           clientId: client.id,
           requestId: request.id,
-          exit
+          exit: exit as any
         })
+      }
+      const close = Scope.closeUnsafe(scope, exit)
       if (exit._tag === "Failure") {
         reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
       }
@@ -304,7 +321,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       })
     }
     if (!isFork && concurrencySemaphore) {
-      effect = concurrencySemaphore.withPermits(1)(effect)
+      effect = concurrencySemaphore.withPermit(effect)
     }
     const context = new Map(entry.context.mapUnsafe)
     requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value))
@@ -317,7 +334,20 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       )
     )
     client.fibers.set(request.id, fiber)
-    fiber.addObserver((exit) => {
+    fiber.addObserver(function onExit(exit: Exit.Exit<any, any>): void {
+      if (deferred) {
+        const fiber = trackFiber(runFork(Effect.onExit(Deferred.await(deferred), (exit) =>
+          options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          }))))
+        client.fibers.set(request.id, fiber)
+        deferred = undefined
+        fiber.addObserver(onExit)
+        return
+      }
       if (!responded && exit._tag === "Failure") {
         trackFiber(
           runFork(
@@ -415,7 +445,7 @@ const applyMiddleware = <A, E, R>(
     readonly client: Rpc.ServerClient
     readonly requestId: RequestId
     readonly headers: Headers.Headers
-    readonly payload: A
+    readonly payload: unknown
   }
 ) => {
   for (const service of options.rpc.middlewares) {