conductor-node 9.8.1 → 10.0.0

package/README.md

@@ -16,7 +16,7 @@ Execute _any_ read or write [QuickBooks Desktop API](https://developer.intuit.co
 
 ## Requirements
 
-1. A Conductor API key from Danny.
+1. A Conductor API key.
 2. A running version of QuickBooks Desktop connected to Conductor. See our [guide to connecting QuickBooks Desktop to Conductor](https://conductor-io.notion.site/QuickBooks-Desktop-integration-setup-86f6325f747d4447b95d27b59ad89ef5).
 
 ## Installation
@@ -34,7 +34,7 @@ import Conductor from "conductor-node";
 const conductor = new Conductor("sk_test_...");
 
 // Fetch all authorized integration-connections.
-const qbdConnections = await conductor.getIntegrationConnections();
+const qbdConnections = await conductor.integrationConnection.list();
 
 // Execute any QBD API against your QBD connection id.
 const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
@@ -46,12 +46,20 @@ const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
 
 ## APIs
 
-### `createIntegrationConnection(input: CreateIntegrationConnectionInput)`
+### `integrationConnections.list()`
+
+Returns a of list all integration-connections associated with your Conductor account.
+
+```ts
+const qbdConnections = await conductor.integrationConnections.list();
+```
+
+### `integrationConnections.create(input: CreateIntegrationConnectionInput)`
 
 Creates a new integration-connection.
 
 ```ts
-const newQbdConnection = await conductor.createIntegrationConnection({
+const newQbdConnection = await conductor.integrationConnections.create({
   // The identifier of the third-party platform to integrate.
   integrationKey: "quickbooks-desktop",
   // Your end-user's unique ID in your product's database. Must be
@@ -79,45 +87,27 @@ The response looks like the following:
 }
 ```
 
-### `qbd.*`
-
-Executes any QuickBooks Desktop (QBD) API against a specific integration-connection id. See the official [QuickBooks Desktop API Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop) for a complete list of available APIs.
-
-```ts
-const newAccount = await conductor.qbd.account.add(qbdConnectionId, {
-  Name: "Test Account",
-  AccountType: "Bank",
-  OpenBalance: "100",
-});
-```
-
-### `getIntegrationConnections()`
-
-Fetches all authorized integration-connections.
-
-```ts
-const qbdConnections = await conductor.getIntegrationConnections();
-```
-
-### `getIntegrationConnection(id: string)`
+### `integrationConnections.retrieve(id: string)`
 
-Fetches a single integration-connection by id.
+Retrieves the specified integration-connection.
 
 ```ts
-const qbdConnection = await conductor.getIntegrationConnection(qbdConnectionId);
+const qbdConnection = await conductor.integrationConnections.retrieve(
+  qbdConnectionId
+);
 ```
 
-### `pingIntegrationConnection(id: string)`
+### `integrationConnections.ping(id: string)`
 
 Checks whether the specified integration-connection can connect and process requests end-to-end.
 
-If the connection fails, the error we encountered will be thrown as a [`ConductorError`](#error-handling). This information is useful for showing a "connection status" indicator in your app. If an error occurs, we recommend displaying the property `error.endUserMessage` to your end-user in your app's UI.
+If the connection fails, the error we encountered will be thrown as a [`ConductorError`](#error-handling) (like any request). This information is useful for showing a "connection status" indicator in your app. If an error occurs, we recommend displaying the property `error.endUserMessage` to your end-user in your app's UI.
 
 Using `async`/`await`:
 
 ```ts
 try {
-  await conductor.pingIntegrationConnection(qbdConnectionId);
+  await conductor.integrationConnections.ping(qbdConnectionId);
 } catch (error) {
   if (error instanceof ConductorError) {
     // Update your app's UI to display `error.endUserMessage`.
@@ -129,7 +119,7 @@ try {
 Or in the form of a rejected promise:
 
 ```ts
-conductor.pingIntegrationConnection(qbdConnectionId).catch((error) => {
+conductor.integrationConnections.ping(qbdConnectionId).catch((error) => {
   if (error instanceof ConductorError) {
     // Update your app's UI to display `error.endUserMessage`.
   }
@@ -137,6 +127,18 @@ conductor.pingIntegrationConnection(qbdConnectionId).catch((error) => {
 });
 ```
 
+### `qbd.*`
+
+Executes any QuickBooks Desktop (QBD) API against a specific integration-connection id. See the official [QuickBooks Desktop API Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop) for a complete list of available APIs.
+
+```ts
+const newAccount = await conductor.qbd.account.add(qbdConnectionId, {
+  Name: "Test Account",
+  AccountType: "Bank",
+  OpenBalance: "100",
+});
+```
+
 ## TypeScript
 
 Access the entire QuickBooks Desktop API through TypeScript. The `qbd.*` APIs are fully typed with inline documentation and will autocomplete in your editor.
@@ -162,11 +164,11 @@ All errors thrown by the Conductor API are instances of `ConductorError` or its
 | Property          | Type                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | ----------------- | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `type`            | `string`                | Categorizes the error. See [Error Types](#error-types) below.<br><br>This value is the same as the subclass name. E.g., `"ConductorIntegrationError"` or `"ConductorInvalidRequestError"`.                                                                                                                                                                                                                                                                                                                                                                             |
-| `code`            | `string`                | The unique error code from Conductor, which is useful for adding special handling for specific errors. E.g., `"INTEGRATION_CONNECTION_MISSING"`, `"API_KEY_INVALID"`, or `"QBD_REQUEST_ERROR"`.<br><br>In contrast, `type` is more general and categorizes the error.                                                                                                                                                                                                                                                                                                  |
+| `code`            | `string`                | The unique error code from Conductor, which is useful for adding special handling for specific errors. E.g., `"RESOURCE_MISSING"`, `"API_KEY_INVALID"`, or `"QBD_REQUEST_ERROR"`.<br><br>In contrast, `type` is more general and categorizes the error.                                                                                                                                                                                                                                                                                                                |
+| `httpStatusCode`  | `number` or `undefined` | The HTTP status code of the response that included the error. You probably won't need this.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `message`         | `string`                | The developer-friendly error message for your logs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `endUserMessage`  | `string`                | The end-user-friendly error message to display in your app's UI to your end-users.<br><br>This value exists for _every_ error. E.g., for a QBD connection error, it might recommend the end-user to check that their QuickBooks Desktop is open and that they're logged in. But if a Conductor API key is expired, e.g., this message will just say "An internal server error occurred. Please try again later.".                                                                                                                                                      |
 | `integrationCode` | `string` or `undefined` | The unique error code supplied by the third-party integration for errors returned by the integration (i.e., `ConductorIntegrationError`) or integration connector (i.e., `ConductorIntegrationConnectorError`). This is useful for adding special handling for specific errors from the third-party integration or connector.<br><br>The integration's corresponding error message for this code is in `error.message`.<br><br>The third-party integrations' error codes are not standardized, so you should not rely on this code to be the same across integrations. |
-| `httpStatusCode`  | `number` or `undefined` | The HTTP status code of the response that included the error. You probably won't need this.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
 ### Error Types
 
@@ -224,16 +226,16 @@ conductor.qbd.account
   });
 ```
 
-### Centralized Error Handling
+### Global Error Handling
 
-It is unnecessary to wrap each API call individually, as demonstrated in the examples above. Instead, we suggest implementing a centralized error handler for your server, such as [`app.use((error, ...) => { ... })` in Express](https://expressjs.com/en/guide/error-handling.html#writing-error-handlers) or [`formatError` in Apollo Server](https://apollographql.com/docs/apollo-server/data/errors/#for-client-responses). Within this handler, perform the following actions:
+It is unnecessary to wrap each API call individually, as demonstrated in the examples above. Instead, we suggest implementing a Global error handler for your server, such as [`app.use((error, ...) => { ... })` in Express](https://expressjs.com/en/guide/error-handling.html#writing-error-handlers) or [`formatError` in Apollo Server](https://apollographql.com/docs/apollo-server/data/errors/#for-client-responses). Within this handler, perform the following actions:
 
 1. For any `ConductorError` instance, display the `error.endUserMessage` property to the end-user in your app's UI while logging the complete error object.
 2. For all `ConductorError` instances, transmit the full error object to your error-tracking service (e.g., Sentry):
    - Send a **warning** for instances of `ConductorIntegrationConnectionError`, which are not actionable by you and can only be resolved by the end-user; for example, failure to connect to QuickBooks Desktop on the end-user's computer.
    - Send an **error** for all other `ConductorError` instances, such as an invalid API key.
 
-For example, using an Express error handler:
+For example, using an [Express error handler](https://expressjs.com/en/guide/error-handling.html#writing-error-handlers):
 
 ```ts
 import * as Sentry from "@sentry/node";
@@ -259,7 +261,7 @@ app.use((error, req, res, next) => {
 });
 ```
 
-Or using Apollo Server's error handler:
+Or using [Apollo Server's error handler](https://apollographql.com/docs/apollo-server/data/errors/#for-client-responses):
 
 ```ts
 import { ApolloServer } from "@apollo/server";

package/dist/package.json

@@ -1,8 +1,7 @@
 {
     "name": "conductor-node",
-    "version": "9.8.1",
-    "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
-    "author": "Danny Nemer <hi@DannyNemer.com>",
+    "version": "10.0.0",
+    "description": "Easily integrate the entire QuickBooks Desktop API using fully-typed async TypeScript",
     "license": "MIT",
     "type": "commonjs",
     "main": "dist/src/index.js",
@@ -13,10 +12,9 @@
     ],
     "scripts": {
         "prepack": "yarn --silent tsc && yarn --silent delete-compiled-dev-files && yarn --silent tsc-alias",
-        "delete-compiled-dev-files": "rm -rf `find ./dist -type d -name __tests__` ./dist/src/utils/testing.* ./dist/src/graphql/codegenConfig.*",
+        "delete-compiled-dev-files": "rm -rf `find ./dist -type d -name __tests__` ./dist/src/utils/test/*",
         "postpack": "rm -rf dist",
         "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo",
-        "gen:graphql": "yarn graphql-codegen --config=./src/graphql/codegenConfig.ts",
         "diff": "yarn pack && npm diff --diff=conductor-node@latest --diff=conductor-node-v$(node -p \"require('./package.json').version\").tgz && yarn clean",
         "prepublishOnly": "yarn test",
         "test": "yarn --cwd=../../ test ./packages/client",
@@ -26,25 +24,17 @@
         "node": ">=16"
     },
     "dependencies": {
-        "graphql": "^16.6.0",
-        "graphql-request": "~5.1.0"
+        "axios": "^1.4.0"
     },
     "devDependencies": {
-        "@graphql-codegen/add": "^4.0.1",
-        "@graphql-codegen/cli": "^3.2.1",
-        "@graphql-codegen/typescript-graphql-request": "^4.5.8",
-        "@graphql-codegen/typescript-operations": "^3.0.1",
+        "axios-mock-adapter": "^1.21.4",
         "tsc-alias": "^1.7.0"
     },
     "keywords": [
-        "accounting",
-        "api",
         "conductor",
         "qbd",
         "qbwc",
         "qbxml",
-        "quickbooks desktop",
-        "sdk",
-        "typescript"
+        "quickbooks desktop"
     ]
 }

package/dist/src/Client.d.ts

@@ -1,57 +1,17 @@
-import type { GraphqlCreateIntegrationConnectionInput, GraphqlCreateIntegrationConnectionMutation, GraphqlGetIntegrationConnectionQuery, GraphqlGetIntegrationConnectionQueryVariables, GraphqlGetIntegrationConnectionsQuery, GraphqlPingIntegrationConnectionMutation, GraphqlPingIntegrationConnectionMutationVariables } from "./graphql/__generated__/operationTypes";
 import QbdIntegration from "./integrations/qbd/QbdIntegration";
-import { getServerUrlForEnvironment } from "./utils/misc";
+import IntegrationConnectionsResource from "./resources/IntegrationConnectionsResource";
+import { getServerUrlForEnvironment } from "./utils/http";
 export interface ClientOptions {
-    /** Logs each request and response. */
+    /** Logs each request, response, and error. */
     readonly verbose?: boolean;
     readonly serverEnvironment?: Parameters<typeof getServerUrlForEnvironment>[0];
 }
 export default class Client {
+    readonly integrationConnections: IntegrationConnectionsResource;
     /** QuickBooks Desktop integration. */
     readonly qbd: QbdIntegration;
-    private readonly graphqlClient;
-    private readonly graphqlOperations;
+    private readonly httpClient;
     constructor(apiKey: string, { verbose, serverEnvironment }?: ClientOptions);
-    /**
-     * Fetches all integration-connections associated with your Conductor account.
-     *
-     * @returns The integration-connections.
-     */
-    getIntegrationConnections(): Promise<GraphqlGetIntegrationConnectionsQuery["integrationConnections"]>;
-    /**
-     * Fetches the specified integration-connection.
-     *
-     * @param integrationConnectionId The integration-connection ID.
-     * @returns The integration-connection.
-     */
-    getIntegrationConnection(integrationConnectionId: GraphqlGetIntegrationConnectionQueryVariables["integrationConnectionId"]): Promise<GraphqlGetIntegrationConnectionQuery["integrationConnection"]>;
-    /**
-     * Creates a new integration-connection.
-     *
-     * @param input - The input object to create the integration-connection.
-     * @param input.integrationKey The identifier of the third-party platform to
-     * integrate.
-     * @param input.endUserSourceId Your end-user's unique ID in your product's
-     * database. Must be distinct from your other connections for the same
-     * integration.
-     * @param input.endUserEmail Your end-user's email address for identification
-     * only. No emails will be sent.
-     * @param input.endUserCompanyName Your end-user's company name that will be
-     * shown elsewhere in Conductor.
-     * @returns The newly created integration-connection.
-     */
-    createIntegrationConnection(input: GraphqlCreateIntegrationConnectionInput & {
-        integrationKey: "quickbooks-desktop";
-    }): Promise<GraphqlCreateIntegrationConnectionMutation["createIntegrationConnection"]["integrationConnection"]>;
-    /**
-     * Checks whether the specified integration-connection can connect and process
-     * requests end-to-end.
-     *
-     * If the connection fails, the error we encountered will be thrown as a
-     * `ConductorError`. This information is useful for showing a "connection
-     * status" indicator in your app. If an error occurs, we recommend displaying
-     * the property `error.endUserMessage` to your end-user in your app's UI.
-     */
-    pingIntegrationConnection(integrationConnectionId: GraphqlPingIntegrationConnectionMutationVariables["input"]["integrationConnectionId"]): Promise<GraphqlPingIntegrationConnectionMutation["pingIntegrationConnection"]>;
+    private createHttpClient;
     private createHeaders;
 }

package/dist/src/Client.js

@@ -4,76 +4,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const package_json_1 = __importDefault(require("./../package.json"));
-const operationTypes_1 = require("./graphql/__generated__/operationTypes");
-const graphqlOperationWrapper_1 = require("./graphql/graphqlOperationWrapper");
 const QbdIntegration_1 = __importDefault(require("./integrations/qbd/QbdIntegration"));
-const misc_1 = require("./utils/misc");
-const graphql_request_1 = require("graphql-request");
+const errorHandling_1 = require("./interceptors/errorHandling");
+const logging_1 = require("./interceptors/logging");
+const IntegrationConnectionsResource_1 = __importDefault(require("./resources/IntegrationConnectionsResource"));
+const checkForUpdates_1 = require("./utils/checkForUpdates");
+const http_1 = require("./utils/http");
+const axios_1 = __importDefault(require("axios"));
 class Client {
+    integrationConnections;
     /** QuickBooks Desktop integration. */
     qbd;
-    graphqlClient;
-    graphqlOperations;
+    httpClient;
     constructor(apiKey, { verbose = false, serverEnvironment = "production" } = {}) {
-        (0, misc_1.checkForUpdates)();
-        this.graphqlClient = new graphql_request_1.GraphQLClient(`${(0, misc_1.getServerUrlForEnvironment)(serverEnvironment)}/graphql`, { headers: this.createHeaders(apiKey) });
-        this.graphqlOperations = (0, graphqlOperationWrapper_1.wrapGraphqlOperations)((0, operationTypes_1.getSdk)(this.graphqlClient), verbose);
-        this.qbd = new QbdIntegration_1.default(this.graphqlOperations);
+        (0, checkForUpdates_1.checkForUpdates)();
+        this.httpClient = this.createHttpClient(apiKey, verbose, serverEnvironment);
+        this.integrationConnections = new IntegrationConnectionsResource_1.default(this.httpClient);
+        this.qbd = new QbdIntegration_1.default(this.httpClient);
     }
-    /**
-     * Fetches all integration-connections associated with your Conductor account.
-     *
-     * @returns The integration-connections.
-     */
-    async getIntegrationConnections() {
-        return this.graphqlOperations
-            .getIntegrationConnections()
-            .then((result) => result.integrationConnections);
-    }
-    /**
-     * Fetches the specified integration-connection.
-     *
-     * @param integrationConnectionId The integration-connection ID.
-     * @returns The integration-connection.
-     */
-    async getIntegrationConnection(integrationConnectionId) {
-        return this.graphqlOperations
-            .getIntegrationConnection({ integrationConnectionId })
-            .then((result) => result.integrationConnection);
-    }
-    /**
-     * Creates a new integration-connection.
-     *
-     * @param input - The input object to create the integration-connection.
-     * @param input.integrationKey The identifier of the third-party platform to
-     * integrate.
-     * @param input.endUserSourceId Your end-user's unique ID in your product's
-     * database. Must be distinct from your other connections for the same
-     * integration.
-     * @param input.endUserEmail Your end-user's email address for identification
-     * only. No emails will be sent.
-     * @param input.endUserCompanyName Your end-user's company name that will be
-     * shown elsewhere in Conductor.
-     * @returns The newly created integration-connection.
-     */
-    async createIntegrationConnection(input) {
-        return this.graphqlOperations
-            .createIntegrationConnection({ input })
-            .then((result) => result.createIntegrationConnection.integrationConnection);
-    }
-    /**
-     * Checks whether the specified integration-connection can connect and process
-     * requests end-to-end.
-     *
-     * If the connection fails, the error we encountered will be thrown as a
-     * `ConductorError`. This information is useful for showing a "connection
-     * status" indicator in your app. If an error occurs, we recommend displaying
-     * the property `error.endUserMessage` to your end-user in your app's UI.
-     */
-    async pingIntegrationConnection(integrationConnectionId) {
-        return this.graphqlOperations
-            .pingIntegrationConnection({ input: { integrationConnectionId } })
-            .then((result) => result.pingIntegrationConnection);
+    createHttpClient(apiKey, verbose, serverEnvironment) {
+        const httpClient = axios_1.default.create({
+            baseURL: `${(0, http_1.getServerUrlForEnvironment)(serverEnvironment)}/v1`,
+            headers: this.createHeaders(apiKey),
+            timeout: 0, // No timeout (default).
+        });
+        // Wrap errors in `ConductorError`.
+        (0, errorHandling_1.addErrorHandlingInterceptors)(httpClient);
+        // Must be the last interceptor for error logging to use the wrapped error.
+        (0, logging_1.addLoggingInterceptors)(httpClient, verbose);
+        return httpClient;
     }
     createHeaders(apiKey) {
         return {

package/dist/src/integrations/BaseIntegration.d.ts

@@ -1,8 +1,8 @@
-import type Client from "../Client";
-import type { GraphqlSendIntegrationRequestInput, GraphqlSendIntegrationRequestMutation } from "../graphql/__generated__/operationTypes";
-export default class BaseIntegration {
-    private readonly graphqlOperations;
-    constructor(graphqlOperations: Client["graphqlOperations"]);
+import type { IntegrationConnection } from "../resources/IntegrationConnectionsResource";
+import type { AxiosInstance } from "axios";
+export default abstract class BaseIntegration {
+    protected readonly httpClient: AxiosInstance;
+    constructor(httpClient: AxiosInstance);
     /** Not intended for public use. */
-    protected sendIntegrationRequest(input: GraphqlSendIntegrationRequestInput): Promise<GraphqlSendIntegrationRequestMutation["sendIntegrationRequest"]["response"]>;
+    protected sendRequest(id: IntegrationConnection["id"], payload: Record<string, unknown>): Promise<object>;
 }

package/dist/src/integrations/BaseIntegration.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class BaseIntegration {
-    graphqlOperations;
-    constructor(graphqlOperations) {
-        this.graphqlOperations = graphqlOperations;
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
     }
     /** Not intended for public use. */
-    async sendIntegrationRequest(input) {
-        return this.graphqlOperations
-            .sendIntegrationRequest({ input })
-            .then((result) => result.sendIntegrationRequest.response);
+    async sendRequest(id, payload) {
+        const { data } = await this.httpClient.post(`/integration-connections/${id}/send-request`, payload);
+        return data;
     }
 }
 exports.default = BaseIntegration;

package/dist/src/integrations/qbd/QbdIntegration.js

@@ -2404,10 +2404,7 @@ class QbdIntegration extends BaseIntegration_1.default {
         query: async (integrationConnectionId, params) => this.sendRequestWrapper(integrationConnectionId, { WorkersCompCodeQueryRq: params }, "WorkersCompCodeQueryRs", "WorkersCompCodeRet"),
     };
     async sendRequestWrapper(integrationConnectionId, params, responseWrapperKey, responseBodyKey) {
-        const response = (await this.sendIntegrationRequest({
-            integrationConnectionId,
-            requestObject: params,
-        }));
+        const response = (await this.sendRequest(integrationConnectionId, params));
         const responseBody = response[responseWrapperKey]?.[responseBodyKey];
         if (responseBody === undefined) {
             throw new error_1.ConductorIntegrationError({

package/dist/src/interceptors/errorHandling.d.ts

@@ -0,0 +1,2 @@
+import type { AxiosInstance } from "axios";
+export declare function addErrorHandlingInterceptors(httpClient: AxiosInstance): void;

package/dist/src/interceptors/errorHandling.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addErrorHandlingInterceptors = void 0;
+const error_1 = require("../utils/error");
+const axios_1 = require("axios");
+function addErrorHandlingInterceptors(httpClient) {
+    httpClient.interceptors.response.use((response) => response, (error) => {
+        // The request was made and the server responded with a status code that
+        // falls out of the range of 2xx.
+        if (error.response) {
+            const errorData = error.response.data;
+            if (!(0, error_1.isWellFormedConductorServerError)(errorData)) {
+                throw new error_1.ConductorInternalError({
+                    code: "INVALID_JSON_RESPONSE",
+                    message: "Invalid JSON received from the Conductor API.",
+                    httpStatusCode: error.status ?? axios_1.HttpStatusCode.InternalServerError,
+                });
+            }
+            throw (0, error_1.generateConductorErrorFromType)({
+                ...errorData.error,
+                httpStatusCode: error.response.status,
+            });
+        }
+        if (error.code === axios_1.AxiosError.ECONNABORTED) {
+            let message = "Request aborted due to timeout being reached";
+            if (error.config?.timeout !== undefined) {
+                message += ` (${error.config.timeout}ms)`;
+            }
+            throw new error_1.ConductorConnectionError({
+                code: error.code,
+                message,
+                httpStatusCode: error.status ?? axios_1.HttpStatusCode.RequestTimeout,
+            });
+        }
+        // Either the request was made but no response was received (e.g.,
+        // Conductor API is offline) or an error ocurred when setting up the
+        // request (e.g., no network connection).
+        throw new error_1.ConductorConnectionError({
+            code: error.code ?? "NETWORK_ERROR",
+            message: "An error occurred with our connection to Conductor.",
+            httpStatusCode: error.status,
+        });
+    });
+}
+exports.addErrorHandlingInterceptors = addErrorHandlingInterceptors;

package/dist/src/interceptors/logging.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosInstance, AxiosRequestConfig } from "axios";
+export interface RequestConfigWithStartTime extends AxiosRequestConfig {
+    startTime: number;
+}
+export declare function addLoggingInterceptors(httpClient: AxiosInstance, verbose: boolean): void;
+export declare function getDurationStringFromConfig(config: RequestConfigWithStartTime): string;
+export declare function stringifyForLogs(object: unknown): string;

package/dist/src/interceptors/logging.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyForLogs = exports.getDurationStringFromConfig = exports.addLoggingInterceptors = void 0;
+const node_util_1 = __importDefault(require("node:util"));
+function addLoggingInterceptors(httpClient, verbose) {
+    httpClient.interceptors.request.use((config) => {
+        if (verbose) {
+            config.startTime = Date.now();
+            console.log("Conductor request:", stringifyForLogs(createRequestLogObject(config)));
+        }
+        return config;
+    });
+    httpClient.interceptors.response.use((response) => {
+        if (verbose) {
+            console.log("Conductor response:", stringifyForLogs(createResponseLogObject(response)));
+        }
+        return response;
+    }, (error) => {
+        // Log after the other interceptor wraps the response error in a
+        // `ConductorError`.
+        // NOTE: We cannot include duration because we lack access to
+        // `AxiosError.config` because we already wrapped the error.
+        if (verbose) {
+            console.log("Conductor error:", stringifyForLogs(error));
+        }
+        throw error;
+    });
+}
+exports.addLoggingInterceptors = addLoggingInterceptors;
+function createRequestLogObject(config) {
+    return {
+        method: config.method?.toUpperCase(),
+        endpoint: config.url,
+        body: config.data,
+    };
+}
+function createResponseLogObject(response) {
+    return {
+        duration: getDurationStringFromConfig(response.config),
+        status: response.status,
+        data: response.data,
+        request: createRequestLogObject(response.config),
+    };
+}
+function getDurationStringFromConfig(config) {
+    const duration = Date.now() - config.startTime;
+    return `${Math.round(duration / 10) / 100}s`;
+}
+exports.getDurationStringFromConfig = getDurationStringFromConfig;
+function stringifyForLogs(object) {
+    return node_util_1.default.inspect(object, {
+        depth: 5,
+        // Omit color codes to keep logs clean when sent to a log management
+        // service.
+        colors: false,
+    });
+}
+exports.stringifyForLogs = stringifyForLogs;

package/dist/src/resources/BaseResource.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosInstance } from "axios";
+export default abstract class BaseResource {
+    protected readonly httpClient: AxiosInstance;
+    protected abstract readonly ROUTE: string;
+    constructor(httpClient: AxiosInstance);
+}

package/dist/src/resources/BaseResource.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BaseResource {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+}
+exports.default = BaseResource;

package/dist/src/resources/IntegrationConnectionsResource.d.ts

@@ -0,0 +1,59 @@
+import BaseResource from "../resources/BaseResource";
+export interface IntegrationConnection {
+    id: string;
+    integrationKey: string;
+    endUserSourceId: string;
+    endUserEmail: string;
+    endUserCompanyName: string;
+}
+export type CreateIntegrationConnectionInput = Pick<IntegrationConnection, "endUserCompanyName" | "endUserEmail" | "endUserSourceId" | "integrationKey">;
+export interface PingIntegrationConnectionOutput {
+    duration: number;
+}
+export default class IntegrationConnectionsResource extends BaseResource {
+    protected readonly ROUTE = "/integration-connections";
+    /**
+     * Returns a list of all integration-connections associated with your
+     * Conductor account.
+     *
+     * @returns Your integration-connections.
+     */
+    list(): Promise<IntegrationConnection[]>;
+    /**
+     * Creates a new integration-connection.
+     *
+     * @param input The input object to create the integration-connection.
+     * @param input.integrationKey The identifier of the third-party platform to
+     * integrate (e.g., "quickbooks-desktop").
+     * @param input.endUserSourceId Your end-user's unique ID in your product's
+     * database. Must be distinct from your other connections for the same
+     * integration.
+     * @param input.endUserEmail Your end-user's email address for identification
+     * only. No emails will be sent.
+     * @param input.endUserCompanyName Your end-user's company name that will be
+     * shown elsewhere in Conductor.
+     * @returns The newly created integration-connection.
+     */
+    create(input: CreateIntegrationConnectionInput): Promise<IntegrationConnection>;
+    /**
+     * Retrieves the specified integration-connection.
+     *
+     * @param id The integration-connection ID.
+     * @returns The integration-connection.
+     */
+    retrieve(id: IntegrationConnection["id"]): Promise<IntegrationConnection>;
+    /**
+     * Checks whether the specified integration-connection can connect and process
+     * requests end-to-end.
+     *
+     * If the connection fails, the error we encountered will be thrown as a
+     * `ConductorError` (like any request). This information is useful for showing
+     * a "connection status" indicator in your app. If an error occurs, we
+     * recommend displaying the property `error.endUserMessage` to your end-user
+     * in your app's UI.
+     *
+     * @param id The integration-connection ID.
+     * @returns The ping result with the duration in milliseconds.
+     */
+    ping(id: IntegrationConnection["id"]): Promise<PingIntegrationConnectionOutput>;
+}

package/dist/src/resources/IntegrationConnectionsResource.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseResource_1 = __importDefault(require("../resources/BaseResource"));
+class IntegrationConnectionsResource extends BaseResource_1.default {
+    ROUTE = "/integration-connections";
+    /**
+     * Returns a list of all integration-connections associated with your
+     * Conductor account.
+     *
+     * @returns Your integration-connections.
+     */
+    async list() {
+        const { data } = await this.httpClient.get(this.ROUTE);
+        return data;
+    }
+    /**
+     * Creates a new integration-connection.
+     *
+     * @param input The input object to create the integration-connection.
+     * @param input.integrationKey The identifier of the third-party platform to
+     * integrate (e.g., "quickbooks-desktop").
+     * @param input.endUserSourceId Your end-user's unique ID in your product's
+     * database. Must be distinct from your other connections for the same
+     * integration.
+     * @param input.endUserEmail Your end-user's email address for identification
+     * only. No emails will be sent.
+     * @param input.endUserCompanyName Your end-user's company name that will be
+     * shown elsewhere in Conductor.
+     * @returns The newly created integration-connection.
+     */
+    async create(input) {
+        const { data } = await this.httpClient.post(this.ROUTE, input);
+        return data;
+    }
+    /**
+     * Retrieves the specified integration-connection.
+     *
+     * @param id The integration-connection ID.
+     * @returns The integration-connection.
+     */
+    async retrieve(id) {
+        const { data } = await this.httpClient.get(`${this.ROUTE}/${id}`);
+        return data;
+    }
+    /**
+     * Checks whether the specified integration-connection can connect and process
+     * requests end-to-end.
+     *
+     * If the connection fails, the error we encountered will be thrown as a
+     * `ConductorError` (like any request). This information is useful for showing
+     * a "connection status" indicator in your app. If an error occurs, we
+     * recommend displaying the property `error.endUserMessage` to your end-user
+     * in your app's UI.
+     *
+     * @param id The integration-connection ID.
+     * @returns The ping result with the duration in milliseconds.
+     */
+    async ping(id) {
+        const { data } = await this.httpClient.get(`${this.ROUTE}/${id}/ping`);
+        return data;
+    }
+}
+exports.default = IntegrationConnectionsResource;

package/dist/src/utils/checkForUpdates.d.ts

@@ -0,0 +1 @@
+export declare function checkForUpdates(): void;

package/dist/src/utils/{misc.js → checkForUpdates.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServerUrlForEnvironment = exports.checkForUpdates = void 0;
+exports.checkForUpdates = void 0;
 const package_json_1 = __importDefault(require("../../package.json"));
 const node_child_process_1 = require("node:child_process");
 function checkForUpdates() {
@@ -16,10 +16,3 @@ function checkForUpdates() {
     }
 }
 exports.checkForUpdates = checkForUpdates;
-function getServerUrlForEnvironment(environment) {
-    if (environment === "production") {
-        return "https://api.conductor.is";
-    }
-    return "http://localhost:4000";
-}
-exports.getServerUrlForEnvironment = getServerUrlForEnvironment;

package/dist/src/utils/error.d.ts

@@ -2,23 +2,30 @@ export declare const DEFAULT_END_USER_MESSAGE = "An internal server error occurr
 export interface ConductorErrorOptions {
     readonly type: string;
     readonly code: string;
+    readonly httpStatusCode?: number | undefined;
     readonly message: string;
     readonly endUserMessage?: string;
-    readonly integrationCode?: string;
-    readonly httpStatusCode?: number;
+    readonly integrationCode?: string | undefined;
 }
 /**
- * The raw GraphQL error that Conductor's API returns.
+ * The raw REST error response that Conductor's API returns.
  */
-export interface ConductorGraphqlError {
-    readonly message: string;
-    readonly extensions: Omit<ConductorErrorOptions, "httpStatusCode" | "message">;
+export interface ConductorServerError {
+    readonly error: {
+        readonly type: string;
+        readonly code: string;
+        readonly httpStatusCode: number;
+        readonly message: string;
+        readonly endUserMessage: string;
+        readonly integrationCode?: string;
+    };
 }
+export declare function isWellFormedConductorServerError(error: unknown): error is ConductorServerError;
 /**
  * The base error from which all other more specific Conductor errors derive.
  * Specifically for errors that Conductor's API returned.
  */
-export declare class ConductorError extends Error {
+export declare abstract class ConductorError extends Error {
     /**
      * Categorizes the error.
      *
@@ -28,12 +35,17 @@ export declare class ConductorError extends Error {
     readonly type: string;
     /**
      * The unique error code from Conductor, which is useful for adding special
-     * handling for specific errors. E.g., `"INTEGRATION_CONNECTION_MISSING"`,
+     * handling for specific errors. E.g., `"RESOURCE_MISSING"`,
      * `"API_KEY_INVALID"`, or `"QBD_REQUEST_ERROR"`.
      *
      * In contrast, `type` is more general and categorizes the error.
      */
     readonly code: string;
+    /**
+     * The HTTP status code of the response that included the error. You probably
+     * won't need this.
+     */
+    readonly httpStatusCode: number | undefined;
     /**
      * The developer-friendly error message for your logs.
      */
@@ -63,16 +75,11 @@ export declare class ConductorError extends Error {
      * should not rely on this code to be the same across integrations.
      */
     readonly integrationCode: string | undefined;
-    /**
-     * The HTTP status code of the response that included the error. You probably
-     * won't need this.
-     */
-    readonly httpStatusCode: number | undefined;
     /**
      * The internal representation of `type` for debugging.
      */
     protected readonly rawType: string;
-    protected constructor(options: ConductorErrorOptions);
+    constructor(options: ConductorErrorOptions);
 }
 type ConductorErrorOptionsWithoutType = Omit<ConductorErrorOptions, "type">;
 /**

package/dist/src/utils/error.js

@@ -1,9 +1,19 @@
 "use strict";
 /* eslint-disable max-classes-per-file -- Use one module for all error classes. */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateConductorErrorFromType = exports.ConductorUnknownError = exports.ConductorInternalError = exports.ConductorConnectionError = exports.ConductorAuthenticationError = exports.ConductorInvalidRequestError = exports.ConductorIntegrationConnectionError = exports.ConductorIntegrationError = exports.ConductorError = exports.DEFAULT_END_USER_MESSAGE = void 0;
+exports.generateConductorErrorFromType = exports.ConductorUnknownError = exports.ConductorInternalError = exports.ConductorConnectionError = exports.ConductorAuthenticationError = exports.ConductorInvalidRequestError = exports.ConductorIntegrationConnectionError = exports.ConductorIntegrationError = exports.ConductorError = exports.isWellFormedConductorServerError = exports.DEFAULT_END_USER_MESSAGE = void 0;
 // Matches server-side value.
 exports.DEFAULT_END_USER_MESSAGE = "An internal server error occurred. Please try again later.";
+function isWellFormedConductorServerError(error) {
+    return (error instanceof Object &&
+        typeof error.error === "object" &&
+        typeof error.error.type === "string" &&
+        typeof error.error.code === "string" &&
+        typeof error.error.httpStatusCode === "number" &&
+        typeof error.error.message === "string" &&
+        typeof error.error.endUserMessage === "string");
+}
+exports.isWellFormedConductorServerError = isWellFormedConductorServerError;
 /**
  * The base error from which all other more specific Conductor errors derive.
  * Specifically for errors that Conductor's API returned.
@@ -18,12 +28,17 @@ class ConductorError extends Error {
     type;
     /**
      * The unique error code from Conductor, which is useful for adding special
-     * handling for specific errors. E.g., `"INTEGRATION_CONNECTION_MISSING"`,
+     * handling for specific errors. E.g., `"RESOURCE_MISSING"`,
      * `"API_KEY_INVALID"`, or `"QBD_REQUEST_ERROR"`.
      *
      * In contrast, `type` is more general and categorizes the error.
      */
     code;
+    /**
+     * The HTTP status code of the response that included the error. You probably
+     * won't need this.
+     */
+    httpStatusCode;
     /**
      * The developer-friendly error message for your logs.
      */
@@ -53,11 +68,6 @@ class ConductorError extends Error {
      * should not rely on this code to be the same across integrations.
      */
     integrationCode;
-    /**
-     * The HTTP status code of the response that included the error. You probably
-     * won't need this.
-     */
-    httpStatusCode;
     /**
      * The internal representation of `type` for debugging.
      */
@@ -78,10 +88,10 @@ class ConductorError extends Error {
         this.type = this.constructor.name;
         this.rawType = options.type;
         this.code = options.code;
+        this.httpStatusCode = options.httpStatusCode;
         this.message = options.message;
         this.endUserMessage = options.endUserMessage ?? exports.DEFAULT_END_USER_MESSAGE;
         this.integrationCode = options.integrationCode;
-        this.httpStatusCode = options.httpStatusCode;
     }
 }
 exports.ConductorError = ConductorError;

package/dist/src/utils/{misc.d.ts → http.d.ts}

@@ -1,2 +1 @@
-export declare function checkForUpdates(): void;
 export declare function getServerUrlForEnvironment(environment: "development" | "production" | "test"): string;

package/dist/src/utils/http.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerUrlForEnvironment = void 0;
+function getServerUrlForEnvironment(environment) {
+    if (environment === "production") {
+        return "https://api.conductor.is";
+    }
+    return "http://localhost:4000";
+}
+exports.getServerUrlForEnvironment = getServerUrlForEnvironment;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "conductor-node",
-  "version": "9.8.1",
-  "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
-  "author": "Danny Nemer <hi@DannyNemer.com>",
+  "version": "10.0.0",
+  "description": "Easily integrate the entire QuickBooks Desktop API using fully-typed async TypeScript",
   "license": "MIT",
   "type": "commonjs",
   "main": "dist/src/index.js",
@@ -13,10 +12,9 @@
   ],
   "scripts": {
     "prepack": "yarn --silent tsc && yarn --silent delete-compiled-dev-files && yarn --silent tsc-alias",
-    "delete-compiled-dev-files": "rm -rf `find ./dist -type d -name __tests__` ./dist/src/utils/testing.* ./dist/src/graphql/codegenConfig.*",
+    "delete-compiled-dev-files": "rm -rf `find ./dist -type d -name __tests__` ./dist/src/utils/test/*",
     "postpack": "rm -rf dist",
     "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo",
-    "gen:graphql": "yarn graphql-codegen --config=./src/graphql/codegenConfig.ts",
     "diff": "yarn pack && npm diff --diff=conductor-node@latest --diff=conductor-node-v$(node -p \"require('./package.json').version\").tgz && yarn clean",
     "prepublishOnly": "yarn test",
     "test": "yarn --cwd=../../ test ./packages/client",
@@ -26,25 +24,17 @@
     "node": ">=16"
   },
   "dependencies": {
-    "graphql": "^16.6.0",
-    "graphql-request": "~5.1.0"
+    "axios": "^1.4.0"
   },
   "devDependencies": {
-    "@graphql-codegen/add": "^4.0.1",
-    "@graphql-codegen/cli": "^3.2.1",
-    "@graphql-codegen/typescript-graphql-request": "^4.5.8",
-    "@graphql-codegen/typescript-operations": "^3.0.1",
+    "axios-mock-adapter": "^1.21.4",
     "tsc-alias": "^1.7.0"
   },
   "keywords": [
-    "accounting",
-    "api",
     "conductor",
     "qbd",
     "qbwc",
     "qbxml",
-    "quickbooks desktop",
-    "sdk",
-    "typescript"
+    "quickbooks desktop"
   ]
 }

package/dist/src/graphql/__generated__/operationTypes.d.ts

@@ -1,114 +0,0 @@
-import type { GraphQLClient } from "graphql-request";
-import type * as Dom from "graphql-request/dist/types.dom";
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = Maybe<T>;
-export type Exact<T extends {
-    [key: string]: unknown;
-}> = {
-    [K in keyof T]: T[K];
-};
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]?: Maybe<T[SubKey]>;
-};
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]: Maybe<T[SubKey]>;
-};
-/** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {
-    ID: string;
-    String: string;
-    Boolean: boolean;
-    Int: number;
-    Float: number;
-    DateTime: Date;
-    JSONObject: object;
-};
-export type GraphqlCreateIntegrationConnectionInput = {
-    endUserCompanyName: Scalars["String"];
-    endUserEmail: Scalars["String"];
-    endUserSourceId: Scalars["String"];
-    integrationKey: Scalars["String"];
-};
-export type GraphqlPingIntegrationConnectionInput = {
-    integrationConnectionId: Scalars["ID"];
-};
-export type GraphqlSendIntegrationRequestInput = {
-    integrationConnectionId: Scalars["ID"];
-    requestObject: Scalars["JSONObject"];
-};
-export type GraphqlIntegrationConnectionFragment = {
-    id: string;
-    integrationKey: string;
-    endUserSourceId: string;
-    endUserEmail: string;
-    endUserCompanyName: string;
-};
-export type GraphqlGetIntegrationConnectionQueryVariables = Exact<{
-    integrationConnectionId: Scalars["ID"];
-}>;
-export type GraphqlGetIntegrationConnectionQuery = {
-    integrationConnection: {
-        id: string;
-        integrationKey: string;
-        endUserSourceId: string;
-        endUserEmail: string;
-        endUserCompanyName: string;
-    };
-};
-export type GraphqlGetIntegrationConnectionsQueryVariables = Exact<{
-    [key: string]: never;
-}>;
-export type GraphqlGetIntegrationConnectionsQuery = {
-    integrationConnections: Array<{
-        id: string;
-        integrationKey: string;
-        endUserSourceId: string;
-        endUserEmail: string;
-        endUserCompanyName: string;
-    }>;
-};
-export type GraphqlCreateIntegrationConnectionMutationVariables = Exact<{
-    input: GraphqlCreateIntegrationConnectionInput;
-}>;
-export type GraphqlCreateIntegrationConnectionMutation = {
-    createIntegrationConnection: {
-        integrationConnection: {
-            id: string;
-            integrationKey: string;
-            endUserSourceId: string;
-            endUserEmail: string;
-            endUserCompanyName: string;
-        };
-    };
-};
-export type GraphqlPingIntegrationConnectionMutationVariables = Exact<{
-    input: GraphqlPingIntegrationConnectionInput;
-}>;
-export type GraphqlPingIntegrationConnectionMutation = {
-    pingIntegrationConnection: {
-        duration: number;
-    };
-};
-export type GraphqlSendIntegrationRequestMutationVariables = Exact<{
-    input: GraphqlSendIntegrationRequestInput;
-}>;
-export type GraphqlSendIntegrationRequestMutation = {
-    sendIntegrationRequest: {
-        response: object;
-    };
-};
-export declare const IntegrationConnectionFragmentDoc = "\n    fragment IntegrationConnection on IntegrationConnection {\n  id\n  integrationKey\n  endUserSourceId\n  endUserEmail\n  endUserCompanyName\n}\n    ";
-export declare const GetIntegrationConnectionDocument: string;
-export declare const GetIntegrationConnectionsDocument: string;
-export declare const CreateIntegrationConnectionDocument: string;
-export declare const PingIntegrationConnectionDocument = "\n    mutation pingIntegrationConnection($input: PingIntegrationConnectionInput!) {\n  pingIntegrationConnection(input: $input) {\n    duration\n  }\n}\n    ";
-export declare const SendIntegrationRequestDocument = "\n    mutation sendIntegrationRequest($input: SendIntegrationRequestInput!) {\n  sendIntegrationRequest(input: $input) {\n    response\n  }\n}\n    ";
-export type SdkFunctionWrapper = <T>(action: (requestHeaders?: Record<string, string>) => Promise<T>, operationName: string, operationType?: string) => Promise<T>;
-export declare function getSdk(client: GraphQLClient, withWrapper?: SdkFunctionWrapper): {
-    getIntegrationConnection(variables: GraphqlGetIntegrationConnectionQueryVariables, requestHeaders?: Dom.RequestInit["headers"]): Promise<GraphqlGetIntegrationConnectionQuery>;
-    getIntegrationConnections(variables?: GraphqlGetIntegrationConnectionsQueryVariables, requestHeaders?: Dom.RequestInit["headers"]): Promise<GraphqlGetIntegrationConnectionsQuery>;
-    createIntegrationConnection(variables: GraphqlCreateIntegrationConnectionMutationVariables, requestHeaders?: Dom.RequestInit["headers"]): Promise<GraphqlCreateIntegrationConnectionMutation>;
-    pingIntegrationConnection(variables: GraphqlPingIntegrationConnectionMutationVariables, requestHeaders?: Dom.RequestInit["headers"]): Promise<GraphqlPingIntegrationConnectionMutation>;
-    sendIntegrationRequest(variables: GraphqlSendIntegrationRequestMutationVariables, requestHeaders?: Dom.RequestInit["headers"]): Promise<GraphqlSendIntegrationRequestMutation>;
-};
-export type Sdk = ReturnType<typeof getSdk>;

package/dist/src/graphql/__generated__/operationTypes.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSdk = exports.SendIntegrationRequestDocument = exports.PingIntegrationConnectionDocument = exports.CreateIntegrationConnectionDocument = exports.GetIntegrationConnectionsDocument = exports.GetIntegrationConnectionDocument = exports.IntegrationConnectionFragmentDoc = void 0;
-exports.IntegrationConnectionFragmentDoc = `
-    fragment IntegrationConnection on IntegrationConnection {
-  id
-  integrationKey
-  endUserSourceId
-  endUserEmail
-  endUserCompanyName
-}
-    `;
-exports.GetIntegrationConnectionDocument = `
-    query getIntegrationConnection($integrationConnectionId: ID!) {
-  integrationConnection(id: $integrationConnectionId) {
-    ...IntegrationConnection
-  }
-}
-    ${exports.IntegrationConnectionFragmentDoc}`;
-exports.GetIntegrationConnectionsDocument = `
-    query getIntegrationConnections {
-  integrationConnections {
-    ...IntegrationConnection
-  }
-}
-    ${exports.IntegrationConnectionFragmentDoc}`;
-exports.CreateIntegrationConnectionDocument = `
-    mutation createIntegrationConnection($input: CreateIntegrationConnectionInput!) {
-  createIntegrationConnection(input: $input) {
-    integrationConnection {
-      ...IntegrationConnection
-    }
-  }
-}
-    ${exports.IntegrationConnectionFragmentDoc}`;
-exports.PingIntegrationConnectionDocument = `
-    mutation pingIntegrationConnection($input: PingIntegrationConnectionInput!) {
-  pingIntegrationConnection(input: $input) {
-    duration
-  }
-}
-    `;
-exports.SendIntegrationRequestDocument = `
-    mutation sendIntegrationRequest($input: SendIntegrationRequestInput!) {
-  sendIntegrationRequest(input: $input) {
-    response
-  }
-}
-    `;
-const defaultWrapper = (action, _operationName, _operationType) => action();
-function getSdk(client, withWrapper = defaultWrapper) {
-    return {
-        getIntegrationConnection(variables, requestHeaders) {
-            return withWrapper((wrappedRequestHeaders) => client.request(exports.GetIntegrationConnectionDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "getIntegrationConnection", "query");
-        },
-        getIntegrationConnections(variables, requestHeaders) {
-            return withWrapper((wrappedRequestHeaders) => client.request(exports.GetIntegrationConnectionsDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "getIntegrationConnections", "query");
-        },
-        createIntegrationConnection(variables, requestHeaders) {
-            return withWrapper((wrappedRequestHeaders) => client.request(exports.CreateIntegrationConnectionDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "createIntegrationConnection", "mutation");
-        },
-        pingIntegrationConnection(variables, requestHeaders) {
-            return withWrapper((wrappedRequestHeaders) => client.request(exports.PingIntegrationConnectionDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "pingIntegrationConnection", "mutation");
-        },
-        sendIntegrationRequest(variables, requestHeaders) {
-            return withWrapper((wrappedRequestHeaders) => client.request(exports.SendIntegrationRequestDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "sendIntegrationRequest", "mutation");
-        },
-    };
-}
-exports.getSdk = getSdk;

package/dist/src/graphql/graphqlOperationWrapper.d.ts

@@ -1,8 +0,0 @@
-import type { getSdk } from "../graphql/__generated__/operationTypes";
-import type { ConductorError } from "../utils/error";
-export declare function wrapGraphqlOperations<T extends ReturnType<typeof getSdk>>(graphqlOperations: T, verbose: boolean): T;
-export declare function graphqlOperationWrapper<V extends {
-    [key: string]: unknown;
-}, R>(operationName: string, variables: V | undefined, operation: (variables: V | undefined) => Promise<R>, verbose: boolean): Promise<R>;
-export declare function getDurationString(startTime: number): string;
-export declare function wrapError(error: Error): ConductorError;

package/dist/src/graphql/graphqlOperationWrapper.js

@@ -1,108 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapError = exports.getDurationString = exports.graphqlOperationWrapper = exports.wrapGraphqlOperations = void 0;
-const error_1 = require("../utils/error");
-const graphql_request_1 = require("graphql-request");
-const node_util_1 = __importDefault(require("node:util"));
-function wrapGraphqlOperations(graphqlOperations, verbose) {
-    return Object.fromEntries(Object.entries(graphqlOperations).map(([operationName, operation]) => [
-        operationName,
-        async (variables) => graphqlOperationWrapper(operationName, 
-        // @ts-expect-error -- It is safe to call `operation` with `variables`.
-        variables, operation, verbose),
-    ]));
-}
-exports.wrapGraphqlOperations = wrapGraphqlOperations;
-async function graphqlOperationWrapper(operationName, variables, operation, verbose) {
-    const graphqlInfo = {
-        operationName,
-        input: variables
-            ? Object.keys(variables).length === 1 && "input" in variables
-                ? variables["input"] // Flatten the input if it only has one key called "input".
-                : variables
-            : {},
-    };
-    if (verbose) {
-        console.log(`Conductor request start: ${node_util_1.default.inspect(graphqlInfo, {
-            depth: undefined,
-        })}`);
-    }
-    const startTime = Date.now();
-    try {
-        const result = await operation(variables);
-        if (verbose) {
-            const responseLog = {
-                duration: getDurationString(startTime),
-                ...graphqlInfo,
-            };
-            const responseString = node_util_1.default.inspect(responseLog, { depth: undefined });
-            console.log(`Conductor request complete: ${responseString}`);
-        }
-        return result;
-    }
-    catch (error) {
-        const conductorError = wrapError(error);
-        if (verbose) {
-            const errorLog = {
-                duration: getDurationString(startTime),
-                error: String(conductorError),
-                ...graphqlInfo,
-            };
-            const errorString = node_util_1.default.inspect(errorLog, { depth: undefined });
-            console.log(`Conductor error: ${errorString}`);
-        }
-        throw conductorError;
-    }
-}
-exports.graphqlOperationWrapper = graphqlOperationWrapper;
-function getDurationString(startTime) {
-    const duration = Date.now() - startTime;
-    return `${Math.round(duration / 10) / 100}s`;
-}
-exports.getDurationString = getDurationString;
-function wrapError(error) {
-    if (error instanceof graphql_request_1.ClientError) {
-        const { response } = error;
-        if ([404, 502, 503].includes(response.status)) {
-            return createConnectionError(String(response.status), response.status);
-        }
-        const nestedError = response.errors?.[0];
-        const errorExtensions = nestedError?.extensions;
-        if (errorExtensions) {
-            // Do *not* bother validating if this error is a Conductor error:
-            // 1. We know this is a `ClientError`, so `message` and `httpStatusCode`
-            //    exist.
-            // 2. We know this is a GraphQL error, so `code` likely exists either from
-            //    Conductor or Apollo.
-            // 3. If `type` is absent, then `generateConductorErrorFromType` will
-            //    default to `ConductorUnknownError`.
-            // 4. If `endUserMessage` is absent, then `ConductorError` will use a
-            //    default value.
-            return (0, error_1.generateConductorErrorFromType)({
-                message: nestedError.message,
-                httpStatusCode: response.status,
-                ...errorExtensions,
-            });
-        }
-        // Ideally, we would check for instances of `FetchError` but we don't have
-        // that type available.
-    }
-    else if (error.name === "FetchError") {
-        return createConnectionError(error.message, 502);
-    }
-    return new error_1.ConductorInternalError({
-        code: "INVALID_JSON_RESPONSE",
-        message: "Invalid JSON received from the Conductor API.",
-    });
-}
-exports.wrapError = wrapError;
-function createConnectionError(originalMessage, httpStatusCode) {
-    return new error_1.ConductorConnectionError({
-        code: "SERVER_UNAVAILABLE",
-        message: `Conductor failed to connect to the server: ${originalMessage}. Please alert the Conductor team if this error persists.`,
-        httpStatusCode,
-    });
-}