effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -1,21 +1,23 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.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 type * as HttpApiMiddleware from "../httpapi/HttpApiMiddleware.ts"
+import * as AsyncResult from "./AsyncResult.ts"
 import * as Atom from "./Atom.ts"
 import * as Reactivity from "./Reactivity.ts"
 
@@ -24,11 +26,10 @@ import * as Reactivity from "./Reactivity.ts"
  * @category Models
  */
 export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Any>
-  extends ServiceMap.Service<Self, HttpApiClient.Client<Groups, never, never>>
+  extends Context.Service<Self, HttpApiClient.Client<Groups, never, never>>
 {
-  new(_: never): ServiceMap.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>
+  new(_: never): Context.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>
 
-  readonly layer: Layer.Layer<Self>
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <
@@ -39,35 +40,35 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       Name
     >,
-    const WithResponse extends boolean = false
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
   >(
     group: GroupName,
     endpoint: Name,
     options?: {
-      readonly withResponse?: WithResponse | undefined
+      readonly responseMode?: ResponseMode | undefined
     }
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _PathSchema,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
       infer _Error,
-      infer _R,
+      infer _Middleware,
       infer _RE
     >
   ] ? Atom.AtomResultFn<
       Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, false> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, "decoded-only"> & {
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
-      WithResponse extends true ? [_Success, HttpClientResponse] : _Success,
-      _Error | HttpClientError.HttpClientError | SchemaError
+      ResponseByMode<_Success["Type"], ResponseMode>,
+      ErrorByMode<_Error, _Middleware, ResponseMode>
     >
     : never
 
@@ -79,7 +80,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       Name
     >,
-    const WithResponse extends boolean = false
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
     group: GroupName,
     endpoint: Name,
@@ -88,8 +89,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _Name,
         infer _Method,
         infer _Path,
-        infer _PathSchema,
-        infer _UrlParams,
+        infer _Params,
+        infer _Query,
         infer _Payload,
         infer _Headers,
         infer _Success,
@@ -98,12 +99,13 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _RE
       >
     ] ? Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, WithResponse> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, ResponseMode> & {
           readonly reactivityKeys?:
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
-          readonly timeToLive?: Duration.DurationInput | undefined
+          readonly timeToLive?: Duration.Input | undefined
+          readonly serializationKey?: string | undefined
         }
       >
       : never
@@ -112,18 +114,19 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
       infer _Error,
-      infer _R,
+      infer _Middleware,
       infer _RE
     >
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
-        WithResponse extends true ? [_Success, HttpClientResponse] : _Success,
-        _Error | HttpClientError.HttpClientError | SchemaError
+        ResponseByMode<_Success["Type"], ResponseMode>,
+        ErrorByMode<_Error, _Middleware, ResponseMode>
       >
     >
     : never
@@ -144,10 +147,15 @@ export const Service = <Self>() =>
   id: Id,
   options: {
     readonly api: HttpApi.HttpApi<ApiId, Groups>
-    readonly httpClient: Layer.Layer<
-      | HttpApiGroup.ClientServices<Groups>
-      | HttpClient.HttpClient
-    >
+    readonly httpClient:
+      | Layer.Layer<
+        | HttpApiGroup.ClientServices<Groups>
+        | HttpClient.HttpClient
+      >
+      | ((get: Atom.AtomContext) => Layer.Layer<
+        | HttpApiGroup.ClientServices<Groups>
+        | HttpClient.HttpClient
+      >)
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
     readonly transformResponse?:
       | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
@@ -156,53 +164,92 @@ export const Service = <Self>() =>
     readonly runtime?: Atom.RuntimeFactory | undefined
   }
 ): AtomHttpApiClient<Self, Id, Groups> => {
-  const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = ServiceMap.Service<
+  const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = Context.Service<
     Self,
     HttpApiClient.Client<Groups, never, never>
   >()(id) as any
 
-  self.layer = Layer.effect(
+  const layer = Layer.effect(
     self,
     HttpApiClient.make(options.api, options)
-  ).pipe(Layer.provide(options.httpClient)) as Layer.Layer<Self>
+  )
   const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(self.layer)
+  self.runtime = runtimeFactory(
+    typeof options.httpClient === "function" ?
+      (get) =>
+        Layer.provide(
+          layer,
+          (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
+            | HttpApiGroup.ClientServices<Groups>
+            | HttpClient.HttpClient
+          >)(get)
+        ) as Layer.Layer<Self> :
+      Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
+  )
+
+  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) =>
-    self.runtime.fn<{
-      path: any
-      urlParams: any
+  const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
+    const atom = self.runtime.fn<{
+      params: any
+      query: any
       headers: any
       payload: any
       reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
     }>()(
       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>
+          responseMode
+        }) as Effect.Effect<any>)
         return yield* opts.reactivityKeys
           ? Reactivity.mutation(effect, opts.reactivityKeys)
           : effect
       })
     )
