conductor-node 8.2.4 → 8.4.0

package/README.md

@@ -2,8 +2,18 @@
 
 Execute _any_ read or write [QuickBooks Desktop API](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop) through async TypeScript and receive a fully-typed response.
 
+<!-- markdownlint-disable MD033 -->
 <img src="https://user-images.githubusercontent.com/170023/213273732-83dd6881-0b36-4787-820b-bd55cdc8444f.jpg" alt="qbd" width="600"/>
 
+## Table of Contents
+
+1. [Requirements](#requirements)
+2. [Installation](#installation)
+3. [Usage](#usage)
+4. [APIs](#apis)
+5. [TypeScript](#typescript)
+6. [Error Handling](#error-handling)
+
 ## Requirements
 
 1. A Conductor API key from Danny.
@@ -34,7 +44,7 @@ const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
 });
 ```
 
-## `Conductor` APIs
+## APIs
 
 ### `createIntegrationConnection(input: CreateIntegrationConnectionInput)`
 
@@ -100,34 +110,39 @@ const qbdConnection = await conductor.getIntegrationConnectionById(
 );
 ```
 
-### `getConnectionStatus(id: string)`
+### `pingIntegrationConnection(id: string)`
 
-Check whether we can successfully connect to the end-user's QBD instance.
+Check whether the specified integration-connection can connect and process requests end-to-end.
 
-Unlike `lastHeartbeatAt`, which only checks if QBWC is running (i.e., is the user's computer on), this check fails if the user's computer is on but QBD is not running, the wrong company file is open, or there is a modal dialog open in QBD.
+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.
+
+In the form of a rejected promise:
 
 ```ts
-const connectionStatus = await conductor.getConnectionStatus(qbdConnectionId);
+conductor.pingIntegrationConnection(qbdConnectionId).catch((error) => {
+  if (error instanceof ConductorError) {
+    // Update your app's UI to display `error.endUserMessage`.
+  }
+  // ...
+});
 ```
 
-The response includes the following:
+Or using `async`/`await`:
 
 ```ts
-{
-  // Whether we can connect to the end-user's QuickBooks Desktop.
-  isConnected: false,
-  // If `isConnected=false`, an `error` like the following will exist:
-  error: {
-    code: "QBWC_CONNECTION_ERROR",
-    developerMessage: "QBWC Error 0x80040408: Could not start QuickBooks.",
-    endUserMessage: "An error occurred while connecting to QuickBooks Desktop. Please ensure QuickBooks Desktop is running and the correct company file is open, then try again.",
+try {
+  await conductor.pingIntegrationConnection(qbdConnectionId);
+} catch (error) {
+  if (error instanceof ConductorError) {
+    // Update your app's UI to display `error.endUserMessage`.
   }
+  // ...
 }
 ```
 
 ## TypeScript
 
-Access the full QuickBooks Desktop API through TypeScript. The `qbd.*` APIs are fully-typed with inline documentation and will autocomplete in your editor.
+Access the full QuickBooks Desktop API through TypeScript. The `qbd.*` APIs are fully typed with inline documentation and will autocomplete in your editor.
 
 To manually access the QBD types, import them from `conductor-node` like so:
 
@@ -140,3 +155,73 @@ const accountAddInput: QbdTypes.AccountAdd = {
   OpenBalance: "100",
 };
 ```
+
+## Error Handling
+
+The `ConductorError` and its subclasses have the following properties:
+
+```ts
+{
+  // The error type.
+  type: string;
+  // The error code.
+  code: string;
+  // The developer-friendly error message for your logs.
+  message: string;
+  // The end-user-friendly error message to display in your app.
+  endUserMessage: string;
+  // The HTTP status code.
+  statusCode: number | undefined;
+}
+```
+
+### Error Types
+
+The error object you receive will have one of the following error types:
+
+| Type                           | Description                                                                                      |
+| ------------------------------ | ------------------------------------------------------------------------------------------------ |
+| `ConductorIntegrationError`    | An error occurred on the third-party integration's end while processing your end-user's request. |
+| `ConductorInvalidRequestError` | You made an API call with the wrong parameters, in the wrong state, or in an invalid way.        |
+| `ConductorAuthenticationError` | Conductor cannot authenticate you with the credentials you provided. E.g., an incorrect API key. |
+| `ConductorConnectionError`     | There was a network problem between the client (on your server) and Conductor's servers.         |
+| `ConductorInternalError`       | Something went wrong on Conductor's end. (These are rare.)                                       |
+
+### Example
+
+Using `async`/`await`:
+
+```ts
+try {
+  const newAccount = await conductor.qbd.account.add(qbdConnectionId, {
+    Name: "Test Account",
+    AccountType: "Bank",
+    OpenBalance: "100",
+  });
+} catch (error) {
+  if (error instanceof ConductorError) {
+    // Update your app's UI to display `error.endUserMessage`.
+  }
+  // ...
+}
+```
+
+Or in the form of a rejected promise:
+
+```ts
+conductor.qbd.account
+  .add(qbdConnectionId, {
+    Name: "Test Account",
+    AccountType: "Bank",
+    OpenBalance: "100",
+  })
+  .then((newAccount) => {
+    // ...
+  })
+  .catch((error) => {
+    if (error instanceof ConductorError) {
+      // Update your app's UI to display `error.endUserMessage`.
+    }
+    // ...
+  });
+```

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "conductor-node",
-    "version": "8.2.4",
+    "version": "8.4.0",
     "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
     "author": "Danny Nemer <hi@DannyNemer.com>",
     "license": "MIT",

package/dist/src/Client.d.ts

@@ -1,4 +1,4 @@
-import type { GraphqlCreateIntegrationConnectionInput, GraphqlCreateIntegrationConnectionMutation, GraphqlGetConnectionStatusQuery, GraphqlGetConnectionStatusQueryVariables, GraphqlGetIntegrationConnectionQuery, GraphqlGetIntegrationConnectionQueryVariables, GraphqlGetIntegrationConnectionsQuery } from "./graphql/__generated__/operationTypes";
+import type { GraphqlCreateIntegrationConnectionInput, GraphqlCreateIntegrationConnectionMutation, GraphqlGetConnectionStatusQuery, GraphqlGetConnectionStatusQueryVariables, GraphqlGetIntegrationConnectionQuery, GraphqlGetIntegrationConnectionQueryVariables, GraphqlGetIntegrationConnectionsQuery, GraphqlPingIntegrationConnectionMutation, GraphqlPingIntegrationConnectionMutationVariables } from "./graphql/__generated__/operationTypes";
 import QbdIntegration from "./integrations/qbd/QbdIntegration";
 import { getServerUrlForEnvironment } from "./utils";
 export interface ClientOptions {
@@ -62,5 +62,14 @@ export default class Client {
     createIntegrationConnection(input: GraphqlCreateIntegrationConnectionInput & {
         integrationKey: "quickbooks-desktop";
     }): Promise<GraphqlCreateIntegrationConnectionMutation["createIntegrationConnection"]["integrationConnection"]>;
+    /**
+     * Check 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.
+     */
+    pingIntegrationConnection(integrationConnectionId: GraphqlPingIntegrationConnectionMutationVariables["input"]["integrationConnectionId"]): Promise<GraphqlPingIntegrationConnectionMutation["pingIntegrationConnection"]>;
     private createHeaders;
 }

package/dist/src/Client.js

@@ -84,6 +84,19 @@ class Client {
             .createIntegrationConnection({ input })
             .then((result) => result.createIntegrationConnection.integrationConnection);
     }
+    /**
+     * Check 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.
+     */
+    async pingIntegrationConnection(integrationConnectionId) {
+        return this.graphqlOperations
+            .pingIntegrationConnection({ input: { integrationConnectionId } })
+            .then((result) => result.pingIntegrationConnection);
+    }
     createHeaders(apiKey) {
         return {
             Authorization: `Bearer ${apiKey}`,

package/dist/src/error.d.ts

@@ -1,18 +1,57 @@
-export declare const DEFAULT_ERROR_CODE = "CONDUCTOR__INTERNAL_SERVER_ERROR";
 export declare const DEFAULT_END_USER_MESSAGE = "An internal server error occurred. Please try again later.";
-interface ConductorRawError {
+export interface ConductorErrorOptions {
     readonly type: string;
     readonly code: string;
-    readonly developerMessage: string;
+    readonly message: string;
     readonly endUserMessage?: string;
     readonly statusCode?: number;
 }
+/**
+ * The base error from which all other more specific Conductor errors derive.
+ * Specifically for errors returned from Conductor's API.
+ */
 export declare class ConductorError extends Error {
     readonly type: string;
+    readonly rawType: string;
     readonly code: string;
-    readonly developerMessage: string;
     readonly endUserMessage: string;
     readonly statusCode: number | undefined;
-    constructor(raw: ConductorRawError);
+    constructor(options: ConductorErrorOptions);
 }
-export {};
+/**
+ * Raised when an error occurs on the third-party integration's end while
+ * processing your end-user's request. E.g., QBWC failed to connect to
+ * QuickBooks Desktop on the end-user's computer.
+ */
+export declare class ConductorIntegrationError extends ConductorError {
+}
+/**
+ * Raised when you make an API call with the wrong parameters, in the wrong
+ * state, or in an invalid way.
+ */
+export declare class ConductorInvalidRequestError extends ConductorError {
+}
+/**
+ * Raised when Conductor cannot authenticate you with the credentials you
+ * provided. E.g., an incorrect API key.
+ */
+export declare class ConductorAuthenticationError extends ConductorError {
+}
+/**
+ * Raised when there is a network problem between the client (on your server)
+ * and Conductor's servers. E.g., a downed network or a bad TLS certificate.
+ */
+export declare class ConductorConnectionError extends ConductorError {
+}
+/**
+ * Raised when something goes wrong on Conductor's end. (These are rare.)
+ */
+export declare class ConductorInternalError extends ConductorError {
+}
+/**
+ * Raised as a fallback for any other error from Conductor that no other error
+ * type captures.
+ */
+export declare class ConductorUnknownError extends ConductorError {
+}
+export declare function generateConductorError(rawConductorError: ConductorErrorOptions): ConductorError;

package/dist/src/error.js

@@ -1,22 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConductorError = exports.DEFAULT_END_USER_MESSAGE = exports.DEFAULT_ERROR_CODE = void 0;
-exports.DEFAULT_ERROR_CODE = "CONDUCTOR__INTERNAL_SERVER_ERROR";
+exports.generateConductorError = exports.ConductorUnknownError = exports.ConductorInternalError = exports.ConductorConnectionError = exports.ConductorAuthenticationError = exports.ConductorInvalidRequestError = exports.ConductorIntegrationError = exports.ConductorError = exports.DEFAULT_END_USER_MESSAGE = void 0;
+/* eslint-disable max-classes-per-file -- Keep the error classes together */
 exports.DEFAULT_END_USER_MESSAGE = "An internal server error occurred. Please try again later.";
+/**
+ * The base error from which all other more specific Conductor errors derive.
+ * Specifically for errors returned from Conductor's API.
+ */
 class ConductorError extends Error {
     type;
+    rawType;
     code;
-    developerMessage;
     endUserMessage;
     statusCode;
-    constructor(raw) {
-        super(raw.developerMessage);
-        this.name = "ConductorError";
-        this.type = raw.type;
-        this.code = raw.code;
-        this.developerMessage = raw.developerMessage;
-        this.endUserMessage = raw.endUserMessage ?? exports.DEFAULT_END_USER_MESSAGE;
-        this.statusCode = raw.statusCode;
+    constructor(options) {
+        super(options.message);
+        // Set `name` to the constructor name so that the error appears in logs as
+        // `[ConductorError: foo]` instead of `[Error: foo]`.
+        this.name = this.constructor.name;
+        // 1. Set `type`, even though it's redundant with `name`, because `name`
+        //    does not appear when doing `console.log(error)` unlike all other
+        //    properties we set.
+        // 2. Set `type` to the constructor name to ensure that subclasses of
+        //    `ConductorError` always have the correct `type` even if they are
+        //    instantiated with the wrong options.
+        this.type = this.constructor.name;
+        this.rawType = options.type;
+        this.code = options.code;
+        this.endUserMessage = options.endUserMessage ?? exports.DEFAULT_END_USER_MESSAGE;
+        this.statusCode = options.statusCode;
     }
 }
 exports.ConductorError = ConductorError;
+/**
+ * Raised when an error occurs on the third-party integration's end while
+ * processing your end-user's request. E.g., QBWC failed to connect to
+ * QuickBooks Desktop on the end-user's computer.
+ */
+class ConductorIntegrationError extends ConductorError {
+}
+exports.ConductorIntegrationError = ConductorIntegrationError;
+/**
+ * Raised when you make an API call with the wrong parameters, in the wrong
+ * state, or in an invalid way.
+ */
+class ConductorInvalidRequestError extends ConductorError {
+}
+exports.ConductorInvalidRequestError = ConductorInvalidRequestError;
+/**
+ * Raised when Conductor cannot authenticate you with the credentials you
+ * provided. E.g., an incorrect API key.
+ */
+class ConductorAuthenticationError extends ConductorError {
+}
+exports.ConductorAuthenticationError = ConductorAuthenticationError;
+/**
+ * Raised when there is a network problem between the client (on your server)
+ * and Conductor's servers. E.g., a downed network or a bad TLS certificate.
+ */
+class ConductorConnectionError extends ConductorError {
+}
+exports.ConductorConnectionError = ConductorConnectionError;
+/**
+ * Raised when something goes wrong on Conductor's end. (These are rare.)
+ */
+class ConductorInternalError extends ConductorError {
+}
+exports.ConductorInternalError = ConductorInternalError;
+/**
+ * Raised as a fallback for any other error from Conductor that no other error
+ * type captures.
+ */
+class ConductorUnknownError extends ConductorError {
+}
+exports.ConductorUnknownError = ConductorUnknownError;
+function generateConductorError(rawConductorError) {
+    switch (rawConductorError.type) {
+        case "INTEGRATION_ERROR": {
+            return new ConductorIntegrationError(rawConductorError);
+        }
+        case "INVALID_REQUEST_ERROR": {
+            return new ConductorInvalidRequestError(rawConductorError);
+        }
+        case "AUTHENTICATION_ERROR": {
+            return new ConductorAuthenticationError(rawConductorError);
+        }
+        case "CONNECTION_ERROR": {
+            return new ConductorConnectionError(rawConductorError);
+        }
+        case "INTERNAL_ERROR": {
+            return new ConductorInternalError(rawConductorError);
+        }
+        default: {
+            return new ConductorUnknownError(rawConductorError);
+        }
+    }
+}
+exports.generateConductorError = generateConductorError;

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

@@ -29,6 +29,9 @@ export type GraphqlCreateIntegrationConnectionInput = {
     endUserSourceId: Scalars["String"];
     integrationKey: Scalars["String"];
 };
+export type GraphqlPingIntegrationConnectionInput = {
+    integrationConnectionId: Scalars["ID"];
+};
 export type GraphqlSendIntegrationRequestInput = {
     integrationConnectionId: Scalars["ID"];
     requestObject: Scalars["JSONObject"];
@@ -105,6 +108,14 @@ export type GraphqlCreateIntegrationConnectionMutation = {
         };
     };
 };
+export type GraphqlPingIntegrationConnectionMutationVariables = Exact<{
+    input: GraphqlPingIntegrationConnectionInput;
+}>;
+export type GraphqlPingIntegrationConnectionMutation = {
+    pingIntegrationConnection: {
+        duration: number;
+    };
+};
 export type GraphqlSendIntegrationRequestMutationVariables = Exact<{
     input: GraphqlSendIntegrationRequestInput;
 }>;
@@ -119,6 +130,7 @@ export declare const GetIntegrationConnectionDocument: string;
 export declare const GetIntegrationConnectionsDocument: string;
 export declare const GetConnectionStatusDocument: 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): {
@@ -126,6 +138,7 @@ export declare function getSdk(client: GraphQLClient, withWrapper?: SdkFunctionW
     getIntegrationConnections(variables?: GraphqlGetIntegrationConnectionsQueryVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlGetIntegrationConnectionsQuery>;
     getConnectionStatus(variables: GraphqlGetConnectionStatusQueryVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlGetConnectionStatusQuery>;
     createIntegrationConnection(variables: GraphqlCreateIntegrationConnectionMutationVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlCreateIntegrationConnectionMutation>;
+    pingIntegrationConnection(variables: GraphqlPingIntegrationConnectionMutationVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlPingIntegrationConnectionMutation>;
     sendIntegrationRequest(variables: GraphqlSendIntegrationRequestMutationVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlSendIntegrationRequestMutation>;
 };
 export type Sdk = ReturnType<typeof getSdk>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSdk = exports.SendIntegrationRequestDocument = exports.CreateIntegrationConnectionDocument = exports.GetConnectionStatusDocument = exports.GetIntegrationConnectionsDocument = exports.GetIntegrationConnectionDocument = exports.UserErrorFragmentDoc = exports.IntegrationConnectionFragmentDoc = void 0;
+exports.getSdk = exports.SendIntegrationRequestDocument = exports.PingIntegrationConnectionDocument = exports.CreateIntegrationConnectionDocument = exports.GetConnectionStatusDocument = exports.GetIntegrationConnectionsDocument = exports.GetIntegrationConnectionDocument = exports.UserErrorFragmentDoc = exports.IntegrationConnectionFragmentDoc = void 0;
 exports.IntegrationConnectionFragmentDoc = `
     fragment IntegrationConnection on IntegrationConnection {
   id
@@ -53,6 +53,13 @@ exports.CreateIntegrationConnectionDocument = `
   }
 }
     ${exports.IntegrationConnectionFragmentDoc}`;
+exports.PingIntegrationConnectionDocument = `
+    mutation pingIntegrationConnection($input: PingIntegrationConnectionInput!) {
+  pingIntegrationConnection(input: $input) {
+    duration
+  }
+}
+    `;
 exports.SendIntegrationRequestDocument = `
     mutation sendIntegrationRequest($input: SendIntegrationRequestInput!) {
   sendIntegrationRequest(input: $input) {
@@ -75,6 +82,9 @@ function getSdk(client, withWrapper = defaultWrapper) {
         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");
         },

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

@@ -1,7 +1,7 @@
-import { ConductorError } from "../error";
+import type { ConductorError } from "../error";
 import type { getSdk } from "../graphql/__generated__/operationTypes";
 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 generateConductorError(error: Error): ConductorError;
+export declare function wrapError(error: Error): ConductorError;

package/dist/src/graphql/graphqlOperationWrapper.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.generateConductorError = exports.graphqlOperationWrapper = exports.wrapGraphqlOperations = void 0;
+exports.wrapError = exports.graphqlOperationWrapper = exports.wrapGraphqlOperations = void 0;
 const package_json_1 = __importDefault(require("../../package.json"));
 const error_1 = require("../error");
 const graphql_request_1 = require("graphql-request");
@@ -45,7 +45,7 @@ async function graphqlOperationWrapper(operationName, variables, operation, verb
         return result;
     }
     catch (error) {
-        const conductorError = generateConductorError(error);
+        const conductorError = wrapError(error);
         if (verbose) {
             const errorLog = {
                 duration: getDurationString(startTime),
@@ -59,48 +59,44 @@ async function graphqlOperationWrapper(operationName, variables, operation, verb
     }
 }
 exports.graphqlOperationWrapper = graphqlOperationWrapper;
-function generateConductorError(error) {
+function wrapError(error) {
     if (error instanceof graphql_request_1.ClientError) {
         const { response } = error;
         if ([404, 502, 503].includes(response.status)) {
-            return new error_1.ConductorError({
-                type: "connection_error",
-                code: error_1.DEFAULT_ERROR_CODE,
-                developerMessage: `The Conductor server returned a ${response.status} error, which may indicate that the server is down. Please alert the Conductor team if this error persists.`,
+            return (0, error_1.generateConductorError)({
+                type: "CONNECTION_ERROR",
+                code: "SERVER_UNAVAILABLE",
+                message: `The Conductor server returned a ${response.status} error, which may indicate that the server is unavailable. Please alert the Conductor team if this error persists.`,
                 statusCode: response.status,
             });
         }
         const nestedError = response.errors?.[0];
-        if (nestedError?.extensions["code"] === "GRAPHQL_VALIDATION_FAILED") {
-            return new error_1.ConductorError({
-                type: "temp",
-                code: error_1.DEFAULT_ERROR_CODE,
-                developerMessage: `The Conductor server is no longer compatible with your version of "${package_json_1.default.name}". Please run "yarn upgrade ${package_json_1.default.name} --latest" to update.`,
-                statusCode: response.status,
-            });
-        }
-        // TODO: Integrate with new error attributes.
-        const errorMessage = nestedError?.message ??
-            // Though `ClientError.response.error` is *not* defined in the type
-            // definition, we've seen it occur (e.g., attempting to access the
-            // `development` environment when `ngrok` is not running locally).
-            response["error"];
-        if (errorMessage !== undefined) {
-            return new error_1.ConductorError({
-                type: "temp",
-                code: error_1.DEFAULT_ERROR_CODE,
-                developerMessage: errorMessage,
+        const errorExtensions = nestedError?.extensions;
+        if (errorExtensions) {
+            if (errorExtensions["code"] === "GRAPHQL_VALIDATION_FAILED") {
+                return (0, error_1.generateConductorError)({
+                    type: "INVALID_REQUEST_ERROR",
+                    code: "CLIENT_OUTDATED",
+                    message: `Your version of "${package_json_1.default.name}" is not longer compatible with the Conductor server. Please run "yarn upgrade ${package_json_1.default.name} --latest" to update.`,
+                    statusCode: response.status,
+                });
+            }
+            return (0, error_1.generateConductorError)({
+                type: errorExtensions["type"],
+                code: errorExtensions["code"],
+                message: nestedError.message,
+                endUserMessage: errorExtensions["endUserMessage"],
                 statusCode: response.status,
             });
         }
     }
-    return new error_1.ConductorError({
-        type: "temp",
-        code: error_1.DEFAULT_ERROR_CODE,
-        developerMessage: "Invalid JSON received from the Conductor API.",
+    return (0, error_1.generateConductorError)({
+        type: "INTERNAL_ERROR",
+        code: "INVALID_JSON_RESPONSE",
+        message: "Invalid JSON received from the Conductor API.",
     });
 }
-exports.generateConductorError = generateConductorError;
+exports.wrapError = wrapError;
 function getDurationString(startTime) {
     const duration = Date.now() - startTime;
     return `${Math.round(duration / 10) / 100}s`;

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 import Client from "./Client";
 export default Client;
 export { type ClientOptions } from "./Client";
+export * from "./error";
 export * as QbdTypes from "./integrations/qbd/qbdTypes";

package/dist/src/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+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);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -31,4 +34,5 @@ exports.QbdTypes = void 0;
 const Client_1 = __importDefault(require("./Client"));
 // eslint-disable-next-line unicorn/prefer-export-from -- We need `Client` to be the default export, which is impossible to define with `export from`.
 exports.default = Client_1.default;
+__exportStar(require("./error"), exports);
 exports.QbdTypes = __importStar(require("./integrations/qbd/qbdTypes"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conductor-node",
-  "version": "8.2.4",
+  "version": "8.4.0",
   "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
   "author": "Danny Nemer <hi@DannyNemer.com>",
   "license": "MIT",