@confect/js 10.0.0-next.8 → 10.0.0

package/dist/internal/WebSocketClient.js

@@ -0,0 +1,74 @@
+import * as Effect from "effect/Effect";
+import * as Ref from "@confect/core/Ref";
+import * as Queue from "effect/Queue";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+//#region src/internal/WebSocketClient.ts
+var WebSocketClientError = class extends Schema.TaggedError()("WebSocketClientError", { cause: Schema.Defect() }) {};
+const runQuery = Effect.fn("WebSocketClient.query")((effect) => effect);
+const runMutation = Effect.fn("WebSocketClient.mutation")((effect) => effect);
+const runAction = Effect.fn("WebSocketClient.action")((effect) => effect);
+const make = (address, convexClient) => {
+	const setAuth = (fetchToken, onChange) => Effect.gen(function* () {
+		const context = yield* Effect.context();
+		const runPromise = Effect.runPromiseWith(context);
+		const runFork = Effect.runForkWith(context);
+		convexClient.setAuth((args) => runPromise(Effect.suspend(() => fetchToken(args))), ...onChange ? [(isAuthenticated) => {
+			runFork(Effect.suspend(() => onChange(isAuthenticated)));
+		}] : []);
+	});
+	const mapUnknownError = (cause) => new WebSocketClientError({ cause });
+	const query = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runQuery(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.query(functionReference, encodedArgs), mapUnknownError));
+	};
+	const mutation = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runMutation(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.mutation(functionReference, encodedArgs), mapUnknownError));
+	};
+	const action = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runAction(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.action(functionReference, encodedArgs), mapUnknownError));
+	};
+	const reactiveQueryResult = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		const functionReference = Ref.getFunctionReference(ref);
+		const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
+		return Stream.unwrap(Effect.match(Ref.encodeArgs(ref, args), {
+			onFailure: (error) => Stream.succeed(Result.fail(error)),
+			onSuccess: (encodedArgs) => Stream.callback((queue) => Effect.gen(function* () {
+				const unsubscribe = convexClient.onUpdate(functionReference, encodedArgs, (result) => {
+					Queue.offerUnsafe(queue, Result.succeed(result));
+				}, (error) => {
+					Queue.offerUnsafe(queue, Result.fail(onError(error)));
+				});
+				yield* Effect.addFinalizer(() => Effect.sync(() => unsubscribe()));
+			}))
+		})).pipe(Stream.mapEffect((result) => Result.match(result, {
+			onFailure: (error) => Effect.succeed(Result.fail(error)),
+			onSuccess: (encodedReturns) => Effect.match(Ref.decodeReturns(ref, encodedReturns), {
+				onFailure: Result.fail,
+				onSuccess: Result.succeed
+			})
+		})));
+	};
+	const reactiveQuery = (ref, ...rest) => reactiveQueryResult(ref, ...rest).pipe(Stream.mapEffect(Result.match({
+		onFailure: Effect.fail,
+		onSuccess: Effect.succeed
+	})));
+	return {
+		url: address,
+		setAuth,
+		query,
+		mutation,
+		action,
+		reactiveQuery,
+		reactiveQueryResult
+	};
+};
+const makeScoped = (address, acquire) => Effect.acquireRelease(acquire, (convexClient) => Effect.promise(() => convexClient.close())).pipe(Effect.map((convexClient) => make(address, convexClient)));
+//#endregion
+export { WebSocketClientError, make, makeScoped };
+
+//# sourceMappingURL=WebSocketClient.js.map

