@vrplatform/graphql 1.0.0

package/build/module/src/index.d.ts

@@ -0,0 +1,14 @@
+export { type HasuraClient, 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 declare function useHasuraClient(args?: GqlAuthParam): {
+    client: import("gqty").GQtyClient<import("./gqty").GeneratedSchema>;
+    subscriptionsClient: import("gqty").LegacySubscriptionsClient;
+    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/src/index.js

@@ -0,0 +1,73 @@
+import { useHasuraClientInner } from './create-client';
+export { useHasuraClientInner } from './create-client';
+export * 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/src/index.spec.d.ts

@@ -0,0 +1 @@
+import '../dotenv';

package/build/module/src/index.spec.js

@@ -0,0 +1,10 @@
+import '../dotenv';
+import { expect, test } from 'bun:test';
+import { useHasuraClient } from './index';
+test('test', async () => {
+    const client = useHasuraClient({
+        secret: process.env.HASURA_GRAPHQL_ADMIN_SECRET,
+    });
+    const user = await client.query((q) => q.user({ limit: 5 }).map((x) => x.id));
+    expect(user.length).toBeTruthy();
+});

package/build/module/src/types.d.ts

@@ -0,0 +1,16 @@
+export type Headers = {
+    [s: string]: string;
+};
+export type GqlAuthParam = {
+    accessToken?: string;
+    secret?: string;
+    headers?: {
+        [s: string]: string;
+    } | (() => Headers) | (() => Promise<Headers>);
+    fetch?: any;
+    subscriptions?: boolean;
+    uri?: string;
+    onError?: (err: Error) => any;
+    retries?: number;
+    auditUserId?: string;
+};

package/build/module/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/module/tsconfig.esm.tsbuildinfo

@@ -0,0 +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"}

package/build/module/types.d.ts

@@ -0,0 +1,18 @@
+export type Headers = {
+    [s: string]: string;
+};
+export type GqlAuthParam = {
+    accessToken?: string;
+    secret?: string;
+    headers?: {
+        [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/types.js

@@ -0,0 +1 @@
+export {};

package/build/module/wrap.d.ts

@@ -0,0 +1,10 @@
+import type { GQtyClient, LegacyResolveOptions, LegacySubscriptionsClient } from 'gqty';
+import type { GeneratedSchema, Mutation, Query, Subscription } from './gqty';
+export type ResolveOptionsWithSession<T> = LegacyResolveOptions<T>;
+export declare function wrapGraphQLClient(client: GQtyClient<GeneratedSchema>, subscriptionsClient?: LegacySubscriptionsClient, onError?: (err: Error) => any, retries?: number): {
+    client: GQtyClient<GeneratedSchema>;
+    subscriptionsClient: LegacySubscriptionsClient;
+    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/wrap.js

@@ -0,0 +1,67 @@
+export function wrapGraphQLClient(client, subscriptionsClient, onError, 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 (onError)
+                throw 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 (onError)
+                throw 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/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@vrplatform/graphql",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build/main",
+    "build/module",
+    "src",
+    "!**/*.spec.*",
+    "LICENSE"
+  ],
+  "version": "1.0.0",
+  "description": "Finalytic graphql",
+  "main": "build/main/index.js",
+  "module": "build/module/index.js",
+  "typings": "build/module/index.d.ts",
+  "repository": "https://github.com/finalytic/core",
+  "license": "UNLICENSED",
+  "keywords": [],
+  "trustedDependencies": [
+    "@biomejs/biome"
+  ],
+  "overrides": {
+    "graphql": "^16.9.0"
+  },
+  "dependencies": {
+    "@types/bun": "^1.1.13",
+    "concurrently": "^9.1.0",
+    "gqty": "^3.2.1",
+    "graphql": "^16.9.0",
+    "graphql-ws": "^5.16.0",
+    "hasura-camelize": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "22.9.0",
+    "@gqty/cli": "^4.2.0",
+    "dotenv": "^16.4.5",
+    "typescript": "^5.6.3",
+    "@biomejs/biome": "^1.9.4",
+    "npm-run-all": "^4.1.5"
+  },
+  "scripts": {
+    "postinstall": "bun scripts/download-hasura.ts",
+    "lint": "biome check --diagnostic-level=warn .",
+    "lint:fix": "biome check --apply-unsafe --skip-errors .",
+    "pre-push": "bun lint && bun typecheck",
+    "test": "echo \"Error: no test specified\"",
+    "up": "bunx npm-check-updates -i",
+    "pub": "npm run generate && npm run build && pnpm version patch --no-commit-hooks --no-git-tag-version && pnpm publish --no-git-checks",
+    "typecheck": "tsc --noEmit",
+    "build": "run-p build:* && run-p buildcp:*",
+    "build:main": "tsc -b tsconfig.main.json",
+    "build:module": "tsc -b tsconfig.esm.json",
+    "buildcp:copy1": "cp ./src/gqty/schema.generated.d.ts ./build/module/gqty/schema.generated.d.ts",
+    "buildcp:copy2": "cp ./src/gqty/schema.generated.d.ts ./build/main/gqty/schema.generated.d.ts",
+    "console": "bunx hasura console --project ./hasura --envfile ../.env --no-browser",
+    "pull": "bunx hasura metadata pull --project ./hasura --envfile ../.env",
+    "apply": "bunx hasura metadata apply --project ./hasura --envfile ../.env",
+    "pull:eu": "bunx hasura metadata pull --project ./hasura --envfile ../.env --endpoint http://100.106.134.38:8080",
+    "apply:eu": "bunx hasura metadata apply --project ./hasura --envfile ../.env --endpoint http://100.106.134.38:8080",
+    "generate": "gqty generate && sleep 1 && npm run post-generate && npm run post-generate2 && rm src/gqty/index.js",
+    "post-generate": "sed -i '' 's/export type Maybe<T> = T | null/export type Maybe<T> = T/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate2": "sed -i '' 's/InputMaybe<T> = Maybe<T>/InputMaybe<T> = Maybe<T> | null/g' ./src/gqty/schema.generated.d.ts"
+  }
+}

package/src/constants.ts

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

package/src/create-client.ts

@@ -0,0 +1,121 @@
+import { createSubscriptionsClient } from '@gqty/subscriptions';
+// import fetch from 'cross-fetch';
+import { Cache, type QueryFetcher, createClient } from 'gqty';
+import { hasuraGraphqlUri, hasuraQueryTypeHeader } from './constants';
+import {
+  type GeneratedSchema,
+  generatedSchema,
+  scalarsEnumsHash,
+} 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;
+  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 json = await response.json();
+    return json; //await defaultResponseHandler(json);
+  };
+
+  const subscriptionsClient =
+    args?.subscriptions === true
+      ? createSubscriptionsClient({
+          lazy: true,
+          connectionInitPayload: async () => ({
+            headers: await getHeaders({
+              [hasuraQueryTypeHeader]: 'subscription',
+            }),
+          }),
+          wsEndpoint() {
+            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 };
+}

package/src/gqty/index.ts

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