effect 4.0.0-beta.27 → 4.0.0-beta.29

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -3,19 +3,21 @@
  */
 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"
 import type { SchemaError } from "../../Schema.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type { Mutable, Simplify } from "../../Types.ts"
 import type * as HttpClient from "../http/HttpClient.ts"
-import type * as HttpClientError from "../http/HttpClientError.ts"
+import * as HttpClientError from "../http/HttpClientError.ts"
 import type { HttpClientResponse } from "../http/HttpClientResponse.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiClient from "../httpapi/HttpApiClient.ts"
-import type * as HttpApiEndpoint from "../httpapi/HttpApiEndpoint.ts"
+import * as HttpApiEndpoint from "../httpapi/HttpApiEndpoint.ts"
 import type * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
-import type * as AsyncResult from "./AsyncResult.ts"
+import * as AsyncResult from "./AsyncResult.ts"
 import * as Atom from "./Atom.ts"
 import * as Reactivity from "./Reactivity.ts"
 
@@ -67,7 +69,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         }
       >,
       WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
-      _Error["Type"] | HttpClientError.HttpClientError | SchemaError
+      _Error["Type"]
     >
     : never
 
@@ -124,7 +126,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
         WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
-        _Error["Type"] | HttpClientError.HttpClientError | SchemaError
+        _Error["Type"]
       >
     >
     : never
@@ -169,8 +171,12 @@ export const Service = <Self>() =>
   const runtimeFactory = options.runtime ?? Atom.runtime
   self.runtime = runtimeFactory(self.layer)
 
