@gaganref/confect-js 0.0.0-stage → 10.3.1-fork.1

package/src/WebSocketClient.ts

@@ -0,0 +1,56 @@
+import { ConvexClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as InternalWebSocketClient from "./internal/WebSocketClient";
+
+export { WebSocketClientError } from "./internal/WebSocketClient";
+
+const make = (
+  address: string,
+  options?: ConstructorParameters<typeof ConvexClient>[1],
+) =>
+  InternalWebSocketClient.makeScoped(
+    address,
+    Effect.sync(() => {
+      const convexClient = new ConvexClient(address, options);
+      return {
+        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).
+ */
+export const WebSocketClient = Context.Service<
+  Effect.Success<ReturnType<typeof make>>
+>("@confect/js/WebSocketClient");
+
+export type WebSocketClient = typeof WebSocketClient.Identifier;
+
+export const layer = (
+  address: string,
+  options?: ConstructorParameters<typeof ConvexClient>[1],
+) => Layer.effect(WebSocketClient, make(address, options));

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as WebSocketClient from "./WebSocketClient";
+export * as HttpClient from "./HttpClient";

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,
+  };
+};

package/src/internal/WebSocketClient.ts

@@ -0,0 +1,224 @@
+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;
+}
+
+const runQuery = Effect.fn("WebSocketClient.query")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+const runMutation = Effect.fn("WebSocketClient.mutation")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+const runAction = Effect.fn("WebSocketClient.action")(
+  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,
+);
+
+export const make = (address: string, convexClient: Transport) => {
+  const setAuth = <R1 = never, R2 = never>(
+    fetchToken: (args: {
+      forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>,
+    onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>,
+  ): Effect.Effect<void, never, R1 | R2> =>
+    Effect.gen(function* () {
+      const context = yield* Effect.context<R1 | R2>();
+      const runPromise = Effect.runPromiseWith(context);
+      const runFork = Effect.runForkWith(context);
+      convexClient.setAuth(
+        (args) => runPromise(Effect.suspend(() => fetchToken(args))),
+        ...(onChange
+          ? [
+              (isAuthenticated: boolean) => {
+                runFork(Effect.suspend(() => 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 runQuery(
+      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 runMutation(
+      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 runAction(
+      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)));