@vrplatform/graphql 1.0.0-staging.0

package/build/module/index.d.ts

@@ -0,0 +1,5 @@
+export { GQtyClient, GQtyError, ResolveOptions, SubscriptionsClient, } from 'gqty';
+export { type HasuraClient, useHasuraClient } from './client';
+export * from './common';
+export * from './gqty';
+export { type ResolveOptionsWithSession, wrapGraphQLClient } from './wrap';

package/build/module/index.js

@@ -0,0 +1,5 @@
+export { GQtyError, } from 'gqty';
+export { useHasuraClient } from './client';
+export * from './common';
+export * from './gqty';
+export { wrapGraphQLClient } from './wrap';

package/build/module/tsconfig.esm.tsbuildinfo

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

@@ -0,0 +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?: AllowedHeaders;
+    subscriptions?: boolean;
+    uri?: string;
+    auditUserId?: string;
+    credentials?: RequestCredentials;
+};

package/build/module/types.js

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

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

@@ -0,0 +1,57 @@
+{
+  "name": "@vrplatform/graphql",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build/main",
+    "build/module",
+    "src",
+    "!**/*.spec.*",
+    "LICENSE"
+  ],
+  "version": "1.0.0-staging.0",
+  "description": "Finalytic graphql",
+  "main": "build/main/index.js",
+  "module": "build/module/index.js",
+  "typings": "build/module/index.d.ts",
+  "repository": "https://github.com/vrplatform/graphql",
+  "license": "UNLICENSED",
+  "keywords": [],
+  "dependencies": {
+    "@finalytic/utils": "^4.9.73",
+    "@gqty/subscriptions": "^2.0.1-alpha-00594c5.0",
+    "gqty": "2.3.0",
+    "graphql": "^16.11.0"
+  },
+  "devDependencies": {
+    "@gqty/cli": "^3.3.0-alpha-d8cdbf6.0"
+  },
+  "scripts": {
+    "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-staging": "bun pub:pre && pnpm publish --no-git-checks --tag staging",
+    "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",
+    "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;
+};

package/src/common/tenant.ts

@@ -0,0 +1,101 @@
+import { utc } from '@finalytic/utils';
+import { HasuraError } from '../error';
+import type { tenant_bool_exp } from '../gqty';
+
+// Tenants
+export const VRP_TENANT_ID = '7bfec41f-aa3f-4602-95d2-f7996e4f0e59';
+export const DEMO_TEST_PARTNER_TENANT_ID =
+  '0b6a7bd6-56cc-46b5-b2ab-1bd7d1e994fa';
+export const XIMPLIFI_TENANT_ID = 'd6ab2bbe-e0fc-48d9-89a3-c3c05f4e79b5';
+
+export function whereTenantActive(where?: tenant_bool_exp) {
+  const statusWhere: tenant_bool_exp = {
+    calculatedStatus: { _eq: 'active' },
+    _or: [
+      {
+        calculatedBillingPartner: { calculatedStatus: { _eq: 'active' } },
+      },
+      {
+        calculatedBillingPartnerId: { _is_null: true },
+      },
+    ],
+  };
+
+  if (where) return { _and: [statusWhere, where] };
+
+  return statusWhere;
+}
+
+export function assertTenantActive(tenant: {
+  calculatedStatus?: string;
+  calculatedBillingPartner?: { calculatedStatus?: string };
+}) {
+  if (
+    tenant.calculatedStatus !== 'active' ||
+    tenant.calculatedBillingPartner?.calculatedStatus !== 'active'
+  )
+    throw new HasuraError('Tenant or billing partner are not active');
+}
+
+export function mapTenantStatus(tenant: {
+  calculatedStatus?: string;
+  calculatedBillingPartner?: { calculatedStatus?: string };
+}): 'active' | 'inactive' {
+  const status = tenant.calculatedStatus === 'active';
+  const partnerStatus = tenant.calculatedBillingPartner?.calculatedStatus;
+
+  return status && partnerStatus === 'active' ? 'active' : 'inactive';
+}
+
+export function whereTenantNotTestTeam(where?: tenant_bool_exp) {
+  const statusWhere: tenant_bool_exp = {
+    id: { _nin: [VRP_TENANT_ID, DEMO_TEST_PARTNER_TENANT_ID] },
+    partnerId: {
+      _neq: DEMO_TEST_PARTNER_TENANT_ID,
+    },
+    _or: [
+      { billingPartnerId: { _neq: DEMO_TEST_PARTNER_TENANT_ID } },
+      { billingPartnerId: { _is_null: true } },
+    ],
+  };
+
+  if (where) return { _and: [statusWhere, where] };
+
+  return statusWhere;
+}
+
+export function whereTenantShouldBePaid(
+  where?: tenant_bool_exp,
+  includePartnerTeams = false
+) {
+  let statusWhere: tenant_bool_exp = {
+    isOnboarding: {
+      _eq: false, // has left onboarding
+    },
+    // tenant has no trial or trial ended
+    _or: [
+      {
+        trialUntil: {
+          _lt: utc().yyyymmdd(),
+        },
+      },
+      {
+        trialUntil: {
+          _is_null: true,
+        },
+      },
+    ],
+  };
+
+  if (!includePartnerTeams)
+    statusWhere = {
+      ...statusWhere,
+      calculatedIsBillable: {
+        _eq: true, // no partner teams
+      },
+    };
+
+  if (where) statusWhere = { _and: [statusWhere, where] };
+
+  return whereTenantActive(statusWhere);
+}

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/error.ts

@@ -0,0 +1 @@
+export class HasuraError extends Error {}