@vrplatform/graphql 1.0.0-staging.0

package/src/index.ts

@@ -0,0 +1,10 @@
+export {
+  GQtyClient,
+  GQtyError,
+  ResolveOptions,
+  SubscriptionsClient,
+} from 'gqty';
+export { type HasuraClient, useHasuraClient } from './client';
+export * from './common';
+export * from './gqty';
+export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';

package/src/types.ts

@@ -0,0 +1,14 @@
+export type Headers = { [s: string]: string };
+export type AllowedHeaders =
+  | { [s: string]: string }
+  | (() => Headers)
+  | (() => Promise<Headers>);
+export type GqlAuthParam = {
+  accessToken?: string;
+  secret?: string;
+  headers?: AllowedHeaders;
+  subscriptions?: boolean;
+  uri?: string;
+  auditUserId?: string;
+  credentials?: RequestCredentials;
+};

package/src/wrap.ts

@@ -0,0 +1,67 @@
+import type { GQtyClient, ResolveOptions, SubscriptionsClient } from 'gqty';
+import type { GeneratedSchema } from './gqty';
+
+export type ResolveOptionsWithSession<T> = ResolveOptions<T>;
+
+type Client = GQtyClient<GeneratedSchema>;
+export function wrapGraphQLClient(
+  getClient: () => Client,
+  subscriptionsClient?: SubscriptionsClient
+) {
+  return {
+    get client() {
+      return getClient();
+    },
+    subscriptionsClient,
+    async mutate<T = unknown>(
+      resolved: (sub: Client['mutation']) => T,
+      options?: ResolveOptionsWithSession<T>
+    ) {
+      if (!options) options = {};
+      if (options.noCache === undefined) options.noCache = true;
+
+      const client = getClient();
+      const result = await client.resolved(
+        () => resolved(client.mutation),
+        options
+      );
+      return result;
+    },
+    async query<T = unknown>(
+      resolved: (sub: Client['query']) => T,
+      options?: ResolveOptionsWithSession<T>
+    ) {
+      const client = getClient();
+      const result = await client.resolved(
+        () => resolved(client.query),
+        options
+      );
+      return result;
+    },
+    subscribe<T = unknown>(
+      resolved: (sub: Client['subscription']) => T,
+      onData: (data: T, unsubscribeFn: () => Promise<void>) => void,
+      onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void
+    ) {
+      if (!subscriptionsClient) throw new Error('Subscriptions not enabled');
+      let unsub: undefined | (() => Promise<void>);
+
+      const stop = async () => {
+        if (!unsub) return;
+        await unsub().catch(() => undefined);
+      };
+
+      const client = getClient();
+      client.resolved(() => resolved(client.subscription), {
+        onSubscription(event) {
+          if (event.unsubscribe) unsub = event.unsubscribe;
+
+          if (event.type === 'data') onData(event.data, stop);
+          else if (event.type === 'with-errors' && onError)
+            onError(event.error, stop);
+        },
+      });
+      return stop;
+    },
+  };
+}