@confect/js 10.0.0-next.2 → 10.0.0-next.21

package/src/WebSocketClient.ts

@@ -1,153 +1,38 @@
-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,
+          ),
       };
     }),
   );

package/src/internal/HttpClient.ts

@@ -0,0 +1,101 @@
+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>;
+}
+
+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 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: client.url,
+    setAuth,
+    clearAuth,
+    query,
+    mutation,
+    action,
+  };
+};

package/src/internal/WebSocketClient.ts

@@ -0,0 +1,202 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+export class WebSocketClientError extends Schema.TaggedError<WebSocketClientError>()(
+  "WebSocketClientError",
+  {
+    cause: Schema.Defect(),
+  },
+) {}
+
+export interface Transport {
+  readonly setAuth: (
+    fetchToken: (args: {
+      readonly forceRefreshToken: boolean;
+    }) => Promise<string | null | undefined>,
+    onChange?: (isAuthenticated: boolean) => void,
+  ) => void;
+  readonly close: () => Promise<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>;
+  readonly onUpdate: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,
+    encodedArgs: unknown,
+    onUpdate: (result: unknown) => void,
+    onError: (error: Error) => void,
+  ) => () => void;
+}
+
+export const make = (address: string, convexClient: Transport) => {
+  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,
+    );
+  };
+
+  type ReactiveQueryError<Query extends Ref.AnyPublicQuery> =
+    | Ref.Error<Query>
+    | WebSocketClientError
+    | Schema.SchemaError;
+
+  const reactiveQueryResult = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Stream.Stream<
+    Result.Result<Ref.Returns<Query>, ReactiveQueryError<Query>>
+  > => {
+    type QueryResult = Result.Result<
+      Ref.Returns<Query>,
+      ReactiveQueryError<Query>
+    >;
+    const args = (rest[0] ?? {}) as Ref.Args<Query>;
+    const functionReference = Ref.getFunctionReference(ref);
+    const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
+
+    return Stream.unwrap(
+      Effect.match(Ref.encodeArgs(ref, args), {
+        onFailure: (error) => Stream.succeed<QueryResult>(Result.fail(error)),
+        onSuccess: (encodedArgs) =>
+          Stream.callback<Result.Result<unknown, ReactiveQueryError<Query>>>(
+            (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): Effect.Effect<QueryResult> =>
+        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 = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Stream.Stream<Ref.Returns<Query>, ReactiveQueryError<Query>> =>
+    reactiveQueryResult(ref, ...rest).pipe(
+      Stream.mapEffect(
+        Result.match({
+          onFailure: Effect.fail,
+          onSuccess: Effect.succeed,
+        }),
+      ),
+    );
+
+  return {
+    url: address,
+    setAuth,
+    query,
+    mutation,
+    action,
+    reactiveQuery,
+    reactiveQueryResult,
+  };
+};
+
+export const makeScoped = <E, R>(
+  address: string,
+  acquire: Effect.Effect<Transport, E, R>,
+) =>
+  Effect.acquireRelease(acquire, (convexClient) =>
+    Effect.promise(() => convexClient.close()),
+  ).pipe(Effect.map((convexClient) => make(address, convexClient)));