@vrplatform/graphql 1.0.7 → 1.1.1

package/build/main/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/main/index.js

@@ -14,83 +14,12 @@ 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.GQtyError = exports.useHasuraClientInner = void 0;
-exports.useHasuraClient = useHasuraClient;
-const create_client_1 = require("./create-client");
-var create_client_2 = require("./create-client");
-Object.defineProperty(exports, "useHasuraClientInner", { enumerable: true, get: function () { return create_client_2.useHasuraClientInner; } });
-__exportStar(require("./gqty"), exports);
+exports.wrapGraphQLClient = exports.useHasuraClient = exports.GQtyError = void 0;
 var gqty_1 = require("gqty");
 Object.defineProperty(exports, "GQtyError", { enumerable: true, get: function () { return gqty_1.GQtyError; } });
-function useHasuraClient(args) {
-    const { client, subscriptionsClient } = (0, create_client_1.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, 1000 * tries + 1000));
-                }
-            }
-            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, 1000 * tries + 1000));
-                }
-            }
-            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;
-        },
-    };
-}
+var client_1 = require("./client");
+Object.defineProperty(exports, "useHasuraClient", { enumerable: true, get: function () { return client_1.useHasuraClient; } });
+__exportStar(require("./common"), exports);
+__exportStar(require("./gqty"), exports);
+var wrap_1 = require("./wrap");
+Object.defineProperty(exports, "wrapGraphQLClient", { enumerable: true, get: function () { return wrap_1.wrapGraphQLClient; } });

package/build/main/tsconfig.main.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/main/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/main/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/main/wrap.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGraphQLClient = wrapGraphQLClient;
+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/build/module/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/module/client/headers.js

@@ -0,0 +1,39 @@
+// Create headers factory function
+export 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/module/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/module/client/index.js

@@ -0,0 +1,98 @@
+import { defaultAssertRetryableResponse, formatResponse, useRetryableFetch, } from '@finalytic/utils';
+import { createClient } from 'gqty';
+import { hasuraGraphqlUri, hasuraQueryTypeHeader } from '../constants';
+import { generatedSchema, scalarsEnumsHash, } from '../gqty';
+import { wrapGraphQLClient } from '../wrap';
+import { createHeadersFactory } from './headers';
+import { createHasuraSubscriptionsClient } from './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));
+}
+export const defaultAssertHasuraRetryableResponse = 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 } = {}) {
+    const getHeaders = createHeadersFactory({
+        accessToken,
+        auditUserId,
+        headers,
+        secret,
+    });
+    // Create the subscriptions client if needed
+    const subscriptionsClient = createHasuraSubscriptionsClient(uri, getHeaders, subscriptions !== false);
+    const fetchFn = retryableFetchArgs.fetch || fetch;
+    const attempts = retryableFetchArgs.attempts === undefined ? 3 : retryableFetchArgs.attempts;
+    const retryableFetch = attempts > 1
+        ? useRetryableFetch({
+            assertResponse: defaultAssertHasuraRetryableResponse,
+            ...retryableFetchArgs,
+            attempts,
+        })
+        : undefined;
+    // Create the GQty client
+    const client = () => createClient({
+        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/build/module/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/module/client/subscription.js

@@ -0,0 +1,26 @@
+import { createSubscriptionsClient } from '@gqty/subscriptions';
+import { hasuraQueryTypeHeader } from '../constants';
+// Create subscriptions client
+export 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 createSubscriptionsClient({
+            wsEndpoint: wsUrl.href,
+            connectionInitPayload: async () => ({
+                headers: await getHeaders({ [hasuraQueryTypeHeader]: 'subscription' }),
+            }),
+        });
+    }
+    catch (error) {
+        console.error('Failed to create subscriptions client:', error);
+        return undefined;
+    }
+}

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

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

package/build/module/common/account.js

@@ -0,0 +1,4 @@
+export const defaultAccountOrderBy = [
+    { category: { index: 'asc' } },
+    { title: 'asc' },
+];

package/build/module/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/module/common/address.js

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

package/build/module/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/module/common/bank-record.js

@@ -0,0 +1,4 @@
+export const defaultBankRecordOrderBy = [
+    { date: 'desc' },
+    { uniqueRef: 'desc' },
+];

package/build/module/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/module/common/index.js

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

package/build/module/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/module/common/listings.js

@@ -0,0 +1,93 @@
+import { hasValue, utc } from '@finalytic/utils';
+export function whereListingIsActive() {
+    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, date = 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;
+}
+export const whereGlListingIsInactive = (where, date = 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(hasValue),
+        },
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+};

package/build/module/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/module/common/tenant.js

@@ -0,0 +1,77 @@
+import { utc } from '@finalytic/utils';
+import { HasuraError } from '../error';
+// 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) {
+    const statusWhere = {
+        calculatedStatus: { _eq: 'active' },
+        _or: [
+            {
+                calculatedBillingPartner: { calculatedStatus: { _eq: 'active' } },
+            },
+            {
+                calculatedBillingPartnerId: { _is_null: true },
+            },
+        ],
+    };
+    if (where)
+        return { _and: [statusWhere, where] };
+    return statusWhere;
+}
+export function assertTenantActive(tenant) {
+    if (tenant.calculatedStatus !== 'active' ||
+        tenant.calculatedBillingPartner?.calculatedStatus !== 'active')
+        throw new HasuraError('Tenant or billing partner are not active');
+}
+export function mapTenantStatus(tenant) {
+    const status = tenant.calculatedStatus === 'active';
+    const partnerStatus = tenant.calculatedBillingPartner?.calculatedStatus;
+    return status && partnerStatus === 'active' ? 'active' : 'inactive';
+}
+export function whereTenantNotTestTeam(where) {
+    const statusWhere = {
+        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, includePartnerTeams = false) {
+    let statusWhere = {
+        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/build/module/error.d.ts

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

package/build/module/error.js

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

package/build/module/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';