@vrplatform/graphql 1.0.7 → 1.1.1

package/build/module/index.d.ts

@@ -1,15 +1,5 @@
-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 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>;
-};
+export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';

package/build/module/index.js

@@ -1,76 +1,5 @@
-import { useHasuraClientInner } from './create-client';
-export { useHasuraClientInner } from './create-client';
+export { GQtyError, } from 'gqty';
+export { useHasuraClient } from './client';
+export * from './common';
 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);
-                    console.log('RESULT', result);
-                    return result;
-                }
-                catch (error) {
-                    console.log('ERROR', 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;
-            console.log('THROW', 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;
-        },
-    };
-}
+export { wrapGraphQLClient } from './wrap';

package/build/module/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"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"}
+{"root":["../../src/constants.ts","../../src/error.ts","../../src/index.ts","../../src/types.ts","../../src/wrap.ts","../../src/client/headers.ts","../../src/client/index.ts","../../src/client/subscription.ts","../../src/common/account.ts","../../src/common/address.ts","../../src/common/bank-record.ts","../../src/common/index.ts","../../src/common/listings.ts","../../src/common/tenant.ts","../../src/gqty/index.ts","../../src/gqty/schema.generated.d.ts","../../src/gqty/schema.generated.js"],"version":"5.9.2"}

package/build/module/types.d.ts

@@ -1,16 +1,15 @@
 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;
+    headers?: AllowedHeaders;
     subscriptions?: boolean;
     uri?: string;
-    onError?: (err: Error) => any;
-    retries?: number;
     auditUserId?: string;
+    credentials?: RequestCredentials;
 };

package/build/module/wrap.d.ts

@@ -0,0 +1,12 @@
+import type { GQtyClient, ResolveOptions, SubscriptionsClient } from 'gqty';
+import type { GeneratedSchema } from './gqty';
+export type ResolveOptionsWithSession<T> = ResolveOptions<T>;
+type Client = GQtyClient<GeneratedSchema>;
+export declare function wrapGraphQLClient(getClient: () => Client, subscriptionsClient?: SubscriptionsClient): {
+    readonly client: Client;
+    subscriptionsClient: SubscriptionsClient;
+    mutate<T = unknown>(resolved: (sub: Client["mutation"]) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    query<T = unknown>(resolved: (sub: Client["query"]) => T, options?: ResolveOptionsWithSession<T>): Promise<T>;
+    subscribe<T = unknown>(resolved: (sub: Client["subscription"]) => T, onData: (data: T, unsubscribeFn: () => Promise<void>) => void, onError?: (err: Error, unsubscribeFn: () => Promise<void>) => void): () => Promise<void>;
+};
+export {};

package/build/module/wrap.js

@@ -0,0 +1,44 @@
+export function wrapGraphQLClient(getClient, subscriptionsClient) {
+    return {
+        get client() {
+            return getClient();
+        },
+        subscriptionsClient,
+        async mutate(resolved, options) {
+            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(resolved, options) {
+            const client = getClient();
+            const result = await client.resolved(() => resolved(client.query), options);
+            return result;
+        },
+        subscribe(resolved, onData, onError) {
+            if (!subscriptionsClient)
+                throw new Error('Subscriptions not enabled');
+            let unsub;
+            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/package.json

@@ -10,57 +10,47 @@
     "!**/*.spec.*",
     "LICENSE"
   ],
-  "version": "1.0.7",
+  "version": "1.1.1",
   "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",
+  "repository": "https://github.com/vrplatform/graphql",
   "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"
+    "@finalytic/utils": "^4.9.73",
+    "@gqty/subscriptions": "^2.0.1-alpha-00594c5.0",
+    "gqty": "2.3.0",
+    "graphql": "^16.11.0"
   },
   "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"
+    "@gqty/cli": "^3.3.0-alpha-d8cdbf6.0"
   },
   "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",
+    "check": "bun run typecheck && bun run lint",
+    "test": "bun test",
+    "lint": "biome check .",
+    "pub": "bun pub:pre && pnpm version patch --no-commit-hooks --no-git-tag-version && pnpm publish --no-git-checks",
+    "pub:pre": "bun check && npm run generate && npm run build",
     "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"
+    "generate": "gqty generate && sleep 1 && npm run post-generate && rm src/gqty/index.js",
+    "post-generate": "run-s post-generate:*",
+    "post-generate:1": "sed -i '' 's/export type Maybe<T> = T | null/export type Maybe<T> = T/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:2": "sed -i '' 's/InputMaybe<T> = Maybe<T>/InputMaybe<T> = T | null/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:3": "sed -i '' 's/ScalarsEnums extends MakeNullable<Scalars>/ScalarsEnums extends Scalars/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:4": "sed -i '' 's/timestamptz: any;/timestamptz: string;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:5": "sed -i '' 's/timestamp: any;/timestamp: string;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:6": "sed -i '' 's/bigint: any;/bigint: number;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:7": "sed -i '' 's/Float: any;/Float: number;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:8": "sed -i '' 's/float8: any;/float8: number;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:9": "sed -i '' 's/numeric: any;/numeric: number;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:10": "sed -i '' 's/uuid: any;/uuid: string;/g' ./src/gqty/schema.generated.d.ts",
+    "post-generate:11": "sed -i '' 's/date: any;/date: string;/g' ./src/gqty/schema.generated.d.ts"
   }
 }