-  ) as any
+    if (responseMode === "decoded-only") {
+      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
+    readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
   }) =>
     mutationFamily({
       group,
       endpoint,
-      withResponse: options?.withResponse ?? false
+      responseMode: options?.responseMode ?? "decoded-only"
     })) as any
 
   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.responseMode === "decoded-only" && opts.serializationKey) {
+      const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
+      atom = Atom.serializable(atom, {
+        key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
+        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)
@@ -217,28 +264,32 @@ export const Service = <Self>() =>
     group: string,
     endpoint: string,
     request: {
-      readonly path?: any
-      readonly urlParams?: any
+      readonly params?: any
+      readonly query?: any
       readonly payload?: any
       readonly headers?: any
-      readonly withResponse?: boolean
+      readonly responseMode?: HttpApiEndpoint.ClientResponseMode
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
+      readonly serializationKey?: string | undefined
     }
-  ) =>
-    queryFamily({
+  ) => {
+    const key: QueryKey = {
       group,
       endpoint,
-      path: request.path,
-      urlParams: request.urlParams,
+      params: request.params,
+      query: request.query,
       payload: request.payload,
       headers: request.headers,
-      withResponse: request.withResponse ?? false,
+      responseMode: request.responseMode ?? "decoded-only",
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
-        ? Duration.fromDurationInputUnsafe(request.timeToLive)
-        : undefined
-    })) as any
+        ? Duration.fromInputUnsafe(request.timeToLive)
+        : undefined,
+      serializationKey: request.serializationKey
+    }
+    return queryFamily(key)
+  }) as any
 
   return self as AtomHttpApiClient<Self, Id, Groups>
 }
@@ -246,17 +297,32 @@ export const Service = <Self>() =>
 interface MutationKey {
   group: string
   endpoint: string
-  withResponse: boolean
+  responseMode: HttpApiEndpoint.ClientResponseMode
 }
 
 interface QueryKey {
   group: string
   endpoint: string
-  path: any
-  urlParams: any
+  params: any
+  query: any
   headers: any
   payload: any
-  withResponse: boolean
-  reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-  timeToLive?: Duration.Duration | undefined
+  responseMode: HttpApiEndpoint.ClientResponseMode
+  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
+
+type ErrorByMode<
+  Error extends Schema.Top,
+  Middleware,
+  ResponseMode extends HttpApiEndpoint.ClientResponseMode
+> =
+  | HttpApiMiddleware.Error<Middleware>
+  | HttpApiMiddleware.ClientError<Middleware>
+  | ([ResponseMode] extends ["response-only"] ? never : Error["Type"])

package/src/unstable/reactivity/AtomRegistry.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -9,10 +10,9 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
-import type { Scheduler } from "../../Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "../../Scheduler.ts"
 import { MixedScheduler } from "../../Scheduler.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Result from "./AsyncResult.ts"
 import type * as Atom from "./Atom.ts"
@@ -56,6 +56,8 @@ export interface AtomRegistry {
   }) => () => void
   readonly reset: () => void
   readonly dispose: () => void
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 }
 
 /**
@@ -65,6 +67,10 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
+  parents: Array<Node<any>>
+  children: Array<Node<any>>
+  listeners: Set<() => void>
+  currentState(): "uninitialized" | "stale" | "valid" | "removed"
 }
 
 /**
@@ -90,7 +96,7 @@ export const make = (
  * @since 4.0.0
  * @category Tags
  */
