connectwise-rest 0.23.3 → 1.0.0

package/src/index.ts

@@ -0,0 +1,18 @@
+import ManageAPI, { CWMOptions, CommonParameters, PatchOperation } from './ManageAPI'
+import AutomateAPI, { CWAOptions } from './AutomateAPI'
+import type * as types from './types'
+import * as utils from './utils'
+import * as AutomateAPIs from './AutomateAPI'
+import * as ManageAPIs from './ManageAPI'
+
+export type {
+  AutomateAPIs,
+  ManageAPIs,
+  CWMOptions,
+  CommonParameters,
+  PatchOperation,
+  CWAOptions,
+  types,
+}
+
+export { AutomateAPI, ManageAPI, utils }

package/src/types.ts

@@ -0,0 +1,66 @@
+import * as ManageAPI from './ManageAPI'
+
+export enum StatusCode {
+  OK = 200,
+  Created = 201,
+  Accepted = 202,
+  NoContent = 204,
+  MovedPermanently = 301,
+  BadRequest = 400,
+  Unauthorized = 401,
+  Forbidden = 403,
+  NotFound = 404,
+  TooManyRequests = 429,
+  InternalServerError = 500,
+  BadGateway = 502,
+  ServiceUnavailable = 503,
+  GatewayTimeout = 504,
+}
+
+export type Methods = 'get' | 'put' | 'delete' | 'post' | 'patch'
+
+export type RetryOptions = {
+  minTimeout: number
+  retries: number
+  maxTimeout: number
+  randomize: boolean
+  factor?: number
+}
+
+export type RequestOptions = {
+  path: string
+  method?: Methods
+  params?: Record<string, unknown>
+  data?:
+    | Record<string, unknown>
+    | Record<string, unknown>[]
+    | PatchOperation[]
+    | null
+    | string
+    | number
+    | undefined
+}
+
+export type LoggingLevels = 'error' | 'warn' | 'info' | 'debug'
+export type CWLogger = (level: LoggingLevels, text: string, meta?: Record<string, unknown>) => void
+
+export type DataResponse =
+  | Record<string, unknown>
+  | Record<string, unknown>[]
+  | string
+  | number
+  | null
+  | undefined
+
+export type ErrorResponse = {
+  status: number | string
+  data: DataResponse
+  message: string
+}
+
+// missing types from api spec
+export type NoContentResponse = undefined
+export type OctetStreamResponse = Buffer
+export type PDFResponse = Blob
+export type HTMLResponse = string
+export type PatchOperation = ManageAPI.PatchOperation

package/src/utils/Callback.ts

@@ -0,0 +1,145 @@
+/*
+ * Created by kgrube on 4/3/2019
+ */
+import axios from 'axios'
+import crypto from 'crypto'
+import type { ClientRequest, ServerResponse } from 'http'
+
+export interface ExpressRequest extends ClientRequest {
+  body: CallbackPayload
+  headers: Record<string, string>
+}
+
+export type CallbackPayload = {
+  Action: string
+  CompanyId: string | number
+  Entity: string
+  FromUrl: string
+  ID: string | number
+  MemberId: string | number
+  Metadata: {
+    key_url: string
+  }
+  Type: string
+}
+
+export type Entity = Record<string, unknown> | Array<Record<string, unknown>>
+
+/**
+ * Load signing key and verify the message
+ * @param callbackBody -
+ * @param contentSignature - base64 content signature req.headers[x-content-signature]
+ * @returns verifies callback signature
+ * @public
+ */
+export function verifyCallback(
+  callbackBody: CallbackPayload,
+  contentSignature: string,
+): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    if (!callbackBody || !contentSignature) {
+      throw new Error('callbackBody and contentSignature must be defined.')
+    }
+
+    const key_url = callbackBody.Metadata && callbackBody.Metadata.key_url
+
+    axios
+      .get(key_url)
+      .then((response) => {
+        const body = response.data
+        try {
+          const parsed = JSON.parse(body)
+          const signingKey = parsed.signing_key
+
+          return resolve(verifyMessage(callbackBody, contentSignature, signingKey))
+        } catch (parseErr) {
+          return reject(parseErr)
+        }
+      })
+      .catch((err) => reject(err))
+  })
+}
+
+/**
+ * Validate a callback body against signed key
+ * @param callbackBody -
+ * @param contentSignature -
+ * @param signingKey -
+ * @returns boolean if verified
+ * @public
+ */
+export function verifyMessage(
+  callbackBody: CallbackPayload,
+  contentSignature: string,
+  signingKey: string,
+): boolean {
+  const hash = crypto.createHash('sha256').update(signingKey).digest()
+  const hmac = crypto.createHmac('sha256', hash)
+
+  return contentSignature === hmac.update(JSON.stringify(callbackBody)).digest('base64')
+}
+
+/**
+ *
+ * @example
+ * Express style middleware
+ * ```
+ * app.post('/your/api', cw.utils.middleware((err, req, res, verified, payload) => {
+ *  if (err) {
+ *    //handle error
+ *    res.status(500).end();
+ *  } else if (!verified) {
+ *    // send 403 on verification failure
+ *    res.status(403).end();
+ *  } else {
+ *    res.status(200).end()
+ *  }
+ *  const {action, id} = req.query;
+ *  // do something with the payload
+ * }));
+ * ```
+ *
+ * @param cb - callback(err, req, res, verified, payload)
+ * @public
+ */
+export function middleware(
+  cb: (
+    err: Error | null,
+    req: ExpressRequest,
+    res: ServerResponse,
+    verified: boolean,
+    payload: Entity | undefined,
+  ) => void,
+) {
+  if (!cb || typeof cb !== 'function') {
+    throw new Error('callback must be a function.')
+  }
+
+  return (req: ExpressRequest, res: ServerResponse) => {
+    if (!req || !req.body || !req.body.Metadata) {
+      return cb(new Error('callback payload is invalid.'), req, res, false, undefined)
+    }
+
+    const contentSignature = req.headers['x-content-signature']
+    const callbackBody = req.body
+
+    let parsedEntity: Entity
+    try {
+      parsedEntity = JSON.parse(callbackBody.Entity)
+    } catch (parseErr) {
+      if (parseErr instanceof Error) {
+        return cb(parseErr, req, res, false, undefined)
+      }
+    }
+
+    verifyCallback(callbackBody, contentSignature)
+      .then((verified) => {
+        return cb(null, req, res, verified, Object.assign(callbackBody, { Entity: parsedEntity }))
+      })
+      .catch((err) => {
+        return cb(err, req, res, false, undefined)
+      })
+  }
+}
+
+export default { middleware, verifyCallback, verifyMessage }