package/src/client/headers.ts

@@ -0,0 +1,51 @@
+import type { GqlAuthParam, Headers } from '../types';
+
+// Create headers factory function
+export function createHeadersFactory(
+  args?: Pick<
+    GqlAuthParam,
+    'headers' | 'secret' | 'accessToken' | 'auditUserId'
+  >
+) {
+  return async (base?: Headers): Promise<Headers> => {
+    const result: Record<string, string> = {};
+
+    // Add static or function headers
+    if (args?.headers) {
+      if (typeof args.headers === 'function') {
+        const functionResult = await args.headers();
+        for (const key in functionResult) {
+          result[key] = functionResult[key];
+        }
+      } else {
+        for (const key in args.headers) {
+          result[key] = args.headers[key];
+        }
+      }
+    }
+
+    // Add base headers
+    if (base) {
+      for (const key in base) {
+        result[key] = base[key];
+      }
+    }
+
+    // Add auth headers
+    if (args?.secret) {
+      result['x-hasura-admin-secret'] = args.secret;
+    } else if (args?.accessToken) {
+      result.authorization = args.accessToken.startsWith('Bearer ')
+        ? args.accessToken
+        : `Bearer ${args.accessToken}`;
+    }
+
+    if (args?.auditUserId) {
+      result['x-hasura-audit-user-id'] = args.auditUserId;
+    }
+
+    return result;
+  };
+}
+
+export type HeadersFactory = ReturnType<typeof createHeadersFactory>;

package/src/client/index.ts

