@vrplatform/graphql 1.0.8 → 1.1.2

package/src/index.ts

@@ -1,95 +1,10 @@
-import { useHasuraClientInner } from './create-client';
-
-export { useHasuraClientInner } from './create-client';
+export {
+  GQtyClient,
+  GQtyError,
+  ResolveOptions,
+  SubscriptionsClient,
+} from 'gqty';
+export { type HasuraClient, useHasuraClient } from './client';
+export * from './common';
 export * from './gqty';
-export { GQtyError } from 'gqty';
-
-import type { LegacyResolveOptions } from 'gqty';
-import type { Mutation, Query, Subscription } from './gqty';
-import type { GqlAuthParam } from './types';
-
-export type ResolveOptionsWithSession<T> = LegacyResolveOptions<T>;
-
-export type HasuraClient = ReturnType<typeof useHasuraClient>;
-
-export function useHasuraClient(args?: GqlAuthParam) {
-  const { client, subscriptionsClient } = useHasuraClientInner(args);
-  const retries = args.retries || 3;
-  return {
-    client,
-    subscriptionsClient,
-    async mutate<T = unknown>(
-      resolved: (sub: Mutation) => T,
-      options?: ResolveOptionsWithSession<T>
-    ) {
-      if (!options) options = {};
-      if (options.noCache === undefined) options.noCache = true;
-
-      let err: any;
-      for (let tries = 1; tries <= retries; tries++) {
-        try {
-          const result = await client.resolve(
-            ({ mutation }) => resolved(mutation),
-            options
-          );
-          return result;
-        } catch (error: any) {
-          err = error;
-          if (error.message !== 'database query error') break;
-          await new Promise((resolve) =>
-            setTimeout(resolve, 1_000 * tries + 1_000)
-          );
-        }
-      }
-      if (args.onError) throw args.onError(err) || err;
-      throw err;
-    },
-    async query<T = unknown>(
-      resolved: (sub: Query) => T,
-      options?: ResolveOptionsWithSession<T>
-    ) {
-      let err: any;
-      for (let tries = 1; tries <= retries; tries++) {
-        try {
-          const result = await client.resolve(
-            ({ query }) => resolved(query),
-            options
-          );
-          return result;
-        } catch (error: any) {
-          err = error;
-          if (error.message !== 'database query error') break;
-          await new Promise((resolve) =>
-            setTimeout(resolve, 1_000 * tries + 1_000)
-          );
-        }
-      }
-      if (args.onError) throw args.onError(err) || err;
-      throw err;
-    },
-    subscribe<T = unknown>(
-      resolved: (sub: 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);
-      };
-
-      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;
-    },
-  };
-}
+export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';

package/src/types.ts

@@ -1,18 +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?:
-    | { [s: string]: string }
-    | (() => Headers)
-    | (() => Promise<Headers>);
-  fetch?: any;
-  // normalization?: boolean;
+  headers?: AllowedHeaders;
   subscriptions?: boolean;
   uri?: string;
-  // cache?: boolean;
-  onError?: (err: Error) => any;
-  /* Retry options, default is 3 times */
-  retries?: number;
   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;
+    },
+  };
+}

package/LICENSE

@@ -1,3 +0,0 @@
-RESTRICTED
-
-THE CODE IS NOT MEANT TO BE SHARED WITH ANYONE OUTSIDE THE MAINTAINERS, AS SET IN THE REPOSITORIES GITHUB ACCESS SETTINGS.

package/build/main/create-client.d.ts

@@ -1,6 +0,0 @@
-import { type GeneratedSchema } from './gqty';
-import type { GqlAuthParam } from './types';
-export declare function useHasuraClientInner(args?: Omit<GqlAuthParam, 'retries'>): {
-    subscriptionsClient: import("graphql-ws").Client;
-    client: import("gqty").GQtyClient<GeneratedSchema>;
-};