package/dist/internal/WebSocketClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketClient.js","names":[],"sources":["../../src/internal/WebSocketClient.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport * as Effect from \"effect/Effect\";\nimport * as Queue from \"effect/Queue\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as Stream from \"effect/Stream\";\n\nexport class WebSocketClientError extends Schema.TaggedError<WebSocketClientError>()(\n  \"WebSocketClientError\",\n  {\n    cause: Schema.Defect(),\n  },\n) {}\n\nexport interface Transport {\n  readonly setAuth: (\n    fetchToken: (args: {\n      readonly forceRefreshToken: boolean;\n    }) => Promise<string | null | undefined>,\n    onChange?: (isAuthenticated: boolean) => void,\n  ) => void;\n  readonly close: () => Promise<void>;\n  readonly query: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly mutation: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicMutation>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly action: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicAction>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly onUpdate: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,\n    encodedArgs: unknown,\n    onUpdate: (result: unknown) => void,\n    onError: (error: Error) => void,\n  ) => () => void;\n}\n\nconst runQuery = Effect.fn(\"WebSocketClient.query\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runMutation = Effect.fn(\"WebSocketClient.mutation\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runAction = Effect.fn(\"WebSocketClient.action\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nexport const make = (address: string, convexClient: Transport) => {\n  const setAuth = <R1 = never, R2 = never>(\n    fetchToken: (args: {\n      forceRefreshToken: boolean;\n    }) => Effect.Effect<string | null | undefined, never, R1>,\n    onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>,\n  ): Effect.Effect<void, never, R1 | R2> =>\n    Effect.gen(function* () {\n      const context = yield* Effect.context<R1 | R2>();\n      const runPromise = Effect.runPromiseWith(context);\n      const runFork = Effect.runForkWith(context);\n      convexClient.setAuth(\n        (args) => runPromise(Effect.suspend(() => fetchToken(args))),\n        ...(onChange\n          ? [\n              (isAuthenticated: boolean) => {\n                runFork(Effect.suspend(() => onChange(isAuthenticated)));\n              },\n            ]\n          : []),\n      );\n    });\n\n  const mapUnknownError = (cause: unknown) =>\n    new WebSocketClientError({ cause });\n\n  const query = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Effect.Effect<\n    Ref.Returns<Query>,\n    Ref.Error<Query> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Query>;\n    return runQuery(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.query(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\n    );\n  };\n\n  const mutation = <Mutation extends Ref.AnyPublicMutation>(\n    ref: Mutation,\n    ...rest: Ref.OptionalArgs<Mutation>\n  ): Effect.Effect<\n    Ref.Returns<Mutation>,\n    Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;\n    return runMutation(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.mutation(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\n    );\n  };\n\n  const action = <Action extends Ref.AnyPublicAction>(\n    ref: Action,\n    ...rest: Ref.OptionalArgs<Action>\n  ): Effect.Effect<\n    Ref.Returns<Action>,\n    Ref.Error<Action> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Action>;\n    return runAction(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.action(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\n    );\n  };\n\n  type ReactiveQueryError<Query extends Ref.AnyPublicQuery> =\n    | Ref.Error<Query>\n    | WebSocketClientError\n    | Schema.SchemaError;\n\n  const reactiveQueryResult = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Stream.Stream<\n    Result.Result<Ref.Returns<Query>, ReactiveQueryError<Query>>\n  > => {\n    type QueryResult = Result.Result<\n      Ref.Returns<Query>,\n      ReactiveQueryError<Query>\n    >;\n    const args = (rest[0] ?? {}) as Ref.Args<Query>;\n    const functionReference = Ref.getFunctionReference(ref);\n    const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);\n\n    return Stream.unwrap(\n      Effect.match(Ref.encodeArgs(ref, args), {\n        onFailure: (error) => Stream.succeed<QueryResult>(Result.fail(error)),\n        onSuccess: (encodedArgs) =>\n          Stream.callback<Result.Result<unknown, ReactiveQueryError<Query>>>(\n            (queue) =>\n              Effect.gen(function* () {\n                const unsubscribe = convexClient.onUpdate(\n                  functionReference,\n                  encodedArgs,\n                  (result) => {\n                    Queue.offerUnsafe(queue, Result.succeed(result));\n                  },\n                  (error) => {\n                    Queue.offerUnsafe(queue, Result.fail(onError(error)));\n                  },\n                );\n                yield* Effect.addFinalizer(() =>\n                  Effect.sync(() => unsubscribe()),\n                );\n              }),\n          ),\n      }),\n    ).pipe(\n      Stream.mapEffect((result): Effect.Effect<QueryResult> =>\n        Result.match(result, {\n          onFailure: (error) => Effect.succeed(Result.fail(error)),\n          onSuccess: (encodedReturns) =>\n            Effect.match(Ref.decodeReturns(ref, encodedReturns), {\n              onFailure: Result.fail,\n              onSuccess: Result.succeed,\n            }),\n        }),\n      ),\n    );\n  };\n\n  const reactiveQuery = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Stream.Stream<Ref.Returns<Query>, ReactiveQueryError<Query>> =>\n    reactiveQueryResult(ref, ...rest).pipe(\n      Stream.mapEffect(\n        Result.match({\n          onFailure: Effect.fail,\n          onSuccess: Effect.succeed,\n        }),\n      ),\n    );\n\n  return {\n    url: address,\n    setAuth,\n    query,\n    mutation,\n    action,\n    reactiveQuery,\n    reactiveQueryResult,\n  };\n};\n\nexport const makeScoped = <E, R>(\n  address: string,\n  acquire: Effect.Effect<Transport, E, R>,\n) =>\n  Effect.acquireRelease(acquire, (convexClient) =>\n    Effect.promise(() => convexClient.close()),\n  ).pipe(Effect.map((convexClient) => make(address, convexClient)));\n"],"mappings":"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"}

