effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/unstable/process/ChildProcess.ts

@@ -41,7 +41,7 @@
  * @since 4.0.0
  */
 import type * as Duration from "../../Duration.ts"
-import * as Effect from "../../Effect.ts"
+import type * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
 import type { Pipeable } from "../../Pipeable.ts"
@@ -49,9 +49,8 @@ import type * as PlatformError from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Scope from "../../Scope.ts"
 import type * as Sink from "../../Sink.ts"
-import * as Stream from "../../Stream.ts"
-import type { ChildProcessHandle, ExitCode } from "./ChildProcessSpawner.ts"
-import { ChildProcessSpawner } from "./ChildProcessSpawner.ts"
+import type * as Stream from "../../Stream.ts"
+import { type ChildProcessHandle, ChildProcessSpawner } from "./ChildProcessSpawner.ts"
 
 const TypeId = "~effect/unstable/process/ChildProcess"
 
@@ -283,7 +282,7 @@ export interface KillOptions {
    * Defaults to `undefined`, which means that no timeout will be enforced by
    * default.
    */
-  readonly forceKillAfter?: Duration.DurationInput | undefined
+  readonly forceKillAfter?: Duration.Input | undefined
 }
 
 /**
@@ -414,7 +413,7 @@ export interface CommandOptions extends KillOptions {
    * the value of `globalThis.process.env`, prioritizing the values in `env`
    * when conflicts exist.
    */
-  readonly env?: Record<string, string> | undefined
+  readonly env?: Record<string, string | undefined> | undefined
   /**
    * If set to `true`, the child process uses both the values in `env` as well
    * as the values in `globalThis.process.env`, prioritizing the values in `env`
@@ -515,7 +514,7 @@ const Proto = {
   ...YieldableProto,
   [TypeId]: TypeId,
   asEffect(this: Command) {
-    return spawn(this)
+    return ChildProcessSpawner.use((_) => _.spawn(this))
   }
 }
 
@@ -1118,207 +1117,6 @@ export const setEnv: {
   }
 )
 
-/**
- * Spawn a command and return a handle for interaction.
- *
- * Unlike `exec`, this does not wait for the process to complete. Instead,
- * it returns a handle that provides access to the process's stdin, stdout,
- * stderr streams and exit code.
- *
- * Note: For piped commands, only the first command in the pipeline is spawned
- * and a handle to it is returned.
- *
- * @example
- * ```ts
- * import { NodeServices } from "@effect/platform-node"
- * import { Console, Effect, Stream } from "effect"
- * import { ChildProcess } from "effect/unstable/process"
- *
- * const program = Effect.gen(function*() {
- *   const cmd = ChildProcess.make`long-running-process`
- *   const handle = yield* ChildProcess.spawn(cmd)
- *
- *   // Stream stdout
- *   yield* handle.stdout.pipe(
- *     Stream.decodeText(),
- *     Stream.runForEach(Console.log),
- *     Effect.forkChild
- *   )
- *
- *   // Wait for exit
- *   const exitCode = yield* handle.exitCode
- *   yield* Console.log(`Process exited with code ${exitCode}`)
- * }).pipe(Effect.provide(NodeServices.layer))
- * ```
- *
- * @since 4.0.0
- * @category Execution
- */
-export const spawn = (command: Command): Effect.Effect<
-  ChildProcessHandle,
-  PlatformError.PlatformError,
-  ChildProcessSpawner | Scope.Scope
-> => ChildProcessSpawner.use((_) => _.spawn(command))
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const exitCode = (command: Command): Effect.Effect<
-  ExitCode,
-  PlatformError.PlatformError,
-  ChildProcessSpawner
-> => Effect.scoped(Effect.flatMap(spawn(command), (handle) => handle.exitCode))
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const streamString: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Stream.Stream<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > =>
-    spawn(self).pipe(
-      Effect.map((handle) =>
-        Stream.decodeText(
-          options?.includeStderr === true ? handle.all : handle.stdout
-        )
-      ),
-      Stream.unwrap
-    )
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const streamLines: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (self: Command, options?: { readonly includeStderr?: boolean | undefined }): Stream.Stream<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.splitLines(streamString(self, options))
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const lines: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Effect.Effect<Array<string>, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Effect.Effect<Array<string>, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Effect.Effect<
-    Array<string>,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.runCollect(streamLines(self, options))
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const string: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Effect.Effect<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Effect.Effect<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Effect.Effect<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.mkString(streamString(self, options))
-)
-
 const isTemplateString = (u: unknown): u is TemplateStringsArray =>
   Array.isArray(u) && "raw" in u && Array.isArray(u.raw)
 

package/src/unstable/process/ChildProcessSpawner.ts

@@ -7,13 +7,13 @@
  * @since 4.0.0
  */
 import * as Brand from "../../Brand.ts"
-import type * as Effect from "../../Effect.ts"
+import * as Effect from "../../Effect.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import type * as PlatformError from "../../PlatformError.ts"
 import type * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Sink from "../../Sink.ts"