package/build/main/create-client.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHasuraClientInner = useHasuraClientInner;
-// import fetch from 'cross-fetch';
-const gqty_1 = require("gqty");
-const graphql_ws_1 = require("graphql-ws");
-const constants_1 = require("./constants");
-const gqty_2 = require("./gqty");
-const error_1 = require("./gqty/error");
-function useHasuraClientInner(args) {
-    const $headers = args && 'headers' in args ? args.headers : undefined;
-    const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || fetch;
-    const uri = args?.uri || constants_1.hasuraGraphqlUri;
-    const getHeaders = async (base) => {
-        const headers = ($headers && typeof $headers === 'function'
-            ? await $headers()
-            : $headers) || {};
-        if (base)
-            for (const key in base)
-                headers[key] = base[key];
-        if (args && 'secret' in args && args.secret) {
-            headers['x-hasura-admin-secret'] = args.secret;
-        }
-        else if (args && 'accessToken' in args && args.accessToken) {
-            headers.authorization = args.accessToken.startsWith('Bearer ')
-                ? args.accessToken
-                : `Bearer ${args.accessToken}`;
-        }
-        if (args?.auditUserId)
-            headers['x-hasura-audit-user-id'] = args.auditUserId;
-        return headers;
-    };
-    const queryFetcher = async ({ query, variables, operationName }, fetchOptions) => {
-        const headers = await getHeaders();
-        if (fetchOptions?.headers) {
-            for (const key in fetchOptions.headers) {
-                headers[key] = fetchOptions.headers[key];
-            }
-        }
-        // Modify "https://finalytic.hasura.app/v1/graphql" if needed
-        const response = await $fetch('https://finalytic.hasura.app/v1/graphql', {
-            ...fetchOptions,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-            body: JSON.stringify({
-                query,
-                variables,
-                operationName,
-            }),
-            mode: 'cors',
-        });
-        const res = await (0, error_1.defaultResponseHandler)(response);
-        return res;
-    };
-    const subscriptionsClient = args?.subscriptions === true
-        ? (0, graphql_ws_1.createClient)({
-            lazy: true,
-            connectionParams: async () => ({
-                headers: await getHeaders({
-                    [constants_1.hasuraQueryTypeHeader]: 'subscription',
-                }),
-            }),
-            url() {
-                const wsUrl = new URL(uri);
-                wsUrl.protocol = wsUrl.protocol
-                    .replace('https', 'wss')
-                    .replace('http', 'ws');
-                return wsUrl.href;
-            },
-            /*url: () => {
-            },*/
-        })
-        : undefined;
-    const cache = new gqty_1.Cache(undefined, {
-        maxAge: 0,
-        staleWhileRevalidate: 0,
-        normalization: false,
-    });
-    const client = (0, gqty_1.createClient)({
-        schema: gqty_2.generatedSchema,
-        scalars: gqty_2.scalarsEnumsHash,
-        //cache,
-        cache,
-        fetchOptions: {
-            fetcher: queryFetcher,
-            subscriber: subscriptionsClient,
-        },
-    });
-    /*const client: GQtyClient<GeneratedSchema> = createClient<GeneratedSchema>({
-      schema: generatedSchema,
-      scalarsEnumsHash,
-      queryFetcher,
-      subscriptionsClient,
-      normalization: args?.normalization === true,
-      defaults: {
-        resolved: {
-          noCache: args?.cache !== true,
-          retry: false,
-        },
-      },
-      ...args,
-    });*/
-    return { subscriptionsClient, client };
-}

package/build/main/gqty/error.d.ts

@@ -1,6 +0,0 @@
-import type { ExecutionResult } from 'graphql';
-export declare const defaultResponseHandler: (response: Response) => Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;
-export declare const parseResponse: (response: Response) => Promise<any>;
-export declare function assertExecutionResult(input: unknown): asserts input is ExecutionResult;
-export declare const isExecutionResult: (input: unknown) => input is ExecutionResult;
-export declare const handleResponseErrors: (result: ExecutionResult) => void;

