@vrplatform/graphql 1.0.5 → 1.0.7

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

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

package/build/main/create-client.js

@@ -6,6 +6,7 @@ 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;
@@ -51,7 +52,8 @@ function useHasuraClientInner(args) {
             }),
             mode: 'cors',
         });
-        return await (0, gqty_1.defaultResponseHandler)(response);
+        const res = await (0, error_1.defaultResponseHandler)(response);
+        return res;
     };
     const subscriptionsClient = args?.subscriptions === true
         ? (0, graphql_ws_1.createClient)({

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,48 @@
+"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/main/index.d.ts

@@ -1,10 +1,11 @@
-export { type HasuraClient, useHasuraClientInner } from './create-client';
+export { useHasuraClientInner } from './create-client';
 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 declare function useHasuraClient(args?: GqlAuthParam): {
     client: import("gqty").GQtyClient<import("./gqty").GeneratedSchema>;
     subscriptionsClient: import("graphql-ws").Client;

package/build/main/index.js

@@ -55,9 +55,11 @@ function useHasuraClient(args) {
             for (let tries = 1; tries <= retries; tries++) {
                 try {
                     const result = await client.resolve(({ query }) => resolved(query), options);
+                    console.log('RESULT', result);
                     return result;
                 }
                 catch (error) {
+                    console.log('ERROR', error);
                     err = error;
                     if (error.message !== 'database query error')
                         break;
@@ -66,6 +68,7 @@ function useHasuraClient(args) {
             }
             if (args.onError)
                 throw args.onError(err) || err;
+            console.log('THROW', err);
             throw err;
         },
         subscribe(resolved, onData, onError) {

package/build/main/tsconfig.main.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.ts","../../src/types.ts","../../src/gqty/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}
+{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.ts","../../src/types.ts","../../src/gqty/error.ts","../../src/gqty/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}

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

@@ -1,6 +1,5 @@
 import { type GeneratedSchema } from './gqty';
 import type { GqlAuthParam } from './types';
-export type HasuraClient = ReturnType<typeof useHasuraClientInner>;
 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,8 +1,9 @@
 // import fetch from 'cross-fetch';
-import { Cache, createClient, defaultResponseHandler, } from 'gqty';
+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;
@@ -48,7 +49,8 @@ export function useHasuraClientInner(args) {
             }),
             mode: 'cors',
         });
-        return await defaultResponseHandler(response);
+        const res = await defaultResponseHandler(response);
+        return res;
     };
     const subscriptionsClient = args?.subscriptions === true
         ? createSubscriptionsClient({

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,40 @@
+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/build/module/index.d.ts

@@ -1,10 +1,11 @@
-export { type HasuraClient, useHasuraClientInner } from './create-client';
+export { useHasuraClientInner } from './create-client';
 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 declare function useHasuraClient(args?: GqlAuthParam): {
     client: import("gqty").GQtyClient<import("./gqty").GeneratedSchema>;
     subscriptionsClient: import("graphql-ws").Client;

package/build/module/index.js

@@ -35,9 +35,11 @@ export function useHasuraClient(args) {
             for (let tries = 1; tries <= retries; tries++) {
                 try {
                     const result = await client.resolve(({ query }) => resolved(query), options);
+                    console.log('RESULT', result);
                     return result;
                 }
                 catch (error) {
+                    console.log('ERROR', error);
                     err = error;
                     if (error.message !== 'database query error')
                         break;
@@ -46,6 +48,7 @@ export function useHasuraClient(args) {
             }
             if (args.onError)
                 throw args.onError(err) || err;
+            console.log('THROW', err);
             throw err;
         },
         subscribe(resolved, onData, onError) {

package/build/module/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.ts","../../src/types.ts","../../src/gqty/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}
+{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.ts","../../src/types.ts","../../src/gqty/error.ts","../../src/gqty/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}

package/package.json

@@ -10,7 +10,7 @@
     "!**/*.spec.*",
     "LICENSE"
   ],
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Finalytic graphql",
   "main": "build/main/index.js",
   "module": "build/module/index.js",

package/src/create-client.ts

@@ -1,10 +1,5 @@
 // import fetch from 'cross-fetch';
-import {
-  Cache,
-  type QueryFetcher,
-  createClient,
-  defaultResponseHandler,
-} from 'gqty';
+import { Cache, type QueryFetcher, createClient } from 'gqty';
 import { createClient as createSubscriptionsClient } from 'graphql-ws';
 import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
 import {
@@ -12,10 +7,9 @@ import {
   generatedSchema,
   scalarsEnumsHash,
 } from './gqty';
+import { defaultResponseHandler } from './gqty/error';
 import type { GqlAuthParam, Headers } from './types';
 
-export type HasuraClient = ReturnType<typeof useHasuraClientInner>;
-
 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;
@@ -65,7 +59,8 @@ export function useHasuraClientInner(args?: Omit<GqlAuthParam, 'retries'>) {
       mode: 'cors',
     });
 
-    return await defaultResponseHandler(response);
+    const res = await defaultResponseHandler(response);
+    return res;
   };
 
   const subscriptionsClient =

package/src/gqty/error.ts

@@ -0,0 +1,54 @@
+import { GQtyError } from 'gqty';
+import type { ExecutionResult } from 'graphql';
+export const defaultResponseHandler = async (response: Response) => {
+  const result = await parseResponse(response);
+  assertExecutionResult(result);
+  handleResponseErrors(result);
+  return result;
+};
+export const parseResponse = async (response: 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: unknown
+): asserts input is ExecutionResult {
+  if (!isExecutionResult(input)) {
+    throw new GQtyError(
+      `Expected response to be an ExecutionResult, received: ${JSON.stringify(
+        input
+      )}`
+    );
+  }
+}
+export const isExecutionResult = (input: unknown): input is ExecutionResult => {
+  if (typeof input !== 'object' || input === null) return false;
+  const value = input as Record<string, unknown>;
+  return 'data' in value || Array.isArray(value.errors);
+};
+
+export const handleResponseErrors = (result: ExecutionResult) => {
+  if (result.errors?.length) {
+    throw GQtyError.fromGraphQLErrors(result.errors);
+  }
+};

package/src/index.ts

@@ -1,6 +1,6 @@
 import { useHasuraClientInner } from './create-client';
 
-export { type HasuraClient, useHasuraClientInner } from './create-client';
+export { useHasuraClientInner } from './create-client';
 export * from './gqty';
 export { GQtyError } from 'gqty';
 
@@ -10,6 +10,8 @@ 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;
@@ -53,8 +55,10 @@ export function useHasuraClient(args?: GqlAuthParam) {
             ({ query }) => resolved(query),
             options
           );
+          console.log('RESULT', result);
           return result;
         } catch (error: any) {
+          console.log('ERROR', error);
           err = error;
           if (error.message !== 'database query error') break;
           await new Promise((resolve) =>
@@ -63,6 +67,7 @@ export function useHasuraClient(args?: GqlAuthParam) {
         }
       }
       if (args.onError) throw args.onError(err) || err;
+      console.log('THROW', err);
       throw err;
     },
     subscribe<T = unknown>(