conductor-node 6.2.5 → 7.0.0

package/README.md

@@ -34,13 +34,11 @@ const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
 
 ## `Conductor` APIs
 
-### `getIntegrationConnections()`
+### `createIntegrationConnection(input: CreateIntegrationConnectionInput)`
 
-Fetch all authorized integration-connections.
+**🚧 Coming soon!**
 
-```ts
-const qbdConnections = await conductor.getIntegrationConnections();
-```
+Create a new integration-connection.
 
 ### `qbd.*`
 
@@ -54,16 +52,12 @@ const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
 });
 ```
 
-### `createIntegrationConnection(qbwcUsername: string)`
-
-**🚧 Not yet enabled.**
+### `getIntegrationConnections()`
 
-Create a new integration-connection.
+Fetch all authorized integration-connections.
 
 ```ts
-const newQbdConnection = await conductor.createIntegrationConnection(
-  "qbwc_username"
-);
+const qbdConnections = await conductor.getIntegrationConnections();
 ```
 
 ### `getIntegrationConnectionById(id: string)`
@@ -85,11 +79,3 @@ const isActive = await conductor.isIntegrationConnectionActive(
   qbdConnections[0].id
 );
 ```
-
-### `logConnectionStatuses()`
-
-Log the time since Conductor has heard from each authorized integration-connection.
-
-```ts
-conductor.logConnectionStatuses(); // Outputs to logs
-```

package/dist/package.json

@@ -1,18 +1,7 @@
 {
     "name": "conductor-node",
-    "version": "6.2.5",
+    "version": "7.0.0",
     "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
-    "keywords": [
-        "accounting",
-        "api",
-        "conductor",
-        "qbd",
-        "qbwc",
-        "qbxml",
-        "quickbooks desktop",
-        "sdk",
-        "typescript"
-    ],
     "author": "Danny Nemer <hi@DannyNemer.com>",
     "license": "MIT",
     "type": "commonjs",
@@ -26,7 +15,8 @@
         "prepack": "yarn tsc && yarn delete-compiled-tests && yarn tsc-alias --verbose",
         "delete-compiled-tests": "rm -rf `find ./dist -type d -name __tests__`",
         "postpack": "rm -rf dist",
-        "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo"
+        "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo",
+        "gen:graphql-types": "yarn graphql-codegen --config ./src/graphql/codegenConfig.ts"
     },
     "engines": {
         "node": ">=16"
@@ -37,6 +27,21 @@
         "graphql-request": "^5.0.0"
     },
     "devDependencies": {
+        "@graphql-codegen/add": "^3.2.1",
+        "@graphql-codegen/cli": "^2.13.11",
+        "@graphql-codegen/typescript-graphql-request": "^4.5.8",
+        "@graphql-codegen/typescript-operations": "^2.5.6",
         "tsc-alias": "^1.7.0"
-    }
+    },
+    "keywords": [
+        "accounting",
+        "api",
+        "conductor",
+        "qbd",
+        "qbwc",
+        "qbxml",
+        "quickbooks desktop",
+        "sdk",
+        "typescript"
+    ]
 }

package/dist/src/Client.d.ts

@@ -1,24 +1,36 @@
 import type { Environment } from "./environment";