package/build/main/gqty/error.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleResponseErrors = exports.isExecutionResult = exports.parseResponse = exports.defaultResponseHandler = void 0;
-exports.assertExecutionResult = assertExecutionResult;
-const gqty_1 = require("gqty");
-const defaultResponseHandler = async (response) => {
-    const result = await (0, exports.parseResponse)(response);
-    assertExecutionResult(result);
-    (0, exports.handleResponseErrors)(result);
-    return result;
-};
-exports.defaultResponseHandler = defaultResponseHandler;
-const parseResponse = async (response) => {
-    const text = await response.text().then((text) => text.trim() || null);
-    if (response.status >= 400) {
-        throw new gqty_1.GQtyError(`Received HTTP ${response.status} from GraphQL endpoint${text
-            ? `, body: ${text.length > 50 ? `${text.slice(0, 50)}...` : text}`
-            : ''}.`);
-    }
-    if (!text) {
-        throw new gqty_1.GQtyError('Received an empty response from GraphQL endpoint.');
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        throw new gqty_1.GQtyError(`Received malformed JSON response from GraphQL endpoint: ${text.length > 50 ? `${text.slice(0, 50)}...` : text}`);
-    }
-};
-exports.parseResponse = parseResponse;
-function assertExecutionResult(input) {
-    if (!(0, exports.isExecutionResult)(input)) {
-        throw new gqty_1.GQtyError(`Expected response to be an ExecutionResult, received: ${JSON.stringify(input)}`);
-    }
-}
-const isExecutionResult = (input) => {
-    if (typeof input !== 'object' || input === null)
-        return false;
-    const value = input;
-    return 'data' in value || Array.isArray(value.errors);
-};
-exports.isExecutionResult = isExecutionResult;
-const handleResponseErrors = (result) => {
-    if (result.errors?.length) {
-        throw gqty_1.GQtyError.fromGraphQLErrors(result.errors);
-    }
-};
-exports.handleResponseErrors = handleResponseErrors;

package/build/module/create-client.d.ts

@@ -1,6 +0,0 @@
-import { type GeneratedSchema } from './gqty';
-import type { GqlAuthParam } from './types';
-export declare function useHasuraClientInner(args?: Omit<GqlAuthParam, 'retries'>): {
-    subscriptionsClient: import("graphql-ws").Client;
-    client: import("gqty").GQtyClient<GeneratedSchema>;
-};

package/build/module/create-client.js

