@vrplatform/graphql 1.0.4 → 1.0.6

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

@@ -1,11 +1,6 @@
-import { type GQtyClient } from 'gqty';
 import { type GeneratedSchema } from './gqty';
 import type { GqlAuthParam } from './types';
-export type HasuraClient = ReturnType<typeof useHasuraClient>;
-export declare function useHasuraClient(args?: GqlAuthParam): {
-    client: GQtyClient<GeneratedSchema>;
-    subscriptionsClient: import("gqty").LegacySubscriptionsClient;
-    mutate<T = unknown>(resolved: (sub: import("./gqty").Mutation) => T, options?: import("./wrap").ResolveOptionsWithSession<T>): Promise<T>;
-    query<T = unknown>(resolved: (sub: import("./gqty").Query) => T, options?: import("./wrap").ResolveOptionsWithSession<T>): Promise<T>;
-    subscribe<T = unknown>(resolved: (sub: import("./gqty").Subscription) => T, onData: (data: T, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
+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,18 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHasuraClient = useHasuraClient;
-const subscriptions_1 = require("@gqty/subscriptions");
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
+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 wrap_1 = require("./wrap");
-function useHasuraClient(args) {
+function useHasuraClientInner(args) {
     const $headers = args && 'headers' in args ? args.headers : undefined;
-    const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || cross_fetch_1.default;
+    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'
@@ -41,10 +37,12 @@ function useHasuraClient(args) {
             }
         }
         // Modify "https://finalytic.hasura.app/v1/graphql" if needed
-        const response = await (0, cross_fetch_1.default)('https://finalytic.hasura.app/v1/graphql', {
+        const response = await $fetch('https://finalytic.hasura.app/v1/graphql', {
+            ...fetchOptions,
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
+                ...headers,
             },
             body: JSON.stringify({
                 query,
@@ -52,20 +50,18 @@ function useHasuraClient(args) {
                 operationName,
             }),
             mode: 'cors',
-            ...fetchOptions,
         });
-        const json = await response.json();
-        return await (0, gqty_1.defaultResponseHandler)(json);
+        return await (0, gqty_1.defaultResponseHandler)(response);
     };
     const subscriptionsClient = args?.subscriptions === true
-        ? (0, subscriptions_1.createSubscriptionsClient)({
+        ? (0, graphql_ws_1.createClient)({
             lazy: true,
-            connectionInitPayload: async () => ({
+            connectionParams: async () => ({
                 headers: await getHeaders({
                     [constants_1.hasuraQueryTypeHeader]: 'subscription',
                 }),
             }),
-            wsEndpoint() {
+            url() {
                 const wsUrl = new URL(uri);
                 wsUrl.protocol = wsUrl.protocol
                     .replace('https', 'wss')
@@ -76,28 +72,15 @@ function useHasuraClient(args) {
             },*/
         })
         : undefined;
-    /*const subscriptionsClient = (() => {
-      if (args?.subscriptions === false) return;
-      const wsUrl = new URL(uri);
-      wsUrl.protocol = wsUrl.protocol
-        .replace('https', 'wss')
-        .replace('http', 'ws');
-      const subscriptionsClient: SubscriptionsClient = createSubscriptionsClient({
-        wsEndpoint: wsUrl.href,
-        connectionInitPayload: async () => ({
-          headers: await getHeaders({ [hasuraQueryTypeHeader]: 'subscription' }),
-        }),
-      });
-      return subscriptionsClient;
-    })();*/
     const cache = new gqty_1.Cache(undefined, {
         maxAge: 0,
-        staleWhileRevalidate: 5 * 60 * 1000,
-        normalization: true,
+        staleWhileRevalidate: 0,
+        normalization: false,
     });
     const client = (0, gqty_1.createClient)({
         schema: gqty_2.generatedSchema,
         scalars: gqty_2.scalarsEnumsHash,
+        //cache,
         cache,
         fetchOptions: {
             fetcher: queryFetcher,
@@ -118,5 +101,5 @@ function useHasuraClient(args) {
       },
       ...args,
     });*/
-    return (0, wrap_1.wrapGraphQLClient)(client, subscriptionsClient, args?.onError, args?.retries);
+    return { subscriptionsClient, client };
 }

package/build/main/index.d.ts

@@ -1,4 +1,15 @@
-export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';
-export { type HasuraClient, useHasuraClient } from './create-client';
+export { useHasuraClientInner } from './create-client';
 export * from './gqty';
-export { GQtyClient, LegacySubscriptionsClient as SubscriptionsClient, LegacyResolveOptions as ResolveOptions, GQtyError, } 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;
+    mutate<T = unknown>(resolved: (sub: Mutation) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    query<T = unknown>(resolved: (sub: Query) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    subscribe<T = unknown>(resolved: (sub: Subscription) => T, onData: (data: T, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
+};

package/build/main/index.js

@@ -14,11 +14,80 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GQtyError = exports.useHasuraClient = exports.wrapGraphQLClient = void 0;
-var wrap_1 = require("./wrap");
-Object.defineProperty(exports, "wrapGraphQLClient", { enumerable: true, get: function () { return wrap_1.wrapGraphQLClient; } });
-var create_client_1 = require("./create-client");
-Object.defineProperty(exports, "useHasuraClient", { enumerable: true, get: function () { return create_client_1.useHasuraClient; } });
+exports.GQtyError = exports.useHasuraClientInner = void 0;
+exports.useHasuraClient = useHasuraClient;
+const create_client_1 = require("./create-client");
+var create_client_2 = require("./create-client");
+Object.defineProperty(exports, "useHasuraClientInner", { enumerable: true, get: function () { return create_client_2.useHasuraClientInner; } });
 __exportStar(require("./gqty"), exports);
 var gqty_1 = require("gqty");
 Object.defineProperty(exports, "GQtyError", { enumerable: true, get: function () { return gqty_1.GQtyError; } });
+function useHasuraClient(args) {
+    const { client, subscriptionsClient } = (0, create_client_1.useHasuraClientInner)(args);
+    const retries = args.retries || 3;
+    return {
+        client,
+        subscriptionsClient,
+        async mutate(resolved, options) {
+            if (!options)
+                options = {};
+            if (options.noCache === undefined)
+                options.noCache = true;
+            let err;
+            for (let tries = 1; tries <= retries; tries++) {
+                try {
+                    const result = await client.resolve(({ mutation }) => resolved(mutation), options);
+                    return result;
+                }
+                catch (error) {
+                    err = error;
+                    if (error.message !== 'database query error')
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * tries + 1000));
+                }
+            }
+            if (args.onError)
+                throw args.onError(err) || err;
+            throw err;
+        },
+        async query(resolved, options) {
+            let err;
+            for (let tries = 1; tries <= retries; tries++) {
+                try {
+                    const result = await client.resolve(({ query }) => resolved(query), options);
+                    return result;
+                }
+                catch (error) {
+                    err = error;
+                    if (error.message !== 'database query error')
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * tries + 1000));
+                }
+            }
+            if (args.onError)
+                throw args.onError(err) || err;
+            throw err;
+        },
+        subscribe(resolved, onData, onError) {
+            if (!subscriptionsClient)
+                throw new Error('Subscriptions not enabled');
+            let unsub;
+            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;
+        },
+    };
+}

package/build/main/tsconfig.main.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.spec.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/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}

package/build/main/types.d.ts

@@ -8,10 +8,8 @@ export type GqlAuthParam = {
         [s: string]: string;
     } | (() => Headers) | (() => Promise<Headers>);
     fetch?: any;
-    normalization?: boolean;
     subscriptions?: boolean;
     uri?: string;
-    cache?: boolean;
     onError?: (err: Error) => any;
     retries?: number;
     auditUserId?: string;

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

@@ -1,11 +1,6 @@
-import { type GQtyClient } from 'gqty';
 import { type GeneratedSchema } from './gqty';
 import type { GqlAuthParam } from './types';
-export type HasuraClient = ReturnType<typeof useHasuraClient>;
-export declare function useHasuraClient(args?: GqlAuthParam): {
-    client: GQtyClient<GeneratedSchema>;
-    subscriptionsClient: import("gqty").LegacySubscriptionsClient;
-    mutate<T = unknown>(resolved: (sub: import("./gqty").Mutation) => T, options?: import("./wrap").ResolveOptionsWithSession<T>): Promise<T>;
-    query<T = unknown>(resolved: (sub: import("./gqty").Query) => T, options?: import("./wrap").ResolveOptionsWithSession<T>): Promise<T>;
-    subscribe<T = unknown>(resolved: (sub: import("./gqty").Subscription) => T, onData: (data: T, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
+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,10 +1,9 @@
-import { createSubscriptionsClient } from '@gqty/subscriptions';
-import fetch from 'cross-fetch';
+// import fetch from 'cross-fetch';
 import { Cache, createClient, defaultResponseHandler, } from 'gqty';
+import { createClient as createSubscriptionsClient } from 'graphql-ws';
 import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
 import { generatedSchema, scalarsEnumsHash, } from './gqty';
-import { wrapGraphQLClient } from './wrap';
-export function useHasuraClient(args) {
+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;
@@ -35,10 +34,12 @@ export function useHasuraClient(args) {
             }
         }
         // Modify "https://finalytic.hasura.app/v1/graphql" if needed
-        const response = await fetch('https://finalytic.hasura.app/v1/graphql', {
+        const response = await $fetch('https://finalytic.hasura.app/v1/graphql', {
+            ...fetchOptions,
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
+                ...headers,
             },
             body: JSON.stringify({
                 query,
@@ -46,20 +47,18 @@ export function useHasuraClient(args) {
                 operationName,
             }),
             mode: 'cors',
-            ...fetchOptions,
         });
-        const json = await response.json();
-        return await defaultResponseHandler(json);
+        return await defaultResponseHandler(response);
     };
     const subscriptionsClient = args?.subscriptions === true
         ? createSubscriptionsClient({
             lazy: true,
-            connectionInitPayload: async () => ({
+            connectionParams: async () => ({
                 headers: await getHeaders({
                     [hasuraQueryTypeHeader]: 'subscription',
                 }),
             }),
-            wsEndpoint() {
+            url() {
                 const wsUrl = new URL(uri);
                 wsUrl.protocol = wsUrl.protocol
                     .replace('https', 'wss')
@@ -70,28 +69,15 @@ export function useHasuraClient(args) {
             },*/
         })
         : undefined;
-    /*const subscriptionsClient = (() => {
-      if (args?.subscriptions === false) return;
-      const wsUrl = new URL(uri);
-      wsUrl.protocol = wsUrl.protocol
-        .replace('https', 'wss')
-        .replace('http', 'ws');
-      const subscriptionsClient: SubscriptionsClient = createSubscriptionsClient({
-        wsEndpoint: wsUrl.href,
-        connectionInitPayload: async () => ({
-          headers: await getHeaders({ [hasuraQueryTypeHeader]: 'subscription' }),
-        }),
-      });
-      return subscriptionsClient;
-    })();*/
     const cache = new Cache(undefined, {
         maxAge: 0,
-        staleWhileRevalidate: 5 * 60 * 1000,
-        normalization: true,
+        staleWhileRevalidate: 0,
+        normalization: false,
     });
     const client = createClient({
         schema: generatedSchema,
         scalars: scalarsEnumsHash,
+        //cache,
         cache,
         fetchOptions: {
             fetcher: queryFetcher,
@@ -112,5 +98,5 @@ export function useHasuraClient(args) {
       },
       ...args,
     });*/
-    return wrapGraphQLClient(client, subscriptionsClient, args?.onError, args?.retries);
+    return { subscriptionsClient, client };
 }

package/build/module/index.d.ts

@@ -1,4 +1,15 @@
-export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';
-export { type HasuraClient, useHasuraClient } from './create-client';
+export { useHasuraClientInner } from './create-client';
 export * from './gqty';
-export { GQtyClient, LegacySubscriptionsClient as SubscriptionsClient, LegacyResolveOptions as ResolveOptions, GQtyError, } 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;
+    mutate<T = unknown>(resolved: (sub: Mutation) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    query<T = unknown>(resolved: (sub: Query) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    subscribe<T = unknown>(resolved: (sub: Subscription) => T, onData: (data: T, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
+};

package/build/module/index.js

@@ -1,4 +1,73 @@
-export { wrapGraphQLClient } from './wrap';
-export { useHasuraClient } from './create-client';
+import { useHasuraClientInner } from './create-client';
+export { useHasuraClientInner } from './create-client';
 export * from './gqty';
-export { GQtyError, } from 'gqty';
+export { GQtyError } from 'gqty';
+export function useHasuraClient(args) {
+    const { client, subscriptionsClient } = useHasuraClientInner(args);
+    const retries = args.retries || 3;
+    return {
+        client,
+        subscriptionsClient,
+        async mutate(resolved, options) {
+            if (!options)
+                options = {};
+            if (options.noCache === undefined)
+                options.noCache = true;
+            let err;
+            for (let tries = 1; tries <= retries; tries++) {
+                try {
+                    const result = await client.resolve(({ mutation }) => resolved(mutation), options);
+                    return result;
+                }
+                catch (error) {
+                    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(resolved, options) {
+            let err;
+            for (let tries = 1; tries <= retries; tries++) {
+                try {
+                    const result = await client.resolve(({ query }) => resolved(query), options);
+                    return result;
+                }
+                catch (error) {
+                    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(resolved, onData, onError) {
+            if (!subscriptionsClient)
+                throw new Error('Subscriptions not enabled');
+            let unsub;
+            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;
+        },
+    };
+}

package/build/module/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../src/constants.ts","../../src/create-client.ts","../../src/index.spec.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/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.6.3"}

package/build/module/types.d.ts

@@ -8,10 +8,8 @@ export type GqlAuthParam = {
         [s: string]: string;
     } | (() => Headers) | (() => Promise<Headers>);
     fetch?: any;
-    normalization?: boolean;
     subscriptions?: boolean;
     uri?: string;
-    cache?: boolean;
     onError?: (err: Error) => any;
     retries?: number;
     auditUserId?: string;

package/package.json

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

package/src/create-client.ts

@@ -1,4 +1,3 @@
-import { createSubscriptionsClient } from '@gqty/subscriptions';
 // import fetch from 'cross-fetch';
 import {
   Cache,
@@ -6,6 +5,7 @@ import {
   createClient,
   defaultResponseHandler,
 } from 'gqty';
+import { createClient as createSubscriptionsClient } from 'graphql-ws';
 import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
 import {
   type GeneratedSchema,
@@ -14,8 +14,6 @@ import {
 } from './gqty';
 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;
@@ -72,12 +70,12 @@ export function useHasuraClientInner(args?: Omit<GqlAuthParam, 'retries'>) {
     args?.subscriptions === true
       ? createSubscriptionsClient({
           lazy: true,
-          connectionInitPayload: async () => ({
+          connectionParams: async () => ({
             headers: await getHeaders({
               [hasuraQueryTypeHeader]: 'subscription',
             }),
           }),
-          wsEndpoint() {
+          url() {
             const wsUrl = new URL(uri);
             wsUrl.protocol = wsUrl.protocol
               .replace('https', 'wss')

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;

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

@@ -1,11 +0,0 @@
-import { type GQtyClient, type SubscriptionsClient } from 'gqty';
-import { type GeneratedSchema } from './gqty';
-import type { GqlAuthParam } from './types';
-export type GqlClientV2 = ReturnType<typeof createClientV2>;
-export declare function createClientV2(graphqlUri: string, args?: GqlAuthParam): {
-    client: GQtyClient<GeneratedSchema>;
-    subscriptionsClient: SubscriptionsClient;
-    mutate<T = unknown>(resolved: (sub: import("./gqty").Mutation) => T, options?: import("./wrap").ResolveOptionsWithSession<T>): Promise<T>;
-    query<T_1 = unknown>(resolved: (sub: import("./gqty").Query) => T_1, options?: import("./wrap").ResolveOptionsWithSession<T_1>): Promise<T_1>;
-    subscribe<T_2 = unknown>(resolved: (sub: import("./gqty").Subscription) => T_2, onData: (data: T_2, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
-};

package/build/main/create-client-v2.js

@@ -1,79 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClientV2 = void 0;
-const subscriptions_1 = require("@gqty/subscriptions");
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
-const gqty_1 = require("gqty");
-const gqty_2 = require("./gqty");
-const wrap_1 = require("./wrap");
-function createClientV2(graphqlUri, args) {
-    const $headers = args && 'headers' in args ? args.headers : undefined;
-    const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || cross_fetch_1.default;
-    const getHeaders = $headers && typeof $headers === 'function'
-        ? () => Promise.resolve($headers())
-        : async () => {
-            const headers = $headers || {};
-            if (args && 'secret' in args) {
-                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}`;
-            }
-            return headers;
-        };
-    const queryFetcher = async (query, variables, fetchOptions) => {
-        const headers = await getHeaders();
-        if (fetchOptions?.headers) {
-            for (const key in fetchOptions.headers) {
-                headers[key] = fetchOptions.headers[key];
-            }
-        }
-        const response = await $fetch(graphqlUri, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-            body: JSON.stringify({
-                query,
-                variables,
-            }),
-        });
-        const json = await response.json();
-        return json;
-    };
-    const subscriptionsClient = (() => {
-        if (args?.subscriptions === false)
-            return;
-        const wsUrl = new URL(graphqlUri);
-        wsUrl.protocol = wsUrl.protocol
-            .replace('https', 'wss')
-            .replace('http', 'ws');
-        const subscriptionsClient = (0, subscriptions_1.createSubscriptionsClient)({
-            wsEndpoint: wsUrl.href,
-            connectionInitPayload: async () => ({ headers: await getHeaders() }),
-        });
-        return subscriptionsClient;
-    })();
-    const client = (0, gqty_1.createClient)({
-        schema: gqty_2.generatedSchema,
-        scalarsEnumsHash: gqty_2.scalarsEnumsHash,
-        queryFetcher,
-        subscriptionsClient,
-        normalization: args?.normalization !== false,
-        defaults: {
-            resolved: {
-                noCache: args?.cache ? false : true,
-                retry: false,
-            },
-        },
-        ...args,
-    });
-    return (0, wrap_1.wrapGraphQLClient)(client, subscriptionsClient, args?.onError);
-}
-exports.createClientV2 = createClientV2;

package/build/main/dotenv.d.ts

@@ -1 +0,0 @@
-export declare const env: import("dotenv").DotenvParseOutput;

package/build/main/dotenv.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.env = void 0;
-const node_path_1 = require("node:path");
-const dotenv_1 = require("dotenv");
-exports.env = (0, dotenv_1.config)({ path: (0, node_path_1.join)(__dirname, '.env') }).parsed || {};

package/build/main/src/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const hasuraGraphqlUri = "https://finalytic.hasura.app/v1/graphql";
-export declare const hasuraQueryTypeHeader = "x-hasura-query-type";

package/build/main/src/constants.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasuraQueryTypeHeader = exports.hasuraGraphqlUri = void 0;
-exports.hasuraGraphqlUri = 'https://finalytic.hasura.app/v1/graphql'; // 'https://hasura.vrplatform.app/v1/graphql';
-exports.hasuraQueryTypeHeader = 'x-hasura-query-type';

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

@@ -1,7 +0,0 @@
-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("gqty").LegacySubscriptionsClient;
-    client: import("gqty").GQtyClient<GeneratedSchema>;
-};