@vrplatform/graphql 1.0.8 → 1.1.1

package/build/main/client/headers.d.ts

@@ -0,0 +1,3 @@
+import type { GqlAuthParam, Headers } from '../types';
+export declare function createHeadersFactory(args?: Pick<GqlAuthParam, 'headers' | 'secret' | 'accessToken' | 'auditUserId'>): (base?: Headers) => Promise<Headers>;
+export type HeadersFactory = ReturnType<typeof createHeadersFactory>;

package/build/main/client/headers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHeadersFactory = createHeadersFactory;
+// Create headers factory function
+function createHeadersFactory(args) {
+    return async (base) => {
+        const result = {};
+        // 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;
+    };
+}

package/build/main/client/index.d.ts

@@ -0,0 +1,13 @@
+import { type RetryableFetchParams } from '@finalytic/utils';
+import { type GQtyClient } from 'gqty';
+import { type GeneratedSchema } from '../gqty';
+import type { GqlAuthParam } from '../types';
+export type HasuraClient = ReturnType<typeof useHasuraClient>;
+export declare const defaultAssertHasuraRetryableResponse: RetryableFetchParams['assertResponse'];
+export declare function useHasuraClient({ uri, secret, auditUserId, accessToken, subscriptions, headers, credentials, ...retryableFetchArgs }?: GqlAuthParam & RetryableFetchParams): {
+    readonly client: GQtyClient<GeneratedSchema>;
+    subscriptionsClient: import("gqty").SubscriptionsClient;
+    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/client/index.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAssertHasuraRetryableResponse = void 0;
+exports.useHasuraClient = useHasuraClient;
+const utils_1 = require("@finalytic/utils");
+const gqty_1 = require("gqty");
+const constants_1 = require("../constants");
+const gqty_2 = require("../gqty");
+const wrap_1 = require("../wrap");
+const headers_1 = require("./headers");
+const subscription_1 = require("./subscription");
+const retryablesErrors = [
+    'deadlock detected',
+    'fetch failed',
+    'Unexpected token',
+    'operation exceeded the time limit',
+];
+function isRetryableResponse(json) {
+    if (!json || typeof json !== 'object')
+        return null;
+    const message = JSON.stringify(json.errors || {});
+    if (!message)
+        return null;
+    return retryablesErrors.find((e) => message?.includes(e));
+}
+const defaultAssertHasuraRetryableResponse = async (arg) => {
+    const defaultResponse = await (0, utils_1.defaultAssertRetryableResponse)(arg);
+    if (defaultResponse && 'retryable' in defaultResponse)
+        return defaultResponse;
+    const json = await (0, utils_1.formatResponse)(arg.response).catch(() => null);
+    arg.response.json = () => json;
+    const retryableResponse = isRetryableResponse(json);
+    if (retryableResponse) {
+        return {
+            retryable: true,
+            errorMessage: retryableResponse,
+            errorDetails: json,
+        };
+    }
+};
+exports.defaultAssertHasuraRetryableResponse = defaultAssertHasuraRetryableResponse;
+function useHasuraClient({ uri = constants_1.hasuraGraphqlUri, secret, auditUserId, accessToken, subscriptions, headers, credentials, ...retryableFetchArgs } = {}) {
+    const getHeaders = (0, headers_1.createHeadersFactory)({
+        accessToken,
+        auditUserId,
+        headers,
+        secret,
+    });
+    // Create the subscriptions client if needed
+    const subscriptionsClient = (0, subscription_1.createHasuraSubscriptionsClient)(uri, getHeaders, subscriptions !== false);
+    const fetchFn = retryableFetchArgs.fetch || fetch;
+    const attempts = retryableFetchArgs.attempts === undefined ? 3 : retryableFetchArgs.attempts;
+    const retryableFetch = attempts > 1
+        ? (0, utils_1.useRetryableFetch)({
+            assertResponse: exports.defaultAssertHasuraRetryableResponse,
+            ...retryableFetchArgs,
+            attempts,
+        })
+        : undefined;
+    // Create the GQty client
+    const client = () => (0, gqty_1.createClient)({
+        schema: gqty_2.generatedSchema,
+        scalarsEnumsHash: gqty_2.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[constants_1.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 (0, wrap_1.wrapGraphQLClient)(client, subscriptionsClient);
+}

package/build/main/client/subscription.d.ts

@@ -0,0 +1,3 @@
+import type { SubscriptionsClient } from 'gqty';
+import type { Headers } from '../types';
+export declare function createHasuraSubscriptionsClient(uri: string, getHeaders: (base?: Headers) => Promise<Headers>, enabled?: boolean): SubscriptionsClient | undefined;

package/build/main/client/subscription.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHasuraSubscriptionsClient = createHasuraSubscriptionsClient;
+const subscriptions_1 = require("@gqty/subscriptions");
+const constants_1 = require("../constants");
+// Create subscriptions client
+function createHasuraSubscriptionsClient(uri, getHeaders, enabled = true) {
+    // 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 (0, subscriptions_1.createSubscriptionsClient)({
+            wsEndpoint: wsUrl.href,
+            connectionInitPayload: async () => ({
+                headers: await getHeaders({ [constants_1.hasuraQueryTypeHeader]: 'subscription' }),
+            }),
+        });
+    }
+    catch (error) {
+        console.error('Failed to create subscriptions client:', error);
+        return undefined;
+    }
+}

package/build/main/common/account.d.ts

@@ -0,0 +1,2 @@
+import type { account_order_by } from '../gqty';
+export declare const defaultAccountOrderBy: account_order_by[];

package/build/main/common/account.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAccountOrderBy = void 0;
+exports.defaultAccountOrderBy = [
+    { category: { index: 'asc' } },
+    { title: 'asc' },
+];

package/build/main/common/address.d.ts

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

package/build/main/common/address.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/main/common/bank-record.d.ts

@@ -0,0 +1,2 @@
+import type { bankRecord_order_by } from '../gqty';
+export declare const defaultBankRecordOrderBy: bankRecord_order_by[];

package/build/main/common/bank-record.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBankRecordOrderBy = void 0;
+exports.defaultBankRecordOrderBy = [
+    { date: 'desc' },
+    { uniqueRef: 'desc' },
+];

package/build/main/common/index.d.ts

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

package/build/main/common/index.js

@@ -0,0 +1,21 @@
+"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("./account"), exports);
+__exportStar(require("./address"), exports);
+__exportStar(require("./bank-record"), exports);
+__exportStar(require("./listings"), exports);
+__exportStar(require("./tenant"), exports);

package/build/main/common/listings.d.ts

@@ -0,0 +1,4 @@
+import type { listing_bool_exp } from '../gqty';
+export declare function whereListingIsActive(): listing_bool_exp;
+export declare function whereGlListingIsActive(where?: listing_bool_exp, date?: string): listing_bool_exp;
+export declare const whereGlListingIsInactive: (where?: listing_bool_exp, date?: string, includeUpcoming?: boolean) => listing_bool_exp;

package/build/main/common/listings.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereGlListingIsInactive = void 0;
+exports.whereListingIsActive = whereListingIsActive;
+exports.whereGlListingIsActive = whereGlListingIsActive;
+const utils_1 = require("@finalytic/utils");
+function whereListingIsActive() {
+    return {
+        _or: [
+            {
+                // LEGACY teams
+                tenant: {
+                    isGeneralLedger: { _eq: false },
+                },
+                calculatedStatus: { _eq: 'active' },
+            },
+            {
+                // GL teams
+                tenant: {
+                    isGeneralLedger: { _eq: true },
+                },
+                ...whereGlListingIsActive(undefined, (0, utils_1.utc)().yyyymmdd()),
+            },
+        ],
+    };
+}
+function whereGlListingIsActive(where, date = (0, utils_1.utc)().yyyymmdd()) {
+    const statusWhere = {
+        _or: [
+            {
+                _not: {
+                    ownershipPeriods: {},
+                },
+            },
+            {
+                ownershipPeriods: {
+                    setListingInactive: { _eq: false },
+                    _or: [
+                        {
+                            startAt: {
+                                _lt: date,
+                            },
+                            endAt: {
+                                _gte: date,
+                            },
+                        },
+                        {
+                            startAt: {
+                                _lt: date,
+                            },
+                            endAt: {
+                                _is_null: true,
+                            },
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+}
+const whereGlListingIsInactive = (where, date = (0, utils_1.utc)().yyyymmdd(), includeUpcoming = false) => {
+    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(utils_1.hasValue),
+        },
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+};
+exports.whereGlListingIsInactive = whereGlListingIsInactive;

package/build/main/common/tenant.d.ts

@@ -0,0 +1,19 @@
+import type { tenant_bool_exp } from '../gqty';
+export declare const VRP_TENANT_ID = "7bfec41f-aa3f-4602-95d2-f7996e4f0e59";
+export declare const DEMO_TEST_PARTNER_TENANT_ID = "0b6a7bd6-56cc-46b5-b2ab-1bd7d1e994fa";
+export declare const XIMPLIFI_TENANT_ID = "d6ab2bbe-e0fc-48d9-89a3-c3c05f4e79b5";
+export declare function whereTenantActive(where?: tenant_bool_exp): tenant_bool_exp;
+export declare function assertTenantActive(tenant: {
+    calculatedStatus?: string;
+    calculatedBillingPartner?: {
+        calculatedStatus?: string;
+    };
+}): void;
+export declare function mapTenantStatus(tenant: {
+    calculatedStatus?: string;
+    calculatedBillingPartner?: {
+        calculatedStatus?: string;
+    };
+}): 'active' | 'inactive';
+export declare function whereTenantNotTestTeam(where?: tenant_bool_exp): tenant_bool_exp;
+export declare function whereTenantShouldBePaid(where?: tenant_bool_exp, includePartnerTeams?: boolean): tenant_bool_exp;

package/build/main/common/tenant.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XIMPLIFI_TENANT_ID = exports.DEMO_TEST_PARTNER_TENANT_ID = exports.VRP_TENANT_ID = void 0;
+exports.whereTenantActive = whereTenantActive;
+exports.assertTenantActive = assertTenantActive;
+exports.mapTenantStatus = mapTenantStatus;
+exports.whereTenantNotTestTeam = whereTenantNotTestTeam;
+exports.whereTenantShouldBePaid = whereTenantShouldBePaid;
+const utils_1 = require("@finalytic/utils");
+const error_1 = require("../error");
+// Tenants
+exports.VRP_TENANT_ID = '7bfec41f-aa3f-4602-95d2-f7996e4f0e59';
+exports.DEMO_TEST_PARTNER_TENANT_ID = '0b6a7bd6-56cc-46b5-b2ab-1bd7d1e994fa';
+exports.XIMPLIFI_TENANT_ID = 'd6ab2bbe-e0fc-48d9-89a3-c3c05f4e79b5';
+function whereTenantActive(where) {
+    const statusWhere = {
+        calculatedStatus: { _eq: 'active' },
+        _or: [
+            {
+                calculatedBillingPartner: { calculatedStatus: { _eq: 'active' } },
+            },
+            {
+                calculatedBillingPartnerId: { _is_null: true },
+            },
+        ],
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+}
+function assertTenantActive(tenant) {
+    if (tenant.calculatedStatus !== 'active' ||
+        tenant.calculatedBillingPartner?.calculatedStatus !== 'active')
+        throw new error_1.HasuraError('Tenant or billing partner are not active');
+}
+function mapTenantStatus(tenant) {
+    const status = tenant.calculatedStatus === 'active';
+    const partnerStatus = tenant.calculatedBillingPartner?.calculatedStatus;
+    return status && partnerStatus === 'active' ? 'active' : 'inactive';
+}
+function whereTenantNotTestTeam(where) {
+    const statusWhere = {
+        id: { _nin: [exports.VRP_TENANT_ID, exports.DEMO_TEST_PARTNER_TENANT_ID] },
+        partnerId: {
+            _neq: exports.DEMO_TEST_PARTNER_TENANT_ID,
+        },
+        _or: [
+            { billingPartnerId: { _neq: exports.DEMO_TEST_PARTNER_TENANT_ID } },
+            { billingPartnerId: { _is_null: true } },
+        ],
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+}
+function whereTenantShouldBePaid(where, includePartnerTeams = false) {
+    let statusWhere = {
+        isOnboarding: {
+            _eq: false, // has left onboarding
+        },
+        // tenant has no trial or trial ended
+        _or: [
+            {
+                trialUntil: {
+                    _lt: (0, utils_1.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/build/main/error.d.ts

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

package/build/main/error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasuraError = void 0;
+class HasuraError extends Error {
+}
+exports.HasuraError = HasuraError;

package/build/main/gqty/index.d.ts

@@ -1 +1,8 @@
+/**
+ * GQTY: You can safely modify this file and Query Fetcher based on your needs
+ */
+import type { GeneratedSchema } from './schema.generated';
+export declare const client: import("gqty").GQtyClient<GeneratedSchema>;
+declare const query: import("./schema.generated").Query, mutation: import("./schema.generated").Mutation, mutate: import("gqty").Mutate<GeneratedSchema>, subscription: import("./schema.generated").Subscription, resolved: import("gqty").Resolved, refetch: import("gqty").Refetch, track: import("gqty/Helpers/track").Track;
+export { query, mutation, mutate, subscription, resolved, refetch, track };
 export * from './schema.generated';

package/build/main/gqty/index.js

@@ -1,4 +1,7 @@
 "use strict";
+/**
+ * GQTY: You can safely modify this file and Query Fetcher based on your needs
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,4 +17,49 @@ 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.track = exports.refetch = exports.resolved = exports.subscription = exports.mutate = exports.mutation = exports.query = exports.client = void 0;
+const subscriptions_1 = require("@gqty/subscriptions");
+const gqty_1 = require("gqty");
+const schema_generated_1 = require("./schema.generated");
+const queryFetcher = async (query, variables, fetchOptions) => {
+    // Modify "/api/graphql" if needed
+    const response = await fetch('/api/graphql', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            query,
+            variables,
+        }),
+        mode: 'cors',
+        ...fetchOptions,
+    });
+    const json = await response.json();
+    return json;
+};
+const subscriptionsClient = typeof window !== 'undefined'
+    ? (0, subscriptions_1.createSubscriptionsClient)({
+        wsEndpoint: () => {
+            // Modify if needed
+            const url = new URL('/api/graphql', window.location.href);
+            url.protocol = url.protocol.replace('http', 'ws');
+            return url.href;
+        },
+    })
+    : undefined;
+exports.client = (0, gqty_1.createClient)({
+    schema: schema_generated_1.generatedSchema,
+    scalarsEnumsHash: schema_generated_1.scalarsEnumsHash,
+    queryFetcher,
+    subscriptionsClient,
+});
+const { query, mutation, mutate, subscription, resolved, refetch, track } = exports.client;
+exports.query = query;
+exports.mutation = mutation;
+exports.mutate = mutate;
+exports.subscription = subscription;
+exports.resolved = resolved;
+exports.refetch = refetch;
+exports.track = track;
 __exportStar(require("./schema.generated"), exports);