@@ -1,104 +0,0 @@
-// import fetch from 'cross-fetch';
-import { Cache, createClient } from 'gqty';
-import { createClient as createSubscriptionsClient } from 'graphql-ws';
-import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
-import { generatedSchema, scalarsEnumsHash, } from './gqty';
-import { defaultResponseHandler } from './gqty/error';
-export function useHasuraClientInner(args) {
-    const $headers = args && 'headers' in args ? args.headers : undefined;
-    const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || fetch;
-    const uri = args?.uri || hasuraGraphqlUri;
-    const getHeaders = async (base) => {
-        const headers = ($headers && typeof $headers === 'function'
-            ? await $headers()
-            : $headers) || {};
-        if (base)
-            for (const key in base)
-                headers[key] = base[key];
-        if (args && 'secret' in args && args.secret) {
-            headers['x-hasura-admin-secret'] = args.secret;
-        }
-        else if (args && 'accessToken' in args && args.accessToken) {
-            headers.authorization = args.accessToken.startsWith('Bearer ')
-                ? args.accessToken
-                : `Bearer ${args.accessToken}`;
-        }
-        if (args?.auditUserId)
-            headers['x-hasura-audit-user-id'] = args.auditUserId;
-        return headers;
-    };
-    const queryFetcher = async ({ query, variables, operationName }, fetchOptions) => {
-        const headers = await getHeaders();
-        if (fetchOptions?.headers) {
-            for (const key in fetchOptions.headers) {
-                headers[key] = fetchOptions.headers[key];
-            }
-        }
-        // Modify "https://finalytic.hasura.app/v1/graphql" if needed
-        const response = await $fetch('https://finalytic.hasura.app/v1/graphql', {
-            ...fetchOptions,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-            body: JSON.stringify({
-                query,
-                variables,
-                operationName,
-            }),
-            mode: 'cors',
-        });
-        const res = await defaultResponseHandler(response);
-        return res;
-    };
-    const subscriptionsClient = args?.subscriptions === true
-        ? createSubscriptionsClient({
-            lazy: true,
-            connectionParams: async () => ({
-                headers: await getHeaders({
-                    [hasuraQueryTypeHeader]: 'subscription',
-                }),
-            }),
-            url() {
-                const wsUrl = new URL(uri);
-                wsUrl.protocol = wsUrl.protocol
-                    .replace('https', 'wss')
-                    .replace('http', 'ws');
-                return wsUrl.href;
-            },
-            /*url: () => {
-            },*/
-        })
-        : undefined;
-    const cache = new Cache(undefined, {
-        maxAge: 0,
-        staleWhileRevalidate: 0,
-        normalization: false,
-    });
-    const client = createClient({
-        schema: generatedSchema,
-        scalars: scalarsEnumsHash,
-        //cache,
-        cache,
-        fetchOptions: {
-            fetcher: queryFetcher,
-            subscriber: subscriptionsClient,
-        },
-    });
-    /*const client: GQtyClient<GeneratedSchema> = createClient<GeneratedSchema>({
-      schema: generatedSchema,
-      scalarsEnumsHash,
-      queryFetcher,
-      subscriptionsClient,
-      normalization: args?.normalization === true,
-      defaults: {
-        resolved: {
-          noCache: args?.cache !== true,
-          retry: false,
-        },
-      },
-      ...args,
-    });*/
-    return { subscriptionsClient, client };
-}

package/build/module/gqty/error.d.ts

@@ -1,6 +0,0 @@
-import type { ExecutionResult } from 'graphql';
-export declare const defaultResponseHandler: (response: Response) => Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;
-export declare const parseResponse: (response: Response) => Promise<any>;
-export declare function assertExecutionResult(input: unknown): asserts input is ExecutionResult;
-export declare const isExecutionResult: (input: unknown) => input is ExecutionResult;
-export declare const handleResponseErrors: (result: ExecutionResult) => void;

package/build/module/gqty/error.js

@@ -1,40 +0,0 @@
-import { GQtyError } from 'gqty';
-export const defaultResponseHandler = async (response) => {
-    const result = await parseResponse(response);
-    assertExecutionResult(result);
-    handleResponseErrors(result);
-    return result;
-};
-export const parseResponse = async (response) => {
-    const text = await response.text().then((text) => text.trim() || null);
-    if (response.status >= 400) {
-        throw new GQtyError(`Received HTTP ${response.status} from GraphQL endpoint${text
-            ? `, body: ${text.length > 50 ? `${text.slice(0, 50)}...` : text}`
-            : ''}.`);
-    }
-    if (!text) {
-        throw new GQtyError('Received an empty response from GraphQL endpoint.');
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        throw new GQtyError(`Received malformed JSON response from GraphQL endpoint: ${text.length > 50 ? `${text.slice(0, 50)}...` : text}`);
-    }
-};
-export function assertExecutionResult(input) {
-    if (!isExecutionResult(input)) {
-        throw new GQtyError(`Expected response to be an ExecutionResult, received: ${JSON.stringify(input)}`);
-    }
-}
-export const isExecutionResult = (input) => {
-    if (typeof input !== 'object' || input === null)
-        return false;
-    const value = input;
-    return 'data' in value || Array.isArray(value.errors);
-};
-export const handleResponseErrors = (result) => {
-    if (result.errors?.length) {
-        throw GQtyError.fromGraphQLErrors(result.errors);
-    }
-};