package/package.json

@@ -1,28 +1,32 @@
 {
   "name": "@confect/js",
   "description": "JavaScript client bindings for any JS runtime",
-  "version": "10.0.0-next.8",
+  "version": "10.0.0",
   "author": "RJ Dellecese",
   "bugs": {
     "url": "https://github.com/rjdellecese/confect/issues"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-beta.101",
-    "@types/node": "26.1.1",
-    "effect": "4.0.0-beta.101",
-    "tsdown": "0.22.12",
-    "typescript": "6.0.3",
+    "@effect/vitest": "4.0.0",
+    "@types/node": "24.13.3",
+    "effect": "4.0.0",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
     "unrun": "0.3.1",
-    "vitest": "4.1.10"
+    "vitest": "5.0.2"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -30,6 +34,7 @@
     "LICENSE",
     "README.md",
     "dist",
+    "!dist/*.tsbuildinfo",
     "package.json",
     "src"
   ],
@@ -42,21 +47,22 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "peerDependencies": {
+    "@confect/core": "^10.0.0",
     "convex": "^1.32.0",
-    "effect": "^4.0.0-beta.101",
-    "@confect/core": "^10.0.0-next.8"
+    "effect": "^4.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/rjdellecese/confect.git"
+    "url": "git+https://github.com/rjdellecese/confect.git"
   },
   "sideEffects": false,
   "type": "module",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "clean": "rm -rf dist coverage node_modules",
-    "dev": "tsdown --watch --config-loader unrun",
+    "clean": "shx rm -rf dist coverage node_modules",
+    "dev": "tsdown --watch --no-clean --config-loader unrun",
     "test": "vitest run",
-    "typecheck": "tsc -b tsconfig.src.json"
+    "typecheck": "tsc -b tsconfig.src.json",
+    "typecheck:inexact": "tsc --noEmit --project tsconfig.json --exactOptionalPropertyTypes false"
   }
 }

package/src/HttpClient.ts

@@ -1,99 +1,32 @@
-import * as Ref from "@confect/core/Ref";
 import { ConvexHttpClient } from "convex/browser";
 import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Schema from "effect/Schema";
+import * as InternalHttpClient from "./internal/HttpClient";
 