@@ -0,0 +1,152 @@
+import {
+  defaultAssertRetryableResponse,
+  formatResponse,
+  type RetryableFetchParams,
+  useRetryableFetch,
+} from '@finalytic/utils';
+import { createClient, type GQtyClient } from 'gqty';
+import { hasuraGraphqlUri, hasuraQueryTypeHeader } from '../constants';
+import {
+  type GeneratedSchema,
+  generatedSchema,
+  type SchemaObjectTypes,
+  type SchemaObjectTypesNames,
+  scalarsEnumsHash,
+} from '../gqty';
+import type { GqlAuthParam } from '../types';
+import { wrapGraphQLClient } from '../wrap';
+import { createHeadersFactory } from './headers';
+import { createHasuraSubscriptionsClient } from './subscription';
+
+export type HasuraClient = ReturnType<typeof useHasuraClient>;
+
+const retryablesErrors = [
+  'deadlock detected',
+  'fetch failed',
+  'Unexpected token',
+  'operation exceeded the time limit',
+];
+
+type HasuraError = {
+  errors: {
+    extensions: {
+      internal: {
+        error: {
+          message: string;
+        };
+      };
+    };
+    message: string;
+  }[];
+};
+
+function isRetryableResponse(json: HasuraError) {
+  if (!json || typeof json !== 'object') return null;
+
+  const message = JSON.stringify(json.errors || {});
+
+  if (!message) return null;
+  return retryablesErrors.find((e) => message?.includes(e));
+}
+
+export const defaultAssertHasuraRetryableResponse: RetryableFetchParams['assertResponse'] =
+  async (arg) => {
+    const defaultResponse = await defaultAssertRetryableResponse(arg);
+    if (defaultResponse && 'retryable' in defaultResponse)
+      return defaultResponse;
+
+    const json = await formatResponse(arg.response).catch(() => null);
+    arg.response.json = () => json;
+    const retryableResponse = isRetryableResponse(json);
+    if (retryableResponse) {
+      return {
+        retryable: true,
+        errorMessage: retryableResponse,
+        errorDetails: json,
+      };
+    }
+  };
+
+export function useHasuraClient({
+  uri = hasuraGraphqlUri,
+  secret,
+  auditUserId,
+  accessToken,
+  subscriptions,
+  headers,
+  credentials,
+  ...retryableFetchArgs
+}: GqlAuthParam & RetryableFetchParams = {}) {
+  const getHeaders = createHeadersFactory({
+    accessToken,
+    auditUserId,
+    headers,
+    secret,
+  });
+
+  // Create the subscriptions client if needed
+  const subscriptionsClient = createHasuraSubscriptionsClient(
+    uri,
+    getHeaders,
+    subscriptions !== false
+  );
+
+  const fetchFn: typeof globalThis.fetch =
+    retryableFetchArgs.fetch || (fetch as any);
+  const attempts =
+    retryableFetchArgs.attempts === undefined ? 3 : retryableFetchArgs.attempts;
+  const retryableFetch =
+    attempts > 1
+      ? useRetryableFetch({
+          assertResponse: defaultAssertHasuraRetryableResponse,
+          ...retryableFetchArgs,
+          attempts,
+        })
+      : undefined;
+
+  // Create the GQty client
+  const client: () => GQtyClient<GeneratedSchema> = () =>
+    createClient<GeneratedSchema, SchemaObjectTypesNames, SchemaObjectTypes>({
+      schema: generatedSchema,
+      scalarsEnumsHash,
+      async queryFetcher(query, variables, fetchOptions) {
+        const getRequest = async () => {
+          const headers = await getHeaders({
+            'Content-Type': 'application/json',
+          });
+          if (fetchOptions?.headers) {
+            for (const key in fetchOptions.headers) {
+              headers[key] = fetchOptions.headers[key];
+            }
+          }
+          const isMutation = query.includes('mutation');
+          headers[hasuraQueryTypeHeader] = isMutation ? 'mutation' : 'query';
+          return new Request(uri, {
+            method: 'POST',
+            credentials,
+            headers,
+            body: JSON.stringify({
+              query,
+              variables,
+            }),
+          });
+        };
+        const response = retryableFetch
+          ? await retryableFetch(getRequest)
+          : await fetchFn(await getRequest());
+        const json = await response.json();
+        return json;
+      },
+      subscriptionsClient,
+      normalization: false,
+      defaults: {
+        resolved: {
+          noCache: true,
+          retry: false, // We're handling retries ourselves in queryFetcher
+        },
+      },
+      retry: { maxRetries: 0 },
+    });
+
+  return wrapGraphQLClient(client, subscriptionsClient);
+}

package/src/client/subscription.ts

