@droz-js/sdk 0.2.2 → 0.2.4

package/README.md

@@ -8,7 +8,7 @@ first before making any sdk calls. The sdk will fail if you don't set up the ten
 ```typescript
 import { DrozSdk } from '@droz-js/sdk';
 
-DrozSdk.forTenant('dev').withAuthentication('Basic', 'username', 'password');
+DrozSdk.forTenant('dev').withAuthorization('Basic', 'username', 'password');
 ```
 
 You can also split the setup in two steps
@@ -20,7 +20,7 @@ import { DrozSdk } from '@droz-js/sdk';
 DrozSdk.forTenant('dev');
 
 // (optional) later when you have the authentication token you can set it and it will automatically be used in the new requests
-DrozSdk.withAuthentication('Basic', 'username', 'password');
+DrozSdk.withAuthorization('Basic', 'username', 'password');
 ```
 
 ## Websocket

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@droz-js/sdk",
   "description": "Droz SDK",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "private": false,
   "exports": {
     ".": "./src/index.js",

package/src/client/config.d.ts

@@ -1,19 +1,29 @@
-declare class DrozSdkConfig {
-    authentication?: string;
-    tenant?: string;
-    private initialized;
-    private instances;
-    setTenant(tenant: string): void;
-    setAuthentication(type?: string, ...values: string[]): void;
-    get(): Promise<this>;
+import { AuthorizationProvider } from './helpers';
+export interface Service {
+    tenantId: string;
+    serviceId: string;
+    type: string;
+    endpoint: string;
+}
+declare class TenantConfig {
+    readonly tenant: string;
+    private readonly services;
+    constructor(tenant: string, instances: Service[]);
     getEndpoint(serviceName: string, type?: 'http' | 'ws'): string;
-    private reset;
-    private initialize;
 }
+/**
+ * The DrozSdk is the entry point for the SDK. It allows to configure the default tenant and authorization provider.
+ */
 export declare class DrozSdk {
-    private static readonly singleton;
+    private static defaultTenant?;
+    private static defaultAuthorizationProvider?;
+    private static readonly tenantConfigs;
     static forTenant(tenant: string): typeof DrozSdk;
-    static withAuthentication(type?: string, ...values: string[]): void;
-    static config(): Promise<DrozSdkConfig>;
+    static withAuthorization(type?: string, ...values: string[]): void;
+    static withAuthorizationProvider(provider: () => Promise<string>): void;
+    static getAuthorization(customProvider?: AuthorizationProvider): Promise<string>;
+    static getTenantConfig(customTenant?: string): Promise<TenantConfig>;
+    private static getOrDiscoverTenantConfig;
+    private static discoverTenantConfig;
 }
 export {};

package/src/client/config.js

@@ -1,39 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DrozSdk = void 0;
-const discoveryEndpoint = 'https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws';
-class DrozSdkConfig {
-    authentication;
+const helpers_1 = require("./helpers");
+class TenantConfig {
     tenant;
-    // internal state
-    initialized = false;
-    instances = [];
-    setTenant(tenant) {
+    services;
+    constructor(tenant, instances) {
         this.tenant = tenant;
-        this.reset();
-    }
-    setAuthentication(type, ...values) {
-        if (!['Bearer', 'Basic'].includes(type)) {
-            throw new Error(`Invalid authentication type ${type}`);
-        }
-        if (values.length && values.every(Boolean)) {
-            if (type == 'Basic')
-                this.authentication = `Basic ${Buffer.from(values.join(':')).toString('base64')}`;
-            if (type == 'Bearer')
-                this.authentication = `Bearer ${values[0]}`;
-        }
-        else {
-            this.authentication = undefined;
-        }
-    }
-    async get() {
-        if (this.initialized)
-            return this;
-        return await this.initialize();
+        this.services = instances;
     }
     getEndpoint(serviceName, type = 'http') {
         const serviceId = serviceName.replace('@droz/', '');
-        const instance = this.instances.find(instance => {
+        const instance = this.services.find(instance => {
             return instance.serviceId == serviceId && instance.type == type;
         });
         if (instance) {
@@ -44,36 +22,59 @@ class DrozSdkConfig {
             }
             return instance.endpoint;
         }
-        throw new Error(`Endpoint for ${serviceId} and type ${type} not found`);
-    }
-    reset() {
-        this.initialized = false;
-        this.instances = [];
-    }
-    async initialize() {
-        this.initialized = true;
-        // fetch instances from discovery service
-        const data = await fetch(`${discoveryEndpoint}/discover/${this.tenant}`);
-        const json = await data.json();
-        this.instances = json.instances ?? [];
-        // validate it's a valid tenant
-        if (this.instances.length === 0) {
-            throw new Error(`Invalid tenant '${this.tenant}', no instances found`);
-        }
-        return this;
+        throw new Error(`Tenant "${this.tenant}" endpoint for service "${serviceId}" and type "${type}" not found`);
     }
 }
+/**
+ * The DrozSdk is the entry point for the SDK. It allows to configure the default tenant and authorization provider.
+ */
 class DrozSdk {
-    static singleton = new DrozSdkConfig();
+    static defaultTenant;
+    static defaultAuthorizationProvider;
+    static tenantConfigs = new Map();
     static forTenant(tenant) {
-        this.singleton.setTenant(tenant);
+        this.defaultTenant = tenant;
+        this.tenantConfigs.delete(tenant);
         return this;
     }
-    static withAuthentication(type, ...values) {
-        this.singleton.setAuthentication(type, ...values);
+    static withAuthorization(type, ...values) {
+        this.defaultAuthorizationProvider = (0, helpers_1.toAuthorizationProvider)(type, ...values);
+    }
+    static withAuthorizationProvider(provider) {
+        this.defaultAuthorizationProvider = provider;
+    }
+    static async getAuthorization(customProvider) {
+        if (customProvider)
+            return await (0, helpers_1.resolveAuthorization)(customProvider);
+        const defaultProvider = this.defaultAuthorizationProvider;
+        if (defaultProvider)
+            return await (0, helpers_1.resolveAuthorization)(defaultProvider);
+    }
+    static async getTenantConfig(customTenant) {
+        if (customTenant)
+            return await this.getOrDiscoverTenantConfig(customTenant);
+        const defaultTenant = this.defaultTenant;
+        return this.getOrDiscoverTenantConfig(defaultTenant);
+    }
+    static async getOrDiscoverTenantConfig(tenant) {
+        if (this.tenantConfigs.has(tenant)) {
+            return this.tenantConfigs.get(tenant);
+        }
+        return await this.discoverTenantConfig(tenant);
     }
-    static async config() {
-        return await this.singleton.get();
+    static async discoverTenantConfig(tenant) {
+        // fetch instances from discovery service
+        const data = await fetch(`${helpers_1.serviceDiscoveryEndpoint}/discover/${tenant}`);
+        const json = await data.json();
+        const instances = json.instances ?? [];
+        // validate it's a valid tenant
+        if (instances.length === 0) {
+            throw new Error(`Invalid tenant '${tenant}', no instances found on service discovery`);
+        }
+        // create tenant config and cache it
+        const config = new TenantConfig(tenant, instances);
+        this.tenantConfigs.set(tenant, config);
+        return config;
     }
 }
 exports.DrozSdk = DrozSdk;

package/src/client/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionResult } from 'graphql';
+export declare const serviceDiscoveryEndpoint = "https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws";
+export type AuthorizationProvider = string | (() => Promise<string>) | (() => string);
+export type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterableIterator<R>;
+export type GetSdk<Sdk> = (requester: Requester<Sdk>) => Sdk;
+export declare function toAuthorizationProvider(type?: string, ...values: string[]): AuthorizationProvider;
+export declare function resolveAuthorization(provider?: AuthorizationProvider): Promise<string>;
+export declare function mapGraphqlResponse<T>(response: ExecutionResult<T> | Error): T;
+export declare function mapAsyncIterableGraphqlResponse<T>(iterable: AsyncIterableIterator<ExecutionResult<T, any>>): AsyncGenerator<Awaited<T>, void, unknown>;

package/src/client/helpers.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsyncIterableGraphqlResponse = exports.mapGraphqlResponse = exports.resolveAuthorization = exports.toAuthorizationProvider = exports.serviceDiscoveryEndpoint = void 0;
+exports.serviceDiscoveryEndpoint = 'https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws';
+function toAuthorizationProvider(type, ...values) {
+    // this means it is unsetting the authorization token
+    if (!type)
+        return undefined;
+    if (!values.every(Boolean))
+        return undefined;
+    if (type == 'Basic') {
+        const base64 = Buffer.from(values.join(':')).toString('base64');
+        return `Basic ${base64}`;
+    }
+    if (type == 'Bearer') {
+        return `Bearer ${values[0]}`;
+    }
+    // TODO to be removed
+    if (type == 'Mock') {
+        return `Mock ${values[0]}`;
+    }
+    throw new Error(`Invalid authentication type '${type}'`);
+}
+exports.toAuthorizationProvider = toAuthorizationProvider;
+async function resolveAuthorization(provider) {
+    if (typeof provider === 'string')
+        return provider;
+    if (typeof provider === 'function')
+        return await provider();
+    return undefined;
+}
+exports.resolveAuthorization = resolveAuthorization;
+function mapGraphqlResponse(response) {
+    if (response) {
+        if (response && 'stack' in response && 'message' in response)
+            throw response;
+        if ('errors' in response)
+            console.error(JSON.stringify(response.errors));
+        if ('data' in response)
+            return response.data;
+    }
+}
+exports.mapGraphqlResponse = mapGraphqlResponse;
+async function* mapAsyncIterableGraphqlResponse(iterable) {
+    for await (const each of iterable) {
+        yield mapGraphqlResponse(each);
+    }
+}
+exports.mapAsyncIterableGraphqlResponse = mapAsyncIterableGraphqlResponse;

package/src/client/http.d.ts

@@ -1,3 +1,6 @@
-type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterableIterator<R>;
-export declare function HttpClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk>) => Sdk): new () => Sdk;
-export {};
+import { AuthorizationProvider, GetSdk } from './helpers';
+export declare function HttpClientBuilder<Sdk>(serviceName: string, getSdk: GetSdk<Sdk>): new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: AuthorizationProvider): void;
+} & Sdk;

package/src/client/http.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientBuilder = void 0;
 const inbatches_1 = require("inbatches");
 const config_1 = require("./config");
-const utils_1 = require("./utils");
+const helpers_1 = require("./helpers");
 // create an empty AsyncIterableIterator
 function emptyAsyncIterator() {
     return {
@@ -28,11 +28,19 @@ function buildRequestInfo(req) {
     const operationNames = Array.isArray(req) ? req.map(r => r.operationName) : [req.operationName];
     return [...new Set(operationNames)].join(',');
 }
-class HttpSdkRequesterBuilder {
+class HttpRequester {
     serviceName;
+    tenant;
+    authorization;
     constructor(serviceName) {
         this.serviceName = serviceName;
     }
+    forTenant(tenant) {
+        this.tenant = tenant;
+    }
+    withAuthorization(authorization) {
+        this.authorization = authorization;
+    }
     build() {
         return this.requester.bind(this);
     }
@@ -42,23 +50,30 @@ class HttpSdkRequesterBuilder {
             return emptyAsyncIterator();
         // extract operation name and enqueue the request to be executed in batches
         const operationName = /(?:query|mutation) ([^({ ]*)/.exec(query)?.[1];
-        return this.inbatches({ query, variables, operationName }).then(utils_1.mapGraphqlResponse);
+        return this.inbatches({ query, variables, operationName }).then(helpers_1.mapGraphqlResponse);
+    }
+    async buildRequest() {
+        const [authorization, tenant] = await Promise.all([
+            config_1.DrozSdk.getAuthorization(this.authorization),
+            config_1.DrozSdk.getTenantConfig(this.tenant)
+        ]);
+        const endpoint = tenant.getEndpoint(this.serviceName);
+        const heads = new Headers();
+        heads.set('Authorization', authorization);
+        heads.set('Content-Type', 'application/json');
+        const headers = Object.fromEntries(heads.entries());
+        return { endpoint, headers };
     }
     async inbatches(request) {
-        const config = await config_1.DrozSdk.config();
-        const endpoint = config.getEndpoint(this.serviceName, 'http');
+        const { endpoint, headers } = await this.buildRequest();
         const body = JSON.stringify(request);
         const args = buildRequestInfo(request);
-        const headers = new Headers();
-        headers.set('Authorization', config.authentication);
-        headers.set('Content-Type', 'application/json');
         // make POST request
         const response = await fetch(`${endpoint}?${args}`, {
             method: 'POST',
-            headers: Object.fromEntries(headers.entries()),
+            headers,
             body
         });
-        // treat the response
         return await response.json();
     }
 }
@@ -67,14 +82,21 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], HttpSdkRequesterBuilder.prototype, "inbatches", null);
+], HttpRequester.prototype, "inbatches", null);
 function HttpClientBuilder(serviceName, getSdk) {
     class Client {
+        http; // cannot type as HttpSdkRequesterBuilder because it is an anonymous class
         constructor() {
-            const http = new HttpSdkRequesterBuilder(serviceName);
-            const sdk = getSdk(http.build());
+            this.http = new HttpRequester(serviceName);
+            const sdk = getSdk(this.http.build());
             Object.assign(this, sdk);
         }
+        forTenant(tenant) {
+            this.http.forTenant(tenant);
+        }
+        withAuthorization(authorization) {
+            this.http.withAuthorization(authorization);
+        }
     }
     return Client;
 }

package/src/client/ws.d.ts

@@ -1,7 +1,5 @@
-import { Client } from 'graphql-ws';
-type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterableIterator<R>;
-type Connect = {
-    connect(): Promise<Client>;
-};
-export declare function WsClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk>) => Sdk): new () => Sdk & Connect;
-export {};
+import { GetSdk } from './helpers';
+export declare function WsClientBuilder<Sdk>(serviceName: string, getSdk: GetSdk<Sdk>): new () => {
+    readonly ws: any;
+    connect(): Promise<any>;
+} & Sdk;

package/src/client/ws.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsClientBuilder = void 0;
 const graphql_ws_1 = require("graphql-ws");
 const config_1 = require("./config");
-const utils_1 = require("./utils");
-class WsSdkRequesterBuilder {
+const helpers_1 = require("./helpers");
+class WsRequester {
     serviceName;
     client;
     constructor(serviceName) {
@@ -13,16 +13,17 @@ class WsSdkRequesterBuilder {
     async connect() {
         if (this.client)
             return this.client;
-        const config = await config_1.DrozSdk.config();
-        const endpoint = config.getEndpoint(this.serviceName, 'ws');
+        const [tenant, authorization] = await Promise.all([
+            config_1.DrozSdk.getTenantConfig(),
+            config_1.DrozSdk.getAuthorization()
+        ]);
+        const endpoint = tenant.getEndpoint(this.serviceName, 'ws');
         this.client = (0, graphql_ws_1.createClient)({
             url: endpoint,
             lazy: true,
             retryAttempts: 128,
             keepAlive: 25000,
-            connectionParams: {
-                authorization: config.authentication
-            }
+            connectionParams: { authorization }
         });
         return this.client;
     }
@@ -37,20 +38,20 @@ class WsSdkRequesterBuilder {
         const iterable = this.client.iterate(operation);
         // subscription
         if (isSubscription) {
-            return (0, utils_1.mapAsyncIterableGraphqlResponse)(iterable);
+            return (0, helpers_1.mapAsyncIterableGraphqlResponse)(iterable);
         }
         // single query or mutation
         return iterable
             .next()
             .then(one => one.value)
-            .then(res => (0, utils_1.mapGraphqlResponse)(res));
+            .then(res => (0, helpers_1.mapGraphqlResponse)(res));
     }
 }
 function WsClientBuilder(serviceName, getSdk) {
     class Client {
-        ws;
+        ws; // cannot type as WsSdkRequester because it is an anonymous class
         constructor() {
-            this.ws = new WsSdkRequesterBuilder(serviceName);
+            this.ws = new WsRequester(serviceName);
             const sdk = getSdk(this.ws.build());
             Object.assign(this, sdk);
         }

package/src/drozbot.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/drozbot';
 export declare const DrozBot: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;

package/src/drozchat-ws.d.ts

@@ -1,5 +1,8 @@
 export * from './sdks/drozchat';
 export declare const DrozChatWs: new () => {
+    readonly ws: any;
+    connect(): Promise<any>;
+} & {
     createCustomer(variables: import("./sdks/drozchat").Exact<{
         input: import("./sdks/drozchat").CreateCustomerInput;
     }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;
@@ -66,6 +69,4 @@ export declare const DrozChatWs: new () => {
     onTicketMessage(variables: import("./sdks/drozchat").Exact<{
         ticketId: string;
     }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketMessageSubscription>;
-} & {
-    connect(): Promise<import("graphql-ws").Client>;
 };

package/src/drozchat.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/drozchat';
 export declare const DrozChat: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     createCustomer(variables: import("./sdks/drozchat").Exact<{
         input: import("./sdks/drozchat").CreateCustomerInput;
     }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;

package/src/droznexo.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/droznexo';
 export declare const DrozNexo: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     createAgent(variables: import("./sdks/droznexo").Exact<{
         input: import("./sdks/droznexo").CreateAgentInput;
     }>, options?: unknown): Promise<import("./sdks/droznexo").CreateAgentMutation>;

package/src/mercadolivre.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/mercadolivre';
 export declare const MercadoLivre: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/mercadolivre").GetMercadoLivreInstanceQuery>;

package/src/nucleus.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/nucleus';
 export declare const Nucleus: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getApp(variables: import("./sdks/nucleus").Exact<{
         appId: string;
         withInstances?: boolean;

package/src/reclameaqui.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/reclameaqui';
 export declare const Reclameaqui: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/reclameaqui").GetReclameAquiInstanceQuery>;

package/src/sdks/drozbot.d.ts

@@ -115,6 +115,7 @@ export type PageInfo = {
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
     getDrozBotInstance?: Maybe<DrozBotInstance>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     listDrozBotInstances: Array<Maybe<DrozBotInstance>>;
     version?: Maybe<Scalars['String']['output']>;
 };
@@ -124,9 +125,6 @@ export type QueryGetDrozBotInstanceArgs = {
 export type RemoveDrozBotInstanceInput = {
     id: Scalars['ID']['input'];
 };
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     DrozBotInstance = "DrozBotInstance",

package/src/sdks/drozchat.d.ts

@@ -171,6 +171,7 @@ export type PageInfo = {
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
     getCustomer?: Maybe<Customer>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getTicket?: Maybe<Ticket>;
     getWsEndpoint?: Maybe<Scalars['String']['output']>;
     listCustomers: CustomersConnection;

package/src/sdks/droznexo.d.ts

@@ -129,6 +129,7 @@ export type PageInfo = {
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
     getAgent?: Maybe<Agent>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getWsEndpoint?: Maybe<Scalars['String']['output']>;
     listAgentGroups: AgentGroupsConnection;
     listAgents: AgentsConnection;

package/src/sdks/mercadolivre.d.ts

@@ -120,6 +120,7 @@ export type PageInfo = {
 };
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getMercadoLivreInstance?: Maybe<MercadoLivreInstance>;
     listMercadoLivreInstances: Array<MercadoLivreInstance>;
     version?: Maybe<Scalars['String']['output']>;
@@ -130,9 +131,6 @@ export type QueryGetMercadoLivreInstanceArgs = {
 export type RemoveMercadoLivreInstanceInput = {
     id: Scalars['ID']['input'];
 };
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     GraphqlConnections = "GraphqlConnections",

package/src/sdks/nucleus.d.ts

@@ -295,6 +295,7 @@ export type Query = {
     getCredentials?: Maybe<SafeCredentials>;
     getCredentialsSecret?: Maybe<Credentials>;
     getCronJob?: Maybe<CronJob>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getSessionData?: Maybe<Scalars['JSON']['output']>;
     getStateMachineConfig?: Maybe<StateMachineConfig>;
     getXStateMachineConfig?: Maybe<Scalars['JSON']['output']>;
@@ -427,9 +428,6 @@ export declare enum StateMachineConfigStatus {
     Live = "Live",
     Published = "Published"
 }
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     App = "App",

package/src/sdks/reclameaqui.d.ts

@@ -108,6 +108,7 @@ export type PageInfo = {
 };
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getReclameAquiInstance?: Maybe<ReclameAquiInstance>;
     listReclameAquiInstances: Array<ReclameAquiInstance>;
     version?: Maybe<Scalars['String']['output']>;
@@ -124,9 +125,6 @@ export type ReclameAquiInstance = {
 export type RemoveReclameAquiInstanceInput = {
     id: Scalars['ID']['input'];
 };
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     GraphqlConnections = "GraphqlConnections",

package/src/sdks/zendesk.d.ts

@@ -113,6 +113,7 @@ export type PageInfo = {
 };
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getZendeskInstance?: Maybe<ZendeskInstance>;
     listZendeskInstances: Array<ZendeskInstance>;
     version?: Maybe<Scalars['String']['output']>;
@@ -123,9 +124,6 @@ export type QueryGetZendeskInstanceArgs = {
 export type RemoveZendeskInstanceInput = {
     id: Scalars['ID']['input'];
 };
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     GraphqlConnections = "GraphqlConnections",

package/src/zendesk.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/zendesk';
 export declare const Zendesk: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getZendeskInstance(variables: import("./sdks/zendesk").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/zendesk").GetZendeskInstanceQuery>;

package/src/client/utils.d.ts

@@ -1,3 +0,0 @@
-import type { ExecutionResult } from 'graphql';
-export declare function mapGraphqlResponse<T>(response: ExecutionResult<T> | Error): T;
-export declare function mapAsyncIterableGraphqlResponse<T>(iterable: AsyncIterableIterator<ExecutionResult<T, any>>): AsyncGenerator<Awaited<T>, void, unknown>;

package/src/client/utils.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapAsyncIterableGraphqlResponse = exports.mapGraphqlResponse = void 0;
-function mapGraphqlResponse(response) {
-    if (response && 'stack' in response && 'message' in response)
-        throw response;
-    if ('errors' in response)
-        console.error(JSON.stringify(response.errors));
-    if ('data' in response)
-        return response.data;
-}
-exports.mapGraphqlResponse = mapGraphqlResponse;
-async function* mapAsyncIterableGraphqlResponse(iterable) {
-    for await (const each of iterable) {
-        yield mapGraphqlResponse(each);
-    }
-}
-exports.mapAsyncIterableGraphqlResponse = mapAsyncIterableGraphqlResponse;