-export class HttpClientError extends Schema.TaggedErrorClass<HttpClientError>()(
-  "HttpClientError",
-  {
-    cause: Schema.Unknown,
-  },
-) {}
+export { HttpClientError } from "./internal/HttpClient";
 
 const make = (
   address: string,
   options?: ConstructorParameters<typeof ConvexHttpClient>[1],
 ) => {
   const client = new ConvexHttpClient(address, options);
-
-  const url = client.url;
-
-  const setAuth = (token: string) =>
-    Effect.sync(() => {
-      client.setAuth(token);
-    });
-
-  const clearAuth = Effect.sync(() => {
-    client.clearAuth();
+  return InternalHttpClient.make({
+    url: client.url,
+    setAuth: (token) => client.setAuth(token),
+    clearAuth: () => client.clearAuth(),
+    query: (functionReference, encodedArgs) =>
+      client.query(functionReference, encodedArgs),
+    mutation: (functionReference, encodedArgs) =>
+      client.mutation(functionReference, encodedArgs),
+    action: (functionReference, encodedArgs) =>
+      client.action(functionReference, encodedArgs),
   });
-
-  const mapUnknownError = (cause: unknown) => new HttpClientError({ cause });
-
-  const query = <Query extends Ref.AnyPublicQuery>(
-    ref: Query,
-    ...rest: Ref.OptionalArgs<Query>
-  ): Effect.Effect<
-    Ref.Returns<Query>,
-    Ref.Error<Query> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Query>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.query(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  const mutation = <Mutation extends Ref.AnyPublicMutation>(
-    ref: Mutation,
-    ...rest: Ref.OptionalArgs<Mutation>
-  ): Effect.Effect<
-    Ref.Returns<Mutation>,
-    Ref.Error<Mutation> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.mutation(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  const action = <Action extends Ref.AnyPublicAction>(
-    ref: Action,
-    ...rest: Ref.OptionalArgs<Action>
-  ): Effect.Effect<
-    Ref.Returns<Action>,
-    Ref.Error<Action> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Action>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.action(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  return {
-    url,
-    setAuth,
-    clearAuth,
-    query,
-    mutation,
-    action,
-  };
 };
 
 /**
- * A Confect client which uses HTTP to communicate with your Convex backend. Works in any JS runtime that supports `fetch`. Wraps [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).
+ * A Confect client which uses HTTP to communicate with your Convex backend.
+ * Works in any JS runtime that supports `fetch`. Wraps
+ * [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).
  */
 export const HttpClient = Context.Service<ReturnType<typeof make>>(
   "@confect/js/HttpClient",

package/src/WebSocketClient.ts

@@ -1,159 +1,48 @@
-import * as Ref from "@confect/core/Ref";
 import { ConvexClient } from "convex/browser";
-import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Queue from "effect/Queue";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
+import * as InternalWebSocketClient from "./internal/WebSocketClient";
 
-export class WebSocketClientError extends Schema.TaggedErrorClass<WebSocketClientError>()(
-  "WebSocketClientError",
-  {
-    cause: Schema.Unknown,
-  },
-) {}
+export { WebSocketClientError } from "./internal/WebSocketClient";
 
 const make = (
   address: string,
   options?: ConstructorParameters<typeof ConvexClient>[1],
 ) =>
-  Effect.acquireRelease(
-    Effect.sync(() => new ConvexClient(address, options)),
-    (convexClient) => Effect.promise(() => convexClient.close()),
-  ).pipe(
-    Effect.map((convexClient) => {
-      const url = address;
-
-      const setAuth = (
-        fetchToken: (args: {
-          forceRefreshToken: boolean;
-        }) => Effect.Effect<string | null | undefined>,
-        onChange?: (isAuthenticated: boolean) => Effect.Effect<void>,
-      ) =>
-        Effect.sync(() => {
-          convexClient.setAuth(
-            (args) => Effect.runPromise(fetchToken(args)),
-            ...(onChange
-              ? [
-                  (isAuthenticated: boolean) =>
-                    Effect.runFork(onChange(isAuthenticated)),
-                ]
-              : []),
-          );
-        });
-
-      const mapUnknownError = (cause: unknown) =>
-        new WebSocketClientError({ cause });
-
-      const query = <Query extends Ref.AnyPublicQuery>(
-        ref: Query,
-        ...rest: Ref.OptionalArgs<Query>
-      ): Effect.Effect<
-        Ref.Returns<Query>,
-        Ref.Error<Query> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Query>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.query(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      const mutation = <Mutation extends Ref.AnyPublicMutation>(
-        ref: Mutation,
-        ...rest: Ref.OptionalArgs<Mutation>
-      ): Effect.Effect<
-        Ref.Returns<Mutation>,
-        Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.mutation(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      const action = <Action extends Ref.AnyPublicAction>(
-        ref: Action,
-        ...rest: Ref.OptionalArgs<Action>
-      ): Effect.Effect<
-        Ref.Returns<Action>,
-        Ref.Error<Action> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Action>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.action(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      const reactiveQuery = <Query extends Ref.AnyPublicQuery>(
-        ref: Query,
-        ...rest: Ref.OptionalArgs<Query>
-      ): Stream.Stream<
-        Ref.Returns<Query>,
-        Ref.Error<Query> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Query>;
-        const functionReference = Ref.getFunctionReference(ref);
-        const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
-
-        return Stream.unwrap(
-          Effect.gen(function* () {
-            const encodedArgs = yield* Ref.encodeArgs(ref, args);
-
-            return Stream.callback<
-              unknown,
-              Ref.Error<Query> | WebSocketClientError
-            >((queue) =>
-              Effect.gen(function* () {
-                const unsubscribe = convexClient.onUpdate(
-                  functionReference,
-                  encodedArgs,
-                  (result) => {
-                    Queue.offerUnsafe(queue, result);
-                  },
-                  (error) => {
-                    Queue.failCauseUnsafe(queue, Cause.fail(onError(error)));
-                  },
-                );
-                yield* Effect.addFinalizer(() =>
-                  Effect.sync(() => unsubscribe()),
-                );
-              }),
-            );
-          }),
-        ).pipe(
-          Stream.mapEffect((encodedReturns) =>
-            Ref.decodeReturns(ref, encodedReturns),
-          ),
-        );
-      };
-
+  InternalWebSocketClient.makeScoped(
+    address,
+    Effect.sync(() => {
+      const convexClient = new ConvexClient(address, options);
       return {
-        url,
-        setAuth,
-        query,
-        mutation,
-        action,
-        reactiveQuery,
+        setAuth: (fetchToken, onChange) =>
+          onChange === undefined
+            ? convexClient.setAuth(fetchToken)
+            : convexClient.setAuth(fetchToken, onChange),
+        close: () => convexClient.close(),
+        query: (functionReference, encodedArgs) =>
+          convexClient.query(functionReference, encodedArgs),
+        mutation: (functionReference, encodedArgs) =>
+          convexClient.mutation(functionReference, encodedArgs),
+        action: (functionReference, encodedArgs) =>
+          convexClient.action(functionReference, encodedArgs),
+        onUpdate: (functionReference, encodedArgs, onUpdate, onError) =>
+          convexClient.onUpdate(
+            functionReference,
+            encodedArgs,
+            onUpdate,
+            onError,
+          ),
       };
     }),
   );
 
 /**
- * A Confect client which uses a WebSocket to communicate with your Convex backend and supports reactive query subscriptions. The WebSocket connection is managed by the layer's scope and closed automatically when the scope ends. Wraps [ConvexClient](https://docs.convex.dev/api/classes/browser.ConvexClient).
+ * A Confect client which uses a WebSocket to communicate with your Convex
+ * backend and supports reactive query subscriptions. The WebSocket connection
+ * is managed by the layer's scope and closed automatically when the scope ends.
+ * Wraps
+ * [ConvexClient](https://docs.convex.dev/api/classes/browser.ConvexClient).
  */
 export const WebSocketClient = Context.Service<
   Effect.Success<ReturnType<typeof make>>

package/src/internal/HttpClient.ts

@@ -0,0 +1,119 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+
+export class HttpClientError extends Schema.TaggedError<HttpClientError>()(
+  "HttpClientError",
+  {
+    cause: Schema.Unknown,
+  },
+) {}
+
+export interface Transport {
+  readonly url: string;
+  readonly setAuth: (token: string) => void;
+  readonly clearAuth: () => void;
+  readonly query: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly mutation: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicMutation>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly action: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicAction>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+}
+
+const runQuery = Effect.fn("HttpClient.query")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+const runMutation = Effect.fn("HttpClient.mutation")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+const runAction = Effect.fn("HttpClient.action")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+export const make = (client: Transport) => {
+  const setAuth = (token: string) =>
+    Effect.sync(() => {
+      client.setAuth(token);
+    });
+
+  const clearAuth = Effect.sync(() => {
+    client.clearAuth();
+  });
+
+  const mapUnknownError = (cause: unknown) => new HttpClientError({ cause });
+
+  const query = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Effect.Effect<
+    Ref.Returns<Query>,
+    Ref.Error<Query> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Query>;
+    return runQuery(
+      Ref.runWithCodec(
+        ref,
+        args,
+        (functionReference, encodedArgs) =>
+          client.query(functionReference, encodedArgs),
+        mapUnknownError,
+      ),
+    );
+  };
+
+  const mutation = <Mutation extends Ref.AnyPublicMutation>(
+    ref: Mutation,
+    ...rest: Ref.OptionalArgs<Mutation>
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
+    return runMutation(
+      Ref.runWithCodec(
+        ref,
+        args,
+        (functionReference, encodedArgs) =>
+          client.mutation(functionReference, encodedArgs),
+        mapUnknownError,
+      ),
+    );
+  };
+
+  const action = <Action extends Ref.AnyPublicAction>(
+    ref: Action,
+    ...rest: Ref.OptionalArgs<Action>
+  ): Effect.Effect<
+    Ref.Returns<Action>,
+    Ref.Error<Action> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Action>;
+    return runAction(
+      Ref.runWithCodec(
+        ref,
+        args,
+        (functionReference, encodedArgs) =>
+          client.action(functionReference, encodedArgs),
+        mapUnknownError,
+      ),
+    );
+  };
+
+  return {
+    url: client.url,
+    setAuth,
+    clearAuth,
+    query,
+    mutation,
+    action,
+  };
+};