package/src/create-client.ts

@@ -1,120 +0,0 @@
-// import fetch from 'cross-fetch';
-import { Cache, type QueryFetcher, createClient } from 'gqty';
-import { createClient as createSubscriptionsClient } from 'graphql-ws';
-import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
-import {
-  type GeneratedSchema,
-  generatedSchema,
-  scalarsEnumsHash,
-} from './gqty';
-import { defaultResponseHandler } from './gqty/error';
-import type { GqlAuthParam, Headers } from './types';
-
-export function useHasuraClientInner(args?: Omit<GqlAuthParam, 'retries'>) {
-  const $headers = args && 'headers' in args ? args.headers : undefined;
-  const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || fetch;
-  const uri = args?.uri || hasuraGraphqlUri;
-
-  const getHeaders = async (base?: Headers): Promise<Headers> => {
-    const headers: Record<string, any> =
-      ($headers && typeof $headers === 'function'
-        ? await $headers()
-        : $headers) || {};
-    if (base) for (const key in base) headers[key] = base[key];
-    if (args && 'secret' in args && args.secret) {
-      headers['x-hasura-admin-secret'] = args.secret;
-    } else if (args && 'accessToken' in args && args.accessToken) {
-      headers.authorization = args.accessToken.startsWith('Bearer ')
-        ? args.accessToken
-        : `Bearer ${args.accessToken}`;
-    }
-    if (args?.auditUserId) headers['x-hasura-audit-user-id'] = args.auditUserId;
-    return headers;
-  };
-
-  const queryFetcher: QueryFetcher = async (
-    { query, variables, operationName },
-    fetchOptions
-  ) => {
-    const headers = await getHeaders();
-    if (fetchOptions?.headers) {
-      for (const key in fetchOptions.headers) {
-        headers[key] = fetchOptions.headers[key];
-      }
-    }
-
-    // Modify "https://finalytic.hasura.app/v1/graphql" if needed
-    const response = await $fetch('https://finalytic.hasura.app/v1/graphql', {
-      ...fetchOptions,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers,
-      },
-      body: JSON.stringify({
-        query,
-        variables,
-        operationName,
-      }),
-      mode: 'cors',
-    });
-
-    const res = await defaultResponseHandler(response);
-    return res;
-  };
-
-  const subscriptionsClient =
-    args?.subscriptions === true
-      ? createSubscriptionsClient({
-          lazy: true,
-          connectionParams: async () => ({
-            headers: await getHeaders({
-              [hasuraQueryTypeHeader]: 'subscription',
-            }),
-          }),
-          url() {
-            const wsUrl = new URL(uri);
-            wsUrl.protocol = wsUrl.protocol
-              .replace('https', 'wss')
-              .replace('http', 'ws');
-            return wsUrl.href;
-          },
-          /*url: () => {
-          },*/
-        })
-      : undefined;
-
-  const cache = new Cache(undefined, {
-    maxAge: 0,
-    staleWhileRevalidate: 0,
-    normalization: false,
-  });
-
-  const client = createClient<GeneratedSchema>({
-    schema: generatedSchema,
-    scalars: scalarsEnumsHash,
-    //cache,
-    cache,
-    fetchOptions: {
-      fetcher: queryFetcher,
-      subscriber: subscriptionsClient,
-    },
-  });
-
-  /*const client: GQtyClient<GeneratedSchema> = createClient<GeneratedSchema>({
-    schema: generatedSchema,
-    scalarsEnumsHash,
-    queryFetcher,
-    subscriptionsClient,
-    normalization: args?.normalization === true,
-    defaults: {
-      resolved: {
-        noCache: args?.cache !== true,
-        retry: false,
-      },
-    },
-    ...args,
-  });*/
-
-  return { subscriptionsClient, client };
-}