-export const AtomRegistry = ServiceMap.Service<AtomRegistry>(TypeId)
+export const AtomRegistry = Context.Service<AtomRegistry>(TypeId)
 
 /**
  * @since 4.0.0
@@ -162,7 +168,7 @@ export const toStream: {
     A>((queue) =>
       Effect.suspend(() => {
         const fiber = Fiber.getCurrent()!
-        const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+        const scope = Context.getUnsafe(fiber.context, Scope.Scope)
         const cancel = self.subscribe(atom, (value) => Queue.offerUnsafe(queue, value), {
           immediate: true
         })
@@ -290,6 +296,9 @@ class RegistryImpl implements AtomRegistry {
   readonly defaultIdleTTL: number | undefined
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
+  readonly dispatcher: SchedulerDispatcher
+  onNodeAdded?: ((node: Node<any>) => void) | undefined
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined
 
   constructor(
     initialValues?: Iterable<readonly [Atom.Atom<any>, any]>,
@@ -300,6 +309,7 @@ class RegistryImpl implements AtomRegistry {
     this[TypeId] = TypeId
     this.scheduler = new MixedScheduler("sync", scheduleTask)
     this.schedulerAsync = new MixedScheduler("async", scheduleTask)
+    this.dispatcher = this.schedulerAsync.makeDispatcher()
     this.defaultIdleTTL = defaultIdleTTL
 
     if (timeoutResolution === undefined && defaultIdleTTL !== undefined) {
@@ -309,7 +319,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)
       }
     }
   }
@@ -386,6 +400,7 @@ class RegistryImpl implements AtomRegistry {
     if (node === undefined) {
       node = this.createNode(atom)
       this.nodes.set(key, node)
+      this.onNodeAdded?.(node)
     } else if (this.atomHasTtl(atom)) {
       this.removeNodeTimeout(node)
     }
@@ -414,7 +429,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleAtomRemoval(atom: Atom.Atom<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       const node = this.nodes.get(atomKey(atom))
       if (node !== undefined && node.canBeRemoved) {
         this.removeNode(node)
@@ -423,7 +438,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleNodeRemoval(node: NodeImpl<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       if (node.canBeRemoved) {
         this.removeNode(node)
       }
@@ -436,6 +451,7 @@ class RegistryImpl implements AtomRegistry {
     } else {
       this.nodes.delete(atomKey(node.atom))
       node.remove()
+      this.onNodeRemoved?.(node)
     }
   }
 
@@ -450,6 +466,7 @@ class RegistryImpl implements AtomRegistry {
       if (idleTTL <= 0) {
         this.nodes.delete(atomKey(node.atom))
         node.remove()
+        this.onNodeRemoved?.(node)
         return
       }
     }
@@ -471,9 +488,7 @@ class RegistryImpl implements AtomRegistry {
 
   removeNodeTimeout(node: NodeImpl<any>): void {
     const bucket = this.nodeTimeoutBucket.get(node)
-    if (bucket === undefined) {
-      return
-    }
+    if (bucket === undefined) return
     this.nodeTimeoutBucket.delete(node)
     this.scheduleNodeRemoval(node)
 
@@ -491,11 +506,10 @@ class RegistryImpl implements AtomRegistry {
     this.timeoutBuckets.delete(bucket)
 
     nodes.forEach((node) => {
-      if (!node.canBeRemoved) {
-        return
-      }
       this.nodeTimeoutBucket.delete(node)
+      if (!node.canBeRemoved) return
       this.nodes.delete(atomKey(node.atom))
+      this.onNodeRemoved?.(node)
       this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL!
       node.remove()
       this.#currentSweepTTL = null
@@ -507,7 +521,10 @@ class RegistryImpl implements AtomRegistry {
     this.timeoutBuckets.clear()
     this.nodeTimeoutBucket.clear()
 
-    this.nodes.forEach((node) => node.remove())
+    this.nodes.forEach((node) => {
+      node.remove()
+      this.onNodeRemoved?.(node)
+    })
     this.nodes.clear()
   }
 
@@ -547,6 +564,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
@@ -554,6 +572,19 @@ class NodeImpl<A> {
   listeners: Set<() => void> = new Set()
   skipInvalidation = false
 
+  currentState() {
+    switch (this.state) {
+      case NodeState.uninitialized:
+        return "uninitialized"
+      case NodeState.stale:
+        return "stale"
+      case NodeState.valid:
+        return "valid"
+      default:
+        return "removed"
+    }
+  }
+
   get canBeRemoved(): boolean {
     return !this.atom.keepAlive && this.listeners.size === 0 && this.children.length === 0 && this.state !== 0
   }
@@ -564,7 +595,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) {
@@ -589,6 +625,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
@@ -755,7 +809,7 @@ function childrenAreActive(children: Array<NodeImpl<any>>): boolean {
   return false
 }
 
-interface Lifetime<A> extends Atom.Context {
+interface Lifetime<A> extends Atom.AtomContext {
   isFn: boolean
   readonly node: NodeImpl<A>
   finalizers: Array<() => void> | undefined