effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/unstable/reactivity/Atom.ts

@@ -25,7 +25,7 @@ import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as SubscriptionRef from "../../SubscriptionRef.ts"
-import type { NoInfer } from "../../Types.ts"
+import type { Mutable, NoInfer } from "../../Types.ts"
 import * as KeyValueStore from "../persistence/KeyValueStore.ts"
 import * as AsyncResult from "./AsyncResult.ts"
 import { AtomRegistry } from "./AtomRegistry.ts"
@@ -56,6 +56,7 @@ export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
   readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void
   readonly label?: readonly [name: string, stack: string]
   readonly idleTTL?: number
+  readonly initialValueTarget?: Atom<A>
 }
 
 /**
@@ -169,25 +170,25 @@ export const setIdleTTL: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => A
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
+  <A extends Atom<any>>(self: A, duration: Duration.Input): A
 } = dual<
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
+  (duration: Duration.Input) => <A extends Atom<any>>(self: A) => A,
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
+  <A extends Atom<any>>(self: A, duration: Duration.Input) => A
 >(2, (self, durationInput) => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+  const duration = Duration.fromInputUnsafe(durationInput)
   const isFinite = Duration.isFinite(duration)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
@@ -417,7 +418,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -431,7 +432,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -477,11 +478,11 @@ const makeRead: {
   <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
+  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
   <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
+  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
   <A>(create: (get: Context) => A): (get: Context, services?: ServiceMap.ServiceMap<any>) => A
   <A>(initialValue: A): Writable<A>
 } = <A, E>(
@@ -653,10 +654,10 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
     }): Atom<AsyncResult.AsyncResult<A, E | ER>>
     <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
       readonly initialValue?: A
-    }): Atom<AsyncResult.AsyncResult<A, E | ER>>
+    }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>
     <A, E>(stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
       readonly initialValue?: A
-    }): Atom<AsyncResult.AsyncResult<A, E | ER>>
+    }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>
   }
 
   readonly fn: {
@@ -792,7 +793,7 @@ export const context: (options: {
         }))
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
-      }) as any as A
+      }, { initialValueTarget: atom }) as any as A
   return factory
 }
 
@@ -1600,33 +1601,67 @@ export const transform: {
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(f: (get: Context, atom: R) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(self: R, f: (get: Context, atom: R) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    self: R,
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
 } = dual(
-  2,
-  (<A, B>(self: Atom<A>, f: (get: Context, atom: Atom<A>) => B): Atom<B> =>
-    isWritable(self)
-      ? writable(
-        (get) => f(get, self),
-        function(ctx, value) {
-          ctx.set(self, value)
-        },
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )
-      : readable(
-        (get) => f(get, self),
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )) as any
+  (args) => isAtom(args[0]),
+  (<A, B>(
+    self: Atom<A>,
+    f: (get: Context, atom: Atom<A>, options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): Atom<B> => {
+    const atom = removeTtl(
+      isWritable(self)
+        ? writable(
+          (get) => f(get, self),
+          function(ctx, value) {
+            ctx.set(self, value)
+          },
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+        : readable(
+          (get) => f(get, self),
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+    )
+    if (options?.initialValueTarget) {
+      ;(atom as Mutable<Atom<B>>).initialValueTarget = getInitialValueTarget(options.initialValueTarget)
+    }
+    return atom
+  }) as any
 )
 
+const getInitialValueTarget = <A>(atom: Atom<A>): Atom<A> => {
+  let target = atom
+  while (target.initialValueTarget) {
+    target = target.initialValueTarget
+  }
+  return target
+}
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -1684,16 +1719,16 @@ export const debounce: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       let timeout: number | undefined
       let value = get.once(self)
@@ -1710,7 +1745,7 @@ export const debounce: {
         timeout = setTimeout(update, millis) as any
       })
       return value
-    })
+    }, { initialValueTarget: self })
   }
 )
 
@@ -1729,7 +1764,7 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * Ensures that the value of the atom is refreshed at most once per specified
    * duration.
@@ -1737,19 +1772,143 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       const handle = setTimeout(() => get.refresh(self), millis) as any
       get.addFinalizer(() => clearTimeout(handle))
       return get(self)
-    })
+    }, { initialValueTarget: self })
   }
 )
 
+/**
+ * Adds stale-while-revalidate refresh behavior to an async result atom.
+ *
+ * Automatic revalidation during reads is skipped while the current value is
+ * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+ * forward to the wrapped atom.
+ *
+ * Use `revalidateOnMount` to control whether stale data should trigger a
+ * background refresh on first mount. Use `revalidateOnFocus` to control
+ * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const swr: {
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => WithoutSerializable<R>
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <R extends Atom<AsyncResult.AsyncResult<any, any>>>(
+    self: R,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): WithoutSerializable<R>
+} = dual(
+  2,
+  <A, E>(
+    self: Atom<AsyncResult.AsyncResult<A, E>>,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): Atom<AsyncResult.AsyncResult<A, E>> => {
+    const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime))
+    return transform(self, (get) => {
+      const current = get.once(self)
+      get.subscribe(self, (value) => {
+        get.setSelf(value)
+      })
+      if (options.revalidateOnFocus && options.focusSignal) {
+        get.once(options.focusSignal)
+        get.subscribe(
+          options.focusSignal,
+          options.revalidateOnFocus === "always" ? () => get.refresh(self) : () => {
+            const current = get.once(self)
+            if (shouldRevalidateSWR(current, staleTime)) {
+              get.refresh(self)
+            }
+          }
+        )
+      }
+      const firstRead = Option.isNone(get.self<AsyncResult.AsyncResult<A, E>>())
+      if (firstRead && options.revalidateOnMount === false) {
+        return current
+      }
+      if (shouldRevalidateSWR(current, staleTime)) {
+        get.refresh(self)
+      }
+      return current
+    }, { initialValueTarget: self })
+  }
+) as any
+
+const swrTimestamp = <A, E>(result: AsyncResult.AsyncResult<A, E>): Option.Option<number> => {
+  if (result._tag === "Success") {
+    return Option.some(result.timestamp)
+  }
+  if (result._tag === "Failure") {
+    return Option.map(result.previousSuccess, (success) => success.timestamp)
+  }
+  return Option.none()
+}
+
+const isFreshWithin = (timestamp: number, staleTime: number, now: number): boolean => now - timestamp < staleTime
+
+const shouldRevalidateSWR = <A, E>(result: AsyncResult.AsyncResult<A, E>, staleTime: number): boolean => {
+  if (result.waiting) {
+    return false
+  }
+  const timestamp = Option.getOrUndefined(swrTimestamp(result))
+  if (timestamp === undefined) {
+    return result._tag !== "Initial"
+  }
+  return !isFreshWithin(timestamp, staleTime, Date.now())
+}
+
 /**
  * @since 4.0.0
  * @category Optimistic
@@ -1962,7 +2121,7 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
     get.subscribe(signal, (_) => get.refresh(self))
     get.subscribe(self, (value) => get.setSelf(value))
     return get.once(self)
-  }) as any
+  }, { initialValueTarget: self }) as any
 
 /**
  * @since 4.0.0
@@ -2070,7 +2229,7 @@ export const searchParam = <S extends Schema.Codec<any, string> = never>(name: s
         window.removeEventListener("pushstate", handleUpdate)
       })
       const value = new URLSearchParams(window.location.search).get(name) || ""
-      return decode ? Exit.findErrorOption(decode(value)) : value as any
+      return decode ? Exit.getSuccess(decode(value)) : value as any
     },
     (ctx, value: any) => {
       if (typeof window === "undefined") {
@@ -2291,16 +2450,18 @@ export const serializable: {
 } = dual(2, <R extends Atom<any>, A, I>(self: R, options: {
   readonly key: string
   readonly schema: Schema.Codec<A, I>
-}): R & Serializable<any> =>
-  Object.assign(Object.create(Object.getPrototypeOf(self)), {
+}): R & Serializable<any> => {
+  const codecJson = Schema.toCodecJson(options.schema)
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
     label: self.label ?? [options.key, new Error().stack?.split("\n")[5] ?? ""],
     [SerializableTypeId]: {
       key: options.key,
-      encode: Schema.encodeSync(options.schema),
-      decode: Schema.decodeSync(options.schema)
+      encode: Schema.encodeSync(codecJson),
+      decode: Schema.decodeSync(codecJson)
     }
-  }))
+  })
+})
 
 /**
  * @since 4.0.0

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"
 
@@ -51,8 +53,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,
@@ -62,12 +64,12 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.AtomResultFn<
       Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, false> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, false> & {
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
-      WithResponse extends true ? [_Success, HttpClientResponse] : _Success,
-      _Error | HttpClientError.HttpClientError | SchemaError
+      WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
+      _Error["Type"]
     >
     : never
 
@@ -88,8 +90,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 +100,12 @@ 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, WithResponse> & {
           readonly reactivityKeys?:
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
-          readonly timeToLive?: Duration.DurationInput | undefined
+          readonly timeToLive?: Duration.Input | undefined
         }
       >
       : never
@@ -112,7 +114,8 @@ 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,
@@ -122,8 +125,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
-        WithResponse extends true ? [_Success, HttpClientResponse] : _Success,
-        _Error | HttpClientError.HttpClientError | SchemaError
+        WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
+        _Error["Type"]
       >
     >
     : never
@@ -168,26 +171,41 @@ 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<{
-      path: any
-      urlParams: any
+  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
       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>
+        }) 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
@@ -201,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)
@@ -217,26 +248,26 @@ 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 reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
       group,
       endpoint,
-      path: request.path,
-      urlParams: request.urlParams,
+      params: request.params,
+      query: request.query,
       payload: request.payload,
       headers: request.headers,
       withResponse: request.withResponse ?? false,
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
-        ? Duration.fromDurationInputUnsafe(request.timeToLive)
+        ? Duration.fromInputUnsafe(request.timeToLive)
         : undefined
     })) as any
 
@@ -252,11 +283,15 @@ interface MutationKey {
 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
 }
+
+const makeSerializableKey = (
+  key: QueryKey
+): string => `AtomHttpApi:${key.group}:${key.endpoint}:${Hash.hash(key)}`