-import type * as Stream from "../../Stream.ts"
+import * as Stream from "../../Stream.ts"
 import type { Command, KillOptions } from "./ChildProcess.ts"
 
 /**
@@ -76,10 +76,16 @@ export interface ChildProcessHandle {
   readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
   /**
    * The standard output stream for the child process.
+   *
+   * Note: Using alongside `all` may cause interleaving of output and unexpected
+   * results.
    */
   readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>
   /**
    * The standard error stream for the child process.
+   *
+   * Note: Using alongside `all` may cause interleaving of output and unexpected
+   * results.
    */
   readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>
   /**
@@ -123,18 +129,32 @@ export const makeHandle = (params: Omit<ChildProcessHandle, typeof HandleTypeId>
   Object.assign(Object.create(HandleProto), params)
 
 /**
- * Service interface for spawning child processes.
+ * Create a new `ChildProcessSpawner` service from a `spawn` funciton
  *
  * @since 4.0.0
  * @category Models
  */
-export interface ChildProcessSpawner {
-  /**
-   * Spawn a command and return a handle for interaction.
-   */
-  readonly spawn: (
-    command: Command
-  ) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>
+export const make = (spawn: ChildProcessSpawner["Service"]["spawn"]): ChildProcessSpawner["Service"] => {
+  const streamString: ChildProcessSpawner["Service"]["streamLines"] = (command, options) =>
+    spawn(command).pipe(
+      Effect.map((handle) =>
+        Stream.decodeText(
+          options?.includeStderr === true ? handle.all : handle.stdout
+        )
+      ),
+      Stream.unwrap
+    )
+  const streamLines: ChildProcessSpawner["Service"]["streamLines"] = (command, options) =>
+    Stream.splitLines(streamString(command, options))
+
+  return ChildProcessSpawner.of({
+    spawn,
+    exitCode: (command) => Effect.scoped(Effect.flatMap(spawn(command), (handle) => handle.exitCode)),
+    streamString,
+    streamLines,
+    lines: (command, options) => Stream.runCollect(streamLines(command, options)),
+    string: (command, options) => Stream.mkString(streamString(command, options))
+  })
 }
 
 /**
@@ -143,7 +163,48 @@ export interface ChildProcessSpawner {
  * @since 4.0.0
  * @category Service
  */
-export const ChildProcessSpawner: ServiceMap.Service<
-  ChildProcessSpawner,
-  ChildProcessSpawner
-> = ServiceMap.Service("effect/process/ChildProcessSpawner")
+export class ChildProcessSpawner extends ServiceMap.Service<ChildProcessSpawner, {
+  /**
+   * Spawn a command and return a handle for interaction.
+   */
+  spawn(
+    command: Command
+  ): Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>
+
+  /**
+   * Run a command and return its exit code.
+   */
+  exitCode(
+    command: Command
+  ): Effect.Effect<ExitCode, PlatformError.PlatformError>
+
+  /**
+   * Stream the output of a command as strings. Optionally include stderr output
+   * interleaved with stdout.
+   */
+  streamString(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined
+  }): Stream.Stream<string, PlatformError.PlatformError>
+
+  /**
+   * Stream the output of a command as lines. Optionally include stderr output
+   * interleaved with stdout.
+   */
+  streamLines(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined
+  }): Stream.Stream<string, PlatformError.PlatformError>
+
+  /**
+   * Run a command and return the lines of its output as an array of strings.
+   */
+  lines(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined
+  }): Effect.Effect<Array<string>, PlatformError.PlatformError>
+
+  /**
+   * Run a command and return its output as a string.
+   */
+  string(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined
+  }): Effect.Effect<string, PlatformError.PlatformError>
+}>()("effect/process/ChildProcessSpawner") {}

package/src/unstable/reactivity/Atom.ts

@@ -169,25 +169,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 +417,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -431,7 +431,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -477,11 +477,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 +653,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: {
@@ -1684,16 +1684,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)
@@ -1729,7 +1729,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,11 +1737,11 @@ 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))
@@ -2070,7 +2070,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 +2291,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

@@ -51,8 +51,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,11 +62,11 @@ 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,
+      WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
       _Error | HttpClientError.HttpClientError | SchemaError
     >
     : never
@@ -88,8 +88,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 +98,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 +112,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,7 +123,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
-        WithResponse extends true ? [_Success, HttpClientResponse] : _Success,
+        WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
         _Error | HttpClientError.HttpClientError | SchemaError
       >
     >
@@ -170,8 +171,8 @@ export const Service = <Self>() =>
 
   const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) =>
     self.runtime.fn<{
-      path: any
-      urlParams: any
+      params: any
+      query: any
       headers: any
       payload: any
       reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
@@ -217,26 +218,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,8 +253,8 @@ interface MutationKey {
 interface QueryKey {
   group: string
   endpoint: string
-  path: any
-  urlParams: any
+  params: any
+  query: any
   headers: any
   payload: any
   withResponse: boolean