conductor-node 11.10.1 → 12.0.0-beta.2

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+
+const has = Object.prototype.hasOwnProperty;
+const is_array = Array.isArray;
+
+const hex_table = (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (is_array(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (is_array(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if (
+        (options && (options.plainObjects || options.allowPrototypes)) ||
+        !has.call(Object.prototype, source)
+      ) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (is_array(target) && !is_array(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (is_array(target) && is_array(source)) {
+    source.forEach(function (item, i) {
+      if (has.call(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has.call(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (is_array(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/pagination.ts

@@ -0,0 +1,60 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from './core';
+
+export interface CursorPageResponse<Item> {
+  data: Array<Item>;
+
+  nextCursor: string | null;
+}
+
+export interface CursorPageParams {
+  cursor?: string;
+
+  limit?: number;
+}
+
+export class CursorPage<Item> extends AbstractPage<Item> implements CursorPageResponse<Item> {
+  data: Array<Item>;
+
+  nextCursor: string | null;
+
+  constructor(
+    client: APIClient,
+    response: Response,
+    body: CursorPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.data = body.data || [];
+    this.nextCursor = body.nextCursor || null;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.data ?? [];
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<CursorPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const cursor = this.nextCursor;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      params: {
+        cursor: cursor,
+      },
+    };
+  }
+}

package/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Conductor } from './index';
+
+export class APIResource {
+  protected _client: Conductor;
+
+  constructor(client: Conductor) {
+    this._client = client;
+  }
+}

package/src/resources/auth-sessions.ts

@@ -0,0 +1,99 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class AuthSessions extends APIResource {
+  /**
+   * To launch the authentication flow, create an AuthSession and pass the returned
+   * session’s `authFlowUrl` to the client for your end-user to visit in their
+   * browser.
+   */
+  create(body: AuthSessionCreateParams, options?: Core.RequestOptions): Core.APIPromise<AuthSession> {
+    return this._client.post('/auth-sessions', { body, ...options });
+  }
+
+  /**
+   * Retrieves the details of an AuthSession that has previously been created.
+   */
+  retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<AuthSession> {
+    return this._client.get(`/auth-sessions/${id}`, options);
+  }
+}
+
+export interface AuthSession {
+  /**
+   * The unique identifier for this AuthSession.
+   */
+  id: string;
+
+  /**
+   * The URL of the authentication flow that you will pass to your client for your
+   * user to set up their IntegrationConnection.
+   */
+  authFlowUrl: string;
+
+  /**
+   * The secret used in `authFlowUrl` to securely access the authentication flow.
+   */
+  clientSecret: string;
+
+  /**
+   * The date and time when this AuthSession record was created.
+   */
+  createdAt: string;
+
+  /**
+   * The ID of the EndUser for whom to create an IntegrationConnection.
+   */
+  endUserId: string;
+
+  /**
+   * The date and time when this AuthSession expires. By default, this value is 30
+   * minutes from creation. You can extend this time by setting `linkExpiryMins` when
+   * [creating the AuthSession](/apis/auth-sessions/create).
+   */
+  expiresAt: string;
+
+  /**
+   * The type of object. This value is always `"auth_session"`.
+   */
+  objectType: 'auth_session';
+
+  /**
+   * The URL to which Conductor will redirect your user to return to your app after
+   * they complete the authentication flow. If `null`, their browser tab will close
+   * instead.
+   */
+  redirectUrl: string | null;
+}
+
+export interface AuthSessionCreateParams {
+  /**
+   * The ID of the EndUser for whom to create the IntegrationConnection.
+   */
+  endUserId: string;
+
+  /**
+   * Your Conductor publishable key, which we use to create the session’s
+   * `authFlowUrl`.
+   */
+  publishableKey: string;
+
+  /**
+   * The number of minutes after which the AuthSession will expire. Must be at least
+   * 15 minutes and no more than 7 days. If not provided, defaults to 30 minutes.
+   */
+  linkExpiryMins?: number;
+
+  /**
+   * The URL to which Conductor will redirect the end-user to return to your app
+   * after they complete the authentication flow. If not provided, their browser tab
+   * will close instead.
+   */
+  redirectUrl?: string;
+}
+
+export declare namespace AuthSessions {
+  export { type AuthSession as AuthSession, type AuthSessionCreateParams as AuthSessionCreateParams };
+}

package/src/resources/end-users.ts

@@ -0,0 +1,216 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class EndUsers extends APIResource {
+  /**
+   * Creates an EndUser.
+   */
+  create(body: EndUserCreateParams, options?: Core.RequestOptions): Core.APIPromise<EndUser> {
+    return this._client.post('/end-users', { body, ...options });
+  }
+
+  /**
+   * Retrieves an EndUser object.
+   */
+  retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<EndUser> {
+    return this._client.get(`/end-users/${id}`, options);
+  }
+
+  /**
+   * Returns a list of your EndUsers.
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<EndUserListResponse> {
+    return this._client.get('/end-users', options);
+  }
+
+  /**
+   * Permanently deletes an EndUser object and all of its connections.
+   */
+  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<EndUserDeleteResponse> {
+    return this._client.delete(`/end-users/${id}`, options);
+  }
+
+  /**
+   * Sends a request directly to the specified integration connection (e.g.,
+   * QuickBooks Desktop) on behalf of the end-user.
+   */
+  passthrough(
+    id: string,
+    integrationSlug: 'quickbooks_desktop',
+    body: EndUserPassthroughParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EndUserPassthroughResponse> {
+    return this._client.post(`/end-users/${id}/passthrough/${integrationSlug}`, { body, ...options });
+  }
+
+  /**
+   * Checks whether the specified IntegrationConnection can connect and process
+   * requests end-to-end. This is useful for showing a "connection status" indicator
+   * in your app.
+   */
+  ping(
+    id: string,
+    integrationSlug: 'quickbooks_desktop',
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EndUserPingResponse> {
+    return this._client.get(`/end-users/${id}/ping/${integrationSlug}`, options);
+  }
+}
+
+export interface EndUser {
+  /**
+   * The unique identifier for this EndUser. You must save this value to your
+   * database because it is how you identify which of your users to receive your API
+   * requests.
+   */
+  id: string;
+
+  /**
+   * The EndUser's company name that will be shown elsewhere in Conductor.
+   */
+  companyName: string;
+
+  /**
+   * The date and time when this EndUser record was created.
+   */
+  createdAt: string;
+
+  /**
+   * The EndUser's email address for identification purposes.
+   */
+  email: string;
+
+  /**
+   * The EndUser's IntegrationConnections.
+   */
+  integrationConnections: Array<EndUser.IntegrationConnection>;
+
+  /**
+   * The type of object. This value is always `"end_user"`.
+   */
+  objectType: 'end_user';
+
+  /**
+   * The EndUser's unique identifier from your system. Maps users between your
+   * database and Conductor.
+   */
+  sourceId: string;
+}
+
+export namespace EndUser {
+  export interface IntegrationConnection {
+    /**
+     * The unique identifier for this IntegrationConnection.
+     */
+    id: string;
+
+    /**
+     * The date and time when this IntegrationConnection record was created.
+     */
+    createdAt: string;
+
+    /**
+     * The identifier of the third-party platform to integrate.
+     */
+    integrationSlug: 'quickbooks_desktop';
+
+    /**
+     * The date and time of your last API request to this IntegrationConnection.
+     */
+    lastRequestAt: string | null;
+
+    /**
+     * The date and time of your last _successful_ API request to this
+     * IntegrationConnection. A successful request means the integration fully
+     * processed and returned a response without any errors end-to-end.
+     */
+    lastSuccessfulRequestAt: string | null;
+
+    /**
+     * The type of object. This value is always `"integration_connection"`.
+     */
+    objectType: 'integration_connection';
+  }
+}
+
+export interface EndUserListResponse {
+  /**
+   * The array of EndUsers.
+   */
+  data: Array<EndUser>;
+
+  /**
+   * The type of object. This value is always `"list"`.
+   */
+  objectType: 'list';
+
+  /**
+   * The endpoint URL where this list can be accessed.
+   */
+  url: string;
+}
+
+export interface EndUserDeleteResponse {
+  /**
+   * The ID of the deleted EndUser.
+   */
+  id: string;
+
+  /**
+   * Indicates whether the EndUser was deleted.
+   */
+  deleted: boolean;
+
+  /**
+   * The type of object. This value is always `"end_user"`.
+   */
+  objectType: 'end_user';
+}
+
+/**
+ * The response from the integration connection.
+ */
+export type EndUserPassthroughResponse = Record<string, unknown>;
+
+export interface EndUserPingResponse {
+  /**
+   * The time, in milliseconds, that it took to ping the connection.
+   */
+  duration: number;
+}
+
+export interface EndUserCreateParams {
+  /**
+   * The end-user's company name that will be shown elsewhere in Conductor.
+   */
+  companyName: string;
+
+  /**
+   * The end-user's email address for identification purposes. Setting this field
+   * will not cause any emails to be sent.
+   */
+  email: string;
+
+  /**
+   * The end-user's unique identifier from your system. Maps users between your
+   * database and Conductor. Must be unique for each user. If you have only one user,
+   * you may use any string value.
+   */
+  sourceId: string;
+}
+
+export type EndUserPassthroughParams = Record<string, unknown>;
+
+export declare namespace EndUsers {
+  export {
+    type EndUser as EndUser,
+    type EndUserListResponse as EndUserListResponse,
+    type EndUserDeleteResponse as EndUserDeleteResponse,
+    type EndUserPassthroughResponse as EndUserPassthroughResponse,
+    type EndUserPingResponse as EndUserPingResponse,
+    type EndUserCreateParams as EndUserCreateParams,
+    type EndUserPassthroughParams as EndUserPassthroughParams,
+  };
+}

package/src/resources/index.ts

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { AuthSessions, type AuthSession, type AuthSessionCreateParams } from './auth-sessions';
+export {
+  EndUsers,
+  type EndUser,
+  type EndUserListResponse,
+  type EndUserDeleteResponse,
+  type EndUserPassthroughResponse,
+  type EndUserPingResponse,
+  type EndUserCreateParams,
+  type EndUserPassthroughParams,
+} from './end-users';
+export { Qbd } from './qbd/qbd';