@@ -0,0 +1,34 @@
+import { createSubscriptionsClient } from '@gqty/subscriptions';
+import type { SubscriptionsClient } from 'gqty';
+import { hasuraQueryTypeHeader } from '../constants';
+import type { Headers } from '../types';
+
+// Create subscriptions client
+export function createHasuraSubscriptionsClient(
+  uri: string,
+  getHeaders: (base?: Headers) => Promise<Headers>,
+  enabled = true
+): SubscriptionsClient | undefined {
+  // Ensure we strictly check for false, not falsy values
+  if (enabled === false) {
+    // We must return undefined here, not a client when disabled
+    return undefined;
+  }
+
+  try {
+    const wsUrl = new URL(uri);
+    wsUrl.protocol = wsUrl.protocol
+      .replace('https', 'wss')
+      .replace('http', 'ws');
+
+    return createSubscriptionsClient({
+      wsEndpoint: wsUrl.href,
+      connectionInitPayload: async () => ({
+        headers: await getHeaders({ [hasuraQueryTypeHeader]: 'subscription' }),
+      }),
+    });
+  } catch (error) {
+    console.error('Failed to create subscriptions client:', error);
+    return undefined;
+  }
+}

package/src/common/account.ts

@@ -0,0 +1,6 @@
+import type { account_order_by } from '../gqty';
+
+export const defaultAccountOrderBy: account_order_by[] = [
+  { category: { index: 'asc' } },
+  { title: 'asc' },
+];

package/src/common/address.ts

@@ -0,0 +1,9 @@
+export type Address = {
+  full: string;
+  line1: string;
+  line2: string | undefined;
+  city: string;
+  postalCode: string;
+  stateCode: string;
+  countryCode: string;
+};

package/src/common/bank-record.ts

@@ -0,0 +1,6 @@
+import type { bankRecord_order_by } from '../gqty';
+
+export const defaultBankRecordOrderBy: bankRecord_order_by[] = [
+  { date: 'desc' },
+  { uniqueRef: 'desc' },
+];

package/src/common/index.ts

@@ -0,0 +1,5 @@
+export * from './account';
+export * from './address';
+export * from './bank-record';
+export * from './listings';
+export * from './tenant';

package/src/common/listings.ts

@@ -0,0 +1,106 @@
+import { hasValue, utc } from '@finalytic/utils';
+import type { listing_bool_exp } from '../gqty';
+
+export function whereListingIsActive(): listing_bool_exp {
+  return {
+    _or: [
+      {
+        // LEGACY teams
+        tenant: {
+          isGeneralLedger: { _eq: false },
+        },
+        calculatedStatus: { _eq: 'active' },
+      },
+      {
+        // GL teams
+        tenant: {
+          isGeneralLedger: { _eq: true },
+        },
+        ...whereGlListingIsActive(undefined, utc().yyyymmdd()),
+      },
+    ],
+  };
+}
+
+export function whereGlListingIsActive(
+  where?: listing_bool_exp,
+  date: string = utc().yyyymmdd()
+): listing_bool_exp {
+  const statusWhere = {
+    _or: [
+      {
+        _not: {
+          ownershipPeriods: {},
+        },
+      },
+      {
+        ownershipPeriods: {
+          setListingInactive: { _eq: false },
+          _or: [
+            {
+              startAt: {
+                _lt: date,
+              },
+              endAt: {
+                _gte: date,
+              },
+            },
+            {
+              startAt: {
+                _lt: date,
+              },
+              endAt: {
+                _is_null: true,
+              },
+            },
+          ],
+        },
+      },
+    ],
+  } satisfies listing_bool_exp;
+
+  if (where) return { _and: [statusWhere, where] };
+
+  return statusWhere;
+}
+
+export const whereGlListingIsInactive = (
+  where?: listing_bool_exp,
+  date: string = utc().yyyymmdd(),
+  includeUpcoming = false
+): listing_bool_exp => {
+  const statusWhere = {
+    ownershipPeriods: {
+      setListingInactive: { _eq: true },
+      _or: [
+        includeUpcoming
+          ? {
+              startAt: {
+                _gte: date,
+              },
+            }
+          : undefined,
+        {
+          startAt: {
+            _lt: date,
+          },
+          endAt: {
+            _gte: date,
+          },
+        },
+        {
+          startAt: {
+            _lt: date,
+          },
+          endAt: {
+            _is_null: true,
+          },
+        },
+      ].filter(hasValue),
+    },
+  } satisfies listing_bool_exp;
+
+  if (where) return { _and: [statusWhere, where] };
+
+  return statusWhere;
+};