-  const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) =>
-    self.runtime.fn<{
+  const catchErrors = Effect.catch((e: unknown) =>
+    Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
+  )
+
+  const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) => {
+    const atom = self.runtime.fn<{
       params: any
       query: any
       headers: any
@@ -179,16 +185,27 @@ export const Service = <Self>() =>
     }>()(
       Effect.fnUntraced(function*(opts) {
         const client = (yield* self) as any
-        const effect = client[group][endpoint]({
+        const effect = catchErrors(client[group][endpoint]({
           ...opts,
           withResponse
-        }) as Effect.Effect<any>
+        }) as Effect.Effect<any>)
         return yield* opts.reactivityKeys
           ? Reactivity.mutation(effect, opts.reactivityKeys)
           : effect
       })
     )
-  ) as any
+    if (withResponse === false) {
+      const definition = options.api.groups[group]!.endpoints[endpoint]! as HttpApiEndpoint.AnyWithProps
+      return Atom.serializable(atom, {
+        key: `AtomHttpApi:mutation:${group}:${endpoint}`,
+        schema: AsyncResult.Schema({
+          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(definition)),
+          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(definition))
+        }) as any
+      })
+    }
+    return atom
+  }) as any
 
   self.mutation = ((group: string, endpoint: string, options?: {
     readonly withResponse?: boolean | undefined
@@ -202,8 +219,21 @@ export const Service = <Self>() =>
   const queryFamily = Atom.family((opts: QueryKey) => {
     let atom = self.runtime.atom(self.use((client_) => {
       const client = client_ as any
-      return client[opts.group][opts.endpoint](opts) as Effect.Effect<any>
+      return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
+        any,
+        HttpClientError.HttpClientError | SchemaError
+      >)
     }))
+    if (opts.withResponse === false) {
+      const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
+      atom = Atom.serializable(atom, {
+        key: makeSerializableKey(opts),
+        schema: AsyncResult.Schema({
+          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
+          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
+        }) as any
+      })
+    }
     if (opts.timeToLive) {
       atom = Duration.isFinite(opts.timeToLive)
         ? Atom.setIdleTTL(atom, opts.timeToLive)
@@ -261,3 +291,7 @@ interface QueryKey {
   reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
   timeToLive?: Duration.Duration | undefined
 }
+
+const makeSerializableKey = (
+  key: QueryKey
+): string => `AtomHttpApi:${key.group}:${key.endpoint}:${Hash.hash(key)}`

package/src/unstable/reactivity/AtomRegistry.ts

@@ -317,7 +317,11 @@ class RegistryImpl implements AtomRegistry {
     }
     if (initialValues !== undefined) {
       for (const [atom, value] of initialValues) {
-        this.ensureNode(atom).setValue(value)
+        let target = atom
+        while (target.initialValueTarget) {
+          target = target.initialValueTarget
+        }
+        this.ensureNode(target).setInitialValue(value)
       }
     }
   }
@@ -558,6 +562,7 @@ class NodeImpl<A> {
   state: NodeState = NodeState.uninitialized
   lifetime: Lifetime<A> | undefined
   writeContext: WriteContextImpl<A>
+  preserveInitialValueOnBuild = false
 
   parents: Array<NodeImpl<any>> = []
   previousParents: Array<NodeImpl<any>> | undefined
@@ -588,7 +593,12 @@ class NodeImpl<A> {
       this.lifetime = makeLifetime(this)
       const value = this.atom.read(this.lifetime)
       if ((this.state & NodeFlags.waitingForValue) !== 0) {
-        this.setValue(value)
+        if (this.preserveInitialValueOnBuild) {
+          this.preserveInitialValueOnBuild = false
+          this.state = NodeState.valid
+        } else {
+          this.setValue(value)
+        }
       }
 
       if (this.previousParents) {
@@ -613,6 +623,24 @@ class NodeImpl<A> {
     return Option.some(this._value)
   }
 
+  setInitialValue(value: A): void {
+    if ((this.state & NodeFlags.initialized) === 0) {
+      this.preserveInitialValueOnBuild = true
+      this.state = NodeState.stale
+      this._value = value
+
+      if (batchState.phase === BatchPhase.collect) {
+        batchState.notify.add(this)
+      } else {
+        this.notify()
+      }
+
+      return
+    }
+
+    this.setValue(value)
+  }
+
   setValue(value: A): void {
     if ((this.state & NodeFlags.initialized) === 0) {
       this.state = NodeState.valid

package/src/unstable/reactivity/AtomRpc.ts

@@ -3,8 +3,10 @@
  */
 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"
 import type { Scope } from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
@@ -12,11 +14,11 @@ import type { Mutable, NoInfer } from "../../Types.ts"
 import * as Headers from "../http/Headers.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
-import type { RpcClientError } from "../rpc/RpcClientError.ts"
+import { RpcClientError } from "../rpc/RpcClientError.ts"
 import type * as RpcGroup from "../rpc/RpcGroup.ts"
 import type { RequestId } from "../rpc/RpcMessage.ts"
 import * as RpcSchema from "../rpc/RpcSchema.ts"
-import type * as AsyncResult from "./AsyncResult.ts"
+import * as AsyncResult from "./AsyncResult.ts"
 import * as Atom from "./Atom.ts"
 import * as Reactivity from "./Reactivity.ts"
 
@@ -24,7 +26,7 @@ import * as Reactivity from "./Reactivity.ts"
  * @since 4.0.0
  * @category Models
  */
-export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E> extends
+export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> extends
   ServiceMap.Service<
     Self,
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
@@ -35,8 +37,8 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >
 
-  readonly layer: Layer.Layer<Self, E>
-  readonly runtime: Atom.AtomRuntime<Self, E>
+  readonly layer: Layer.Layer<Self>
+  readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(
     arg: Tag
@@ -58,7 +60,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
         readonly headers?: Headers.Input | undefined
       },
       _Success["Type"],
-      _Error["Type"] | E | _Middleware["error"]["Type"]
+      _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
     >
     : never
 
@@ -82,14 +84,14 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
   > ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>] ? Atom.Writable<
         Atom.PullResult<
           _A["Type"],
-          _E["Type"] | _Error["Type"] | E | _Middleware["error"]["Type"]
+          _E["Type"] | _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
         >,
         void
       >
     : Atom.Atom<
       AsyncResult.AsyncResult<
         _Success["Type"],
-        _Error["Type"] | E | _Middleware["error"]["Type"]
+        _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
       >
     >
     : never
@@ -132,8 +134,8 @@ export const Service = <Self>() =>
       | undefined
     readonly runtime?: Atom.RuntimeFactory | undefined
   }
-): AtomRpcClient<Self, Id, Rpcs, ER> => {
-  const self: Mutable<AtomRpcClient<Self, Id, Rpcs, ER>> = ServiceMap.Service<
+): AtomRpcClient<Self, Id, Rpcs> => {
+  const self: Mutable<AtomRpcClient<Self, Id, Rpcs>> = ServiceMap.Service<
     Self,
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >()(id) as any
@@ -149,12 +151,13 @@ export const Service = <Self>() =>
         never,
         RM
       >)
-  ).pipe(Layer.provide(options.protocol))
+  ).pipe(Layer.provide(Layer.orDie(options.protocol)))
   const runtimeFactory = options.runtime ?? Atom.runtime
   self.runtime = runtimeFactory(self.layer)
 
-  self.mutation = Atom.family(<Tag extends Rpc.Tag<Rpcs>>(tag: Tag) =>
-    self.runtime.fn<{
+  self.mutation = Atom.family(<Tag extends Rpc.Tag<Rpcs>>(tag: Tag) => {
+    const rpc = options.group.requests.get(tag)! as any as Rpc.AnyWithProps
+    return self.runtime.fn<{
       readonly payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>
       readonly reactivityKeys?:
         | ReadonlyArray<unknown>
@@ -169,13 +172,23 @@ export const Service = <Self>() =>
           ? Reactivity.mutation(effect, reactivityKeys)
           : effect
       }) as any
+    ).pipe(
+      Atom.serializable({
+        key: `AtomRpc:mutation:${tag}`,
+        schema: AsyncResult.Schema({
+          success: rpc.successSchema,
+          error: makeErrorSchema(rpc)
+        }) as any
+      })
     )
-  ) as any
+  }) as any
 
   const queryFamily = Atom.family(
-    ({ headers, payload, reactivityKeys, tag, timeToLive }: QueryKey) => {
+    (key: QueryKey) => {
+      const { headers, payload, reactivityKeys, tag, timeToLive } = key
       const rpc = options.group.requests.get(tag)! as any as Rpc.AnyWithProps
-      let atom = RpcSchema.isStreamSchema(rpc.successSchema)
+      const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
+      let atom = isStream
         ? self.runtime.pull(
           Stream.unwrap(
             self.use((client) =>
@@ -188,6 +201,15 @@ export const Service = <Self>() =>
         : self.runtime.atom(
           self.use((client) => client(tag, payload, { headers } as any)) as any
         )
+      if (!isStream) {
+        atom = Atom.serializable(atom, {
+          key: makeSerializableKey(key),
+          schema: AsyncResult.Schema({
+            success: rpc.successSchema,
+            error: makeErrorSchema(rpc)
+          }) as any
+        })
+      }
       if (timeToLive) {
         atom = Duration.isFinite(timeToLive)
           ? Atom.setIdleTTL(atom, timeToLive)
@@ -223,7 +245,7 @@ export const Service = <Self>() =>
         : undefined
     }) as any
 
-  return self as AtomRpcClient<Self, Id, Rpcs, ER>
+  return self as AtomRpcClient<Self, Id, Rpcs>
 }
 
 interface QueryKey {
@@ -236,3 +258,12 @@ interface QueryKey {
     | undefined
   timeToLive?: Duration.Duration | undefined
 }
+
+const makeErrorSchema = (rpc: Rpc.AnyWithProps): Schema.Top =>
+  Schema.Union([
+    rpc.errorSchema,
+    ...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

@@ -406,9 +406,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
 

package/src/unstable/rpc/RpcMiddleware.ts

@@ -109,7 +109,8 @@ export interface ServiceClass<
   Provides,
   E extends Schema.Top,
   ClientError,
-  Requires
+  Requires,
+  RequiredForClient extends boolean
 > extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
   new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
@@ -121,7 +122,7 @@ export interface ServiceClass<
   }
   readonly [TypeId]: typeof TypeId
   readonly error: E
-  readonly requiredForClient: boolean
+  readonly requiredForClient: RequiredForClient
   readonly "~ClientError": ClientError
 }
 
@@ -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,

package/src/unstable/rpc/RpcServer.ts

@@ -305,7 +305,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       effect = concurrencySemaphore.withPermits(1)(effect)
     }
     const serviceMap = new Map(entry.services.mapUnsafe)
-    serviceMap.forEach((value, key) => serviceMap.set(key, value))
+    requestFiber.services.mapUnsafe.forEach((value, key) => serviceMap.set(key, value))
     serviceMap.set(Scope.Scope.key, scope)
     const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
     const fiber = trackFiber(
@@ -1181,7 +1181,7 @@ export const makeProtocolStdio = Effect.gen(function*() {
     )
 
     yield* Stream.fromQueue(queue).pipe(
-      Stream.run(stdio.stdout),
+      Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
       Effect.forkScoped
     )

package/src/unstable/rpc/Utils.ts

@@ -30,7 +30,7 @@ export const withRun = <
           write = f
 
           for (const [args, context] of buffer) {
-            yield* Effect.provide(write(...args), context)
+            yield* Effect.provideServices(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
 

package/src/unstable/sql/SqlResolver.ts

@@ -57,9 +57,9 @@ export const request: {
 } = function() {
   if (arguments.length === 1) {
     const resolver = arguments[0]
-    return (payload: any) => Effect.request(SqlRequest(payload), Effect.succeed(resolver))
+    return (payload: any) => Effect.request(SqlRequest(payload), resolver)
   }
-  return Effect.request(SqlRequest(arguments[0]), Effect.succeed(arguments[1]))
+  return Effect.request(SqlRequest(arguments[0]), arguments[1])
 } as any
 
 /**