-import type { IntegrationConnection, IntegrationRequestInput } from "./graphqlTypes";
+import type { GraphqlCreateIntegrationConnectionInput, GraphqlCreateIntegrationConnectionMutation, GraphqlGetIntegrationConnectionQuery, GraphqlGetIntegrationConnectionQueryVariables, GraphqlGetIntegrationConnectionsQuery, GraphqlIntegrationRequestInput, GraphqlIntegrationRequestQuery, GraphqlIsIntegrationConnectionActiveQuery, GraphqlIsIntegrationConnectionActiveQueryVariables } from "./graphql/__generated__/operationTypes";
 import QbdIntegration from "./integrations/qbd/QbdIntegration";
 export interface ClientOptions {
     /** Log each request and response. */
-    verbose?: boolean;
-    serverEnvironment?: Environment;
+    readonly verbose?: boolean;
+    readonly serverEnvironment?: Environment;
 }
 export default class Client {
     /** QuickBooks Desktop integration. */
     readonly qbd: QbdIntegration;
-    private readonly serverURL;
-    private readonly gqlClient;
     private readonly verbose;
+    private readonly serverURL;
+    private readonly graphqlClient;
+    private readonly graphqlOperations;
     constructor(apiKey: string, { verbose, serverEnvironment }?: ClientOptions);
-    getIntegrationConnectionById(integrationConnectionId: string): Promise<IntegrationConnection>;
-    getIntegrationConnections(): Promise<IntegrationConnection[]>;
-    createIntegrationConnection(qbwcUsername: string): Promise<IntegrationConnection>;
-    isIntegrationConnectionActive(integrationConnectionId: string, secondsSinceLastActive?: number): Promise<boolean>;
-    logConnectionStatuses(): Promise<void>;
-    integrationRequest(input: IntegrationRequestInput): Promise<object>;
-    private request;
+    getIntegrationConnection(integrationConnectionId: GraphqlGetIntegrationConnectionQueryVariables["integrationConnectionId"]): Promise<GraphqlGetIntegrationConnectionQuery["integrationConnection"]>;
+    getIntegrationConnections(): Promise<GraphqlGetIntegrationConnectionsQuery["integrationConnections"]>;
+    /**
+     * Create 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.endUserEmail Your end-user's email address for identification
+     * purposes only. No emails will be sent. Must be distinct from other
+     * connections for the same integration.
+     * @param input.endUserName Your end-user's name.
+     * @returns The newly created integration connection.
+     */
+    createIntegrationConnection(input: GraphqlCreateIntegrationConnectionInput): Promise<GraphqlCreateIntegrationConnectionMutation["createIntegrationConnection"]>;
+    isIntegrationConnectionActive(integrationConnectionId: GraphqlIsIntegrationConnectionActiveQueryVariables["integrationConnectionId"], secondsSinceLastActive?: GraphqlIsIntegrationConnectionActiveQueryVariables["secondsSinceLastActive"]): Promise<GraphqlIsIntegrationConnectionActiveQuery["integrationConnection"]["isActive"]>;
+    integrationRequest(input: GraphqlIntegrationRequestInput): Promise<GraphqlIntegrationRequestQuery["integrationRequest"]>;
+    graphqlOperationWrapper<V, R>(operationName: string, variables: V, operation: (variables: V) => Promise<R>): Promise<R>;
     private checkForUpdates;
 }

package/dist/src/Client.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const package_json_1 = __importDefault(require("./../package.json"));
 const environment_1 = require("./environment");
+const operationTypes_1 = require("./graphql/__generated__/operationTypes");
 const QbdIntegration_1 = __importDefault(require("./integrations/qbd/QbdIntegration"));
 const chalk_1 = __importDefault(require("chalk"));
 const graphql_request_1 = require("graphql-request");