package/src/utils/Series.ts

@@ -0,0 +1,83 @@
+/**
+ * Created by kgrube on 4/3/2019
+ */
+import { types } from 'util'
+const isPromise = types.isPromise
+
+export type PromiseLikeFunction =
+  | (() => Promise<unknown>)
+  | Promise<unknown>
+  | (() => unknown)
+  | { then: () => void }
+
+export type SeriesOptions = {
+  series: Array<PromiseLikeFunction>
+  concurrent?: number
+  delay?: number
+}
+
+/**
+ *
+ * @param options - options object
+ * @param options.series - functions or promises to be executed
+ * @param options.concurrent - number of concurrent requests
+ * @param options.delay - number of ms between request groups
+ * @returns array of promise results
+ * @public
+ *
+ * @example
+ * ```javascript
+ *    const results = await Series.all({
+ *      series: [
+ *        () => true,
+ *        new Promise((resolve) => resolve(true),
+ *        () => new Promise((resolve) => resolve(true)
+ *      ],
+ *      concurrent: 3,
+ *      delay: 10,
+ *    })
+ * ```
+ */
+function all({ series = [], concurrent = 1, delay = 0 }: SeriesOptions): Promise<Array<unknown>> {
+  const promises = series.slice()
+  const concurrency = concurrent
+  let results: Array<unknown> | null = null
+
+  return new Promise((resolve, reject) => {
+    function next(result?: unknown) {
+      const concurrentPromises: PromiseLikeFunction[] = []
+
+      if (!results) {
+        results = []
+      } else {
+        results = results.concat(result)
+      }
+
+      if (promises.length) {
+        while (concurrentPromises.length < concurrency && promises.length) {
+          let promise = promises.shift()
+
+          if (typeof promise === 'function') {
+            promise = <PromiseLikeFunction>promise()
+          }
+
+          if (!promise || !isPromise(promise)) {
+            promise = Promise.resolve(promise)
+          }
+
+          concurrentPromises.push(promise)
+        }
+
+        setTimeout(() => Promise.all(concurrentPromises).then(next).catch(reject), delay)
+      } else {
+        resolve(results)
+      }
+    }
+
+    next()
+  })
+}
+
+const Series = { all }
+
+export default Series

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+import type * as SeriesTypes from './Series'
+import type * as CallbackTypes from './Callback'
+import Series from './Series'
+import Callback from './Callback'
+
+export type { SeriesTypes, CallbackTypes }
+export { Series, Callback }

package/swagger-errors.md

@@ -0,0 +1,30 @@
+# API Spec Errors
+
+## Automate
+
+**System
+
+## Manage
+
+**Company.deleteCompanyContactsById**
+
+Defines `transferContactId` as path variable but does not specify location in path
+
+**Company.postCompanyCompanyPickerItemsClear**
+
+Specifies `clearPickerRequest` as query variable but probably should be `body` variable.
+
+
+**Project.postProjectTicketNoteByIdMarkAs**
+
+Missing return type
+
+**System.getSystemAudittrail &**
+**System.getSystemAudittrailCount**
+
+Operation name Audittrail typo  
+getRequest specified as path but should be query
+
+**System.getSystemWorkflowsByParentIdEventsByIdTest**
+
+Missing return type

package/test/.env.example

@@ -1,4 +1,12 @@
-API_COMPANY=
-API_URL=
-API_PUBLIC_KEY=
-API_PRIVATE_KEY=
+MANAGE_API_COMPANY=
+MANAGE_API_URL=
+MANAGE_API_PUBLIC_KEY=
+MANAGE_API_PRIVATE_KEY=
+MANAGE_API_CLIENT_ID=
+
+AUTOMATE_API_URL=
+AUTOMATE_API_USER=
+AUTOMATE_API_PASSWORD=
+AUTOMATE_API_CLIENT_ID=
+
+COVERALLS_REPO_TOKEN=

package/test/test-utils.ts

@@ -0,0 +1,27 @@
+export type PromiseArray<T> = Array<Promise<T>>
+
+export function isPromise(input: unknown): input is Promise<unknown> {
+  return (
+    !!input &&
+    (typeof input === 'object' || typeof input === 'function') &&
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    typeof input.then === 'function'
+  )
+}
+
+export function isPromiseType(input: unknown): input is Promise<unknown> {
+  return isPromise(input)
+}
+
+export function isArrayOfPromises(input: unknown): input is PromiseArray<unknown> {
+  if (Array.isArray(input)) {
+    if (Array.length === 0) {
+      return true
+    }
+    if (isPromise(input.pop)) {
+      return true
+    }
+  }
+  return false
+}