@vrplatform/graphql 1.0.0

package/LICENSE

@@ -0,0 +1,3 @@
+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/constants.d.ts

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

package/build/main/constants.js

@@ -0,0 +1,5 @@
+"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/create-client-v2.d.ts

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

@@ -0,0 +1,79 @@
+"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/create-client.d.ts

@@ -0,0 +1,11 @@
+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>;
+};

package/build/main/create-client.js

@@ -0,0 +1,122 @@
+"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"));
+const gqty_1 = require("gqty");
+const constants_1 = require("./constants");
+const gqty_2 = require("./gqty");
+const wrap_1 = require("./wrap");
+function useHasuraClient(args) {
+    const $headers = args && 'headers' in args ? args.headers : undefined;
+    const $fetch = (args && 'fetch' in args ? args.fetch : undefined) || cross_fetch_1.default;
+    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 (0, cross_fetch_1.default)('https://finalytic.hasura.app/v1/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                query,
+                variables,
+                operationName,
+            }),
+            mode: 'cors',
+            ...fetchOptions,
+        });
+        const json = await response.json();
+        return await (0, gqty_1.defaultResponseHandler)(json);
+    };
+    const subscriptionsClient = args?.subscriptions === true
+        ? (0, subscriptions_1.createSubscriptionsClient)({
+            lazy: true,
+            connectionInitPayload: async () => ({
+                headers: await getHeaders({
+                    [constants_1.hasuraQueryTypeHeader]: 'subscription',
+                }),
+            }),
+            wsEndpoint() {
+                const wsUrl = new URL(uri);
+                wsUrl.protocol = wsUrl.protocol
+                    .replace('https', 'wss')
+                    .replace('http', 'ws');
+                return wsUrl.href;
+            },
+            /*url: () => {
+            },*/
+        })
+        : 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,
+    });
+    const client = (0, gqty_1.createClient)({
+        schema: gqty_2.generatedSchema,
+        scalars: gqty_2.scalarsEnumsHash,
+        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 (0, wrap_1.wrapGraphQLClient)(client, subscriptionsClient, args?.onError, args?.retries);
+}

package/build/main/dotenv.d.ts

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

package/build/main/dotenv.js

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

@@ -0,0 +1 @@
+export * from './schema.generated';

package/build/main/gqty/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./schema.generated"), exports);