@@ -12,133 +13,83 @@ const node_child_process_1 = require("node:child_process");
 class Client {
     /** QuickBooks Desktop integration. */
     qbd;
-    serverURL;
-    gqlClient;
     verbose;
+    serverURL;
+    graphqlClient;
+    graphqlOperations;
     constructor(apiKey, { verbose = false, serverEnvironment = "staging" } = {}) {
         this.checkForUpdates();
         this.verbose = verbose;
         this.serverURL = (0, environment_1.envToBaseServerURL)(serverEnvironment);
-        this.gqlClient = new graphql_request_1.GraphQLClient(`${this.serverURL}/graphql`, {
+        this.graphqlClient = new graphql_request_1.GraphQLClient(`${this.serverURL}/graphql`, {
             headers: {
                 Authorization: `Bearer ${apiKey}`,
                 "User-Agent": `${package_json_1.default.name}/${package_json_1.default.version} (Node.js ${process.version})`,
             },
         });
+        this.graphqlOperations = (0, operationTypes_1.getSdk)(this.graphqlClient);
+        Object.entries(this.graphqlOperations).forEach(([operationName, operation]) => {
+            // @ts-expect-error - `operationName` is a key of `this.gqlOperations`.
+            this.graphqlOperations[operationName] = async (variables) => this.graphqlOperationWrapper(operationName, variables, 
+            // @ts-expect-error - It is safe to call `operation` with `variables`.
+            operation);
+        });
         this.qbd = new QbdIntegration_1.default(this);
     }
-    async getIntegrationConnectionById(integrationConnectionId) {
-        const data = (await this.request(
-        /* GraphQL */ `
-        query GetIntegrationConnectionById($integrationConnectionId: ID!) {
-          integrationConnection(id: $integrationConnectionId) {
-            id
-            integration {
-              id
-              name
-            }
-            qbwcUsername
-            lastHeartbeatAt
-          }
-        }
-      `, { integrationConnectionId }));
-        return data.integrationConnection;
+    async getIntegrationConnection(integrationConnectionId) {
+        return this.graphqlOperations
+            .getIntegrationConnection({ integrationConnectionId })
+            .then((result) => result.integrationConnection);
     }
     async getIntegrationConnections() {
-        const data = (await this.request(/* GraphQL */ `
-      query {
-        integrationConnections {
-          id
-          integration {
-            id
-            name
-            key
-          }
-          qbwcUsername
-          lastHeartbeatAt
-        }
-      }
-    `));
-        return data.integrationConnections;
+        return this.graphqlOperations
+            .getIntegrationConnections()
+            .then((result) => result.integrationConnections);
     }
-    async createIntegrationConnection(qbwcUsername) {
-        const data = (await this.request(
-        /* GraphQL */ `
-        mutation CreateIntegrationConnection(
-          $input: IntegrationConnectionInput!
-        ) {
-          createIntegrationConnection(input: $input) {
-            id
-            integration {
-              id
-              name
-              key
-            }
-            qbwcUsername
-            lastHeartbeatAt
-          }
-        }
-      `, {
-            input: {
-                integrationKey: "qbd",
-                qbwcUsername,
-            },
-        }));
-        return data.createIntegrationConnection;
+    /**
+     * Create 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.endUserEmail Your end-user's email address for identification
+     * purposes only. No emails will be sent. Must be distinct from other
+     * connections for the same integration.
+     * @param input.endUserName Your end-user's name.
+     * @returns The newly created integration connection.
+     */
+    async createIntegrationConnection(input) {
+        return this.graphqlOperations
+            .createIntegrationConnection({ input })
+            .then((result) => result.createIntegrationConnection);
     }
     async isIntegrationConnectionActive(integrationConnectionId, secondsSinceLastActive = 60) {
-        const data = (await this.request(
-        /* GraphQL */ `
-        query IsIntegrationConnectionActive(
-          $integrationConnectionId: ID!
-          $secondsSinceLastActive: Int!
-        ) {
-          integrationConnection(id: $integrationConnectionId) {
-            isActive(secondsSinceLastActive: $secondsSinceLastActive)
-          }
-        }
-      `, { integrationConnectionId, secondsSinceLastActive }));
-        return data.integrationConnection.isActive;
+        return this.graphqlOperations
+            .isIntegrationConnectionActive({
+            integrationConnectionId,
+            secondsSinceLastActive,
+        })
+            .then((result) => result.integrationConnection.isActive);
     }
-    async logConnectionStatuses() {
-        const integrationConnections = (await this.getIntegrationConnections());
-        console.log("Time since Conductor last heard from each integration connection:");
-        integrationConnections.forEach(({ qbwcUsername, lastHeartbeatAt }) => {
-            let logMessage = `${chalk_1.default.bold(qbwcUsername)}: `;
-            if (lastHeartbeatAt !== null) {
-                const secondsSinceLastHeartbeat = (Date.now() - new Date(lastHeartbeatAt).getTime()) / 1000;
-                logMessage += chalk_1.default.yellow(`${secondsSinceLastHeartbeat}s ago`);
-            }
-            else {
-                logMessage += "never";
-            }
-            console.log(logMessage);
-        });
-    }
-    // TODO: Hide this method from the dev user while still allowing the
+    // TODO: Hide this method from the dev-user while still allowing the
     // integration clients to access it.
     async integrationRequest(input) {
-        const response = await this.request(
-        /* GraphQL */ `
-        query IntegrationRequest($input: IntegrationRequestInput!) {
-          integrationRequest(input: $input)
-        }
-      `, { input });
-        // @ts-expect-error - This will pass after we integrate GQL codegen.
-        return response.integrationRequest;
+        return this.graphqlOperations
+            .integrationRequest({ input })
+            .then((result) => result.integrationRequest);
     }
-    async request(gqlQuery, variables) {
+    async graphqlOperationWrapper(operationName, variables, operation) {
         if (this.verbose) {
-            console.log(`Client sent request to ${this.serverURL}:`, gqlQuery, JSON.stringify(variables, undefined, 2));
+            console.log(`Client sent request to ${this.serverURL}:`, operationName, JSON.stringify(variables, undefined, 2));
             console.time("Request time");
         }
         try {
-            const response = await this.gqlClient.request(gqlQuery, variables);
+            const result = await operation(variables);
             if (this.verbose) {
                 console.timeEnd("Request time");
-                console.log(`Client received response from ${this.serverURL}:`, JSON.stringify(response, undefined, 2));
+                console.log(`Client received response from ${this.serverURL}:`, JSON.stringify(result, undefined, 2));
             }
-            return response;
+            return result;
         }
         catch (error) {
             if (this.verbose) {

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

@@ -0,0 +1,150 @@
+import { GraphQLClient } from "graphql-request";
+import * as Dom from "graphql-request/dist/types.dom";
+export declare type Maybe<T> = T | null;
+export declare type InputMaybe<T> = Maybe<T>;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare 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 declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    DateTime: Date;
+    JSONObject: object;
+};
+export declare type GraphqlCreateIntegrationConnectionInput = {
+    endUserEmail: Scalars["String"];
+    endUserName: Scalars["String"];
+    integrationKey: Scalars["String"];
+};
+export declare type GraphqlCreateIntegrationConnectionResult = {
+    integrationConnection: GraphqlIntegrationConnection;
+    qbwcPassword: Scalars["String"];
+};
+export declare type GraphqlIntegration = {
+    id: Scalars["ID"];
+    key: Scalars["String"];
+    name: Scalars["String"];
+};
+export declare type GraphqlIntegrationConnection = {
+    devUserId: Scalars["ID"];
+    endUserEmail: Scalars["String"];
+    endUserName: Scalars["String"];
+    id: Scalars["ID"];
+    integration: GraphqlIntegration;
+    integrationKey: Scalars["String"];
+    isActive: Scalars["Boolean"];
+    lastHeartbeatAt: Maybe<Scalars["DateTime"]>;
+    qbwcPassword: Scalars["String"];
+};
+export declare type GraphqlIntegrationConnectionIsActiveArgs = {
+    secondsSinceLastActive: Scalars["Int"];
+};
+export declare type GraphqlIntegrationRequestInput = {
+    integrationConnectionId: Scalars["ID"];
+    requestObject: Scalars["JSONObject"];
+};
+export declare type GraphqlMutation = {
+    createIntegrationConnection: GraphqlCreateIntegrationConnectionResult;
+};
+export declare type GraphqlMutationCreateIntegrationConnectionArgs = {
+    input: GraphqlCreateIntegrationConnectionInput;
+};
+export declare type GraphqlQuery = {
+    integrationConnection: GraphqlIntegrationConnection;
+    integrationConnections: Array<GraphqlIntegrationConnection>;
+    integrationRequest: Scalars["JSONObject"];
+};
+export declare type GraphqlQueryIntegrationConnectionArgs = {
+    id: Scalars["ID"];
+};
+export declare type GraphqlQueryIntegrationRequestArgs = {
+    input: GraphqlIntegrationRequestInput;
+};
+export declare type GraphqlIntegrationConnectionFragment = {
+    id: string;
+    integrationKey: string;
+    endUserEmail: string;
+    endUserName: string;
+    lastHeartbeatAt: Date | null;
+};
+export declare type GraphqlGetIntegrationConnectionQueryVariables = Exact<{
+    integrationConnectionId: Scalars["ID"];
+}>;
+export declare type GraphqlGetIntegrationConnectionQuery = {
+    integrationConnection: {
+        id: string;
+        integrationKey: string;
+        endUserEmail: string;
+        endUserName: string;
+        lastHeartbeatAt: Date | null;
+    };
+};
+export declare type GraphqlGetIntegrationConnectionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type GraphqlGetIntegrationConnectionsQuery = {
+    integrationConnections: Array<{
+        id: string;
+        integrationKey: string;
+        endUserEmail: string;
+        endUserName: string;
+        lastHeartbeatAt: Date | null;
+    }>;
+};
+export declare type GraphqlCreateIntegrationConnectionMutationVariables = Exact<{
+    input: GraphqlCreateIntegrationConnectionInput;
+}>;
+export declare type GraphqlCreateIntegrationConnectionMutation = {
+    createIntegrationConnection: {
+        qbwcPassword: string;
+        integrationConnection: {
+            id: string;
+            integrationKey: string;
+            endUserEmail: string;
+            endUserName: string;
+            lastHeartbeatAt: Date | null;
+        };
+    };
+};
+export declare type GraphqlIsIntegrationConnectionActiveQueryVariables = Exact<{
+    integrationConnectionId: Scalars["ID"];
+    secondsSinceLastActive: Scalars["Int"];
+}>;
+export declare type GraphqlIsIntegrationConnectionActiveQuery = {
+    integrationConnection: {
+        isActive: boolean;
+    };
+};
+export declare type GraphqlIntegrationRequestQueryVariables = Exact<{
+    input: GraphqlIntegrationRequestInput;
+}>;
+export declare type GraphqlIntegrationRequestQuery = {
+    integrationRequest: object;
+};
+export declare const IntegrationConnectionFragmentDoc = "\n    fragment IntegrationConnection on IntegrationConnection {\n  id\n  integrationKey\n  endUserEmail\n  endUserName\n  lastHeartbeatAt\n}\n    ";
+export declare const GetIntegrationConnectionDocument: string;
+export declare const GetIntegrationConnectionsDocument: string;
+export declare const CreateIntegrationConnectionDocument: string;
+export declare const IsIntegrationConnectionActiveDocument = "\n    query isIntegrationConnectionActive($integrationConnectionId: ID!, $secondsSinceLastActive: Int!) {\n  integrationConnection(id: $integrationConnectionId) {\n    isActive(secondsSinceLastActive: $secondsSinceLastActive)\n  }\n}\n    ";
+export declare const IntegrationRequestDocument = "\n    query integrationRequest($input: IntegrationRequestInput!) {\n  integrationRequest(input: $input)\n}\n    ";
+export declare 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?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlGetIntegrationConnectionQuery>;
+    getIntegrationConnections(variables?: GraphqlGetIntegrationConnectionsQueryVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlGetIntegrationConnectionsQuery>;
+    createIntegrationConnection(variables: GraphqlCreateIntegrationConnectionMutationVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlCreateIntegrationConnectionMutation>;
+    isIntegrationConnectionActive(variables: GraphqlIsIntegrationConnectionActiveQueryVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlIsIntegrationConnectionActiveQuery>;
+    integrationRequest(variables: GraphqlIntegrationRequestQueryVariables, requestHeaders?: (Record<string, string> | Dom.Headers | string[][]) | undefined): Promise<GraphqlIntegrationRequestQuery>;
+};
+export declare type Sdk = ReturnType<typeof getSdk>;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSdk = exports.IntegrationRequestDocument = exports.IsIntegrationConnectionActiveDocument = exports.CreateIntegrationConnectionDocument = exports.GetIntegrationConnectionsDocument = exports.GetIntegrationConnectionDocument = exports.IntegrationConnectionFragmentDoc = void 0;
+exports.IntegrationConnectionFragmentDoc = `
+    fragment IntegrationConnection on IntegrationConnection {
+  id
+  integrationKey
+  endUserEmail
+  endUserName
+  lastHeartbeatAt
+}
+    `;
+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
+    }
+    qbwcPassword
+  }
+}
+    ${exports.IntegrationConnectionFragmentDoc}`;
+exports.IsIntegrationConnectionActiveDocument = `
+    query isIntegrationConnectionActive($integrationConnectionId: ID!, $secondsSinceLastActive: Int!) {
+  integrationConnection(id: $integrationConnectionId) {
+    isActive(secondsSinceLastActive: $secondsSinceLastActive)
+  }
+}
+    `;
+exports.IntegrationRequestDocument = `
+    query integrationRequest($input: IntegrationRequestInput!) {
+  integrationRequest(input: $input)
+}
+    `;
+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");
+        },
+        isIntegrationConnectionActive(variables, requestHeaders) {
+            return withWrapper((wrappedRequestHeaders) => client.request(exports.IsIntegrationConnectionActiveDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "isIntegrationConnectionActive", "query");
+        },
+        integrationRequest(variables, requestHeaders) {
+            return withWrapper((wrappedRequestHeaders) => client.request(exports.IntegrationRequestDocument, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "integrationRequest", "query");
+        },
+    };
+}
+exports.getSdk = getSdk;

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

@@ -0,0 +1,3 @@
+import type { CodegenConfig } from "@graphql-codegen/cli";
+declare const codegenConfig: CodegenConfig;
+export default codegenConfig;

package/dist/src/graphql/codegenConfig.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegenConfig = {
+    schema: "../server/src/graphql/__generated__/schema.graphql",
+    hooks: { afterOneFileWrite: ["yarn prettier --write"] },
+    documents: ["./src/graphql/operations.graphql"],
+    ignoreNoDocuments: true,
+    generates: {
+        "./src/graphql/__generated__/operationTypes.ts": {
+            plugins: [
+                "typescript",
+                "typescript-operations",
+                "typescript-graphql-request",
+                {
+                    add: {
+                        content: "/* eslint-disable eslint-comments/disable-enable-pair -- Auto-generated */\n" +
+                            "/* eslint-disable eslint-comments/no-unlimited-disable -- Auto-generated */\n" +
+                            "/* eslint-disable -- Auto-generated */",
+                    },
+                },
+            ],
+            config: {
+                // Avoid including `__typename` in objects we return to dev-users.
+                skipTypename: true,
+                avoidOptionals: true,
+                typesPrefix: "Graphql",
+                // Avoid adding `graphql-tag` as a client dependency.
+                documentMode: "string",
+                scalars: {
+                    DateTime: "Date",
+                    JSONObject: "object",
+                },
+                strictScalars: true,
+            },
+        },
+    },
+};
+exports.default = codegenConfig;

package/dist/src/testUtils.d.ts

@@ -1,2 +1,2 @@
-export declare const TEST_CLIENT_API_KEY = "test_client_api_key";
+export declare const TEST_CLIENT_API_KEY = "sk_test_miter";
 export declare const TEST_QBD_CONNECTION_ID = "test_qbd_connection_id";

package/dist/src/testUtils.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEST_QBD_CONNECTION_ID = exports.TEST_CLIENT_API_KEY = void 0;
-exports.TEST_CLIENT_API_KEY = "test_client_api_key";
+exports.TEST_CLIENT_API_KEY = "sk_test_miter";
 exports.TEST_QBD_CONNECTION_ID = "test_qbd_connection_id";

package/package.json

@@ -1,18 +1,7 @@
 {
   "name": "conductor-node",
-  "version": "6.2.5",
+  "version": "7.0.0",
   "description": "Easily integrate with the entire QuickBooks Desktop API with fully-typed async TypeScript",
-  "keywords": [
-    "accounting",
-    "api",
-    "conductor",
-    "qbd",
-    "qbwc",
-    "qbxml",
-    "quickbooks desktop",
-    "sdk",
-    "typescript"
-  ],
   "author": "Danny Nemer <hi@DannyNemer.com>",
   "license": "MIT",
   "type": "commonjs",
@@ -26,7 +15,8 @@
     "prepack": "yarn tsc && yarn delete-compiled-tests && yarn tsc-alias --verbose",
     "delete-compiled-tests": "rm -rf `find ./dist -type d -name __tests__`",
     "postpack": "rm -rf dist",
-    "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo"
+    "clean": "rm -rf dist package conductor-node-*.tgz tsconfig.tsbuildinfo",
+    "gen:graphql-types": "yarn graphql-codegen --config ./src/graphql/codegenConfig.ts"
   },
   "engines": {
     "node": ">=16"
@@ -37,6 +27,21 @@
     "graphql-request": "^5.0.0"
   },
   "devDependencies": {
+    "@graphql-codegen/add": "^3.2.1",
+    "@graphql-codegen/cli": "^2.13.11",
+    "@graphql-codegen/typescript-graphql-request": "^4.5.8",
+    "@graphql-codegen/typescript-operations": "^2.5.6",
     "tsc-alias": "^1.7.0"
-  }
+  },
+  "keywords": [
+    "accounting",
+    "api",
+    "conductor",
+    "qbd",
+    "qbwc",
+    "qbxml",
+    "quickbooks desktop",
+    "sdk",
+    "typescript"
+  ]
 }

package/dist/src/graphqlTypes.d.ts

@@ -1,19 +0,0 @@
-export interface Integration {
-    id: string;
-    name: string;
-    key: string;
-}
-export interface IntegrationConnection {
-    id: string;
-    integration: Integration;
-    qbwcUsername: string;
-    lastHeartbeatAt: string | null;
-}
-export interface IntegrationRequestInput {
-    integrationConnectionId: string;
-    requestObject: object;
-}
-export interface IntegrationConnectionInput {
-    integrationKey: string;
-    qbwcUsername: string;
-}

package/dist/src/graphqlTypes.js

@@ -1,3 +0,0 @@
-"use strict";
-// TODO: Replace with codegen.
-Object.defineProperty(exports, "__esModule", { value: true });