connectwise-rest 1.0.0 → 1.0.1

package/test/test.ts

@@ -8,9 +8,9 @@ import { ManageAPI, AutomateAPI, utils } from '../dist/index'
 import assert from 'assert'
 import { describe, it } from 'mocha'
 import type { components } from '../src/ManageTypes'
-import { isArrayOfPromises, PromiseArray } from './test-utils'
 import { isPromise } from './test-utils'
-import ComputersAPI, { LabTechModelsComputer } from '../src/Automate/ComputersAPI'
+import { LabTechModelsComputer } from '../src/Automate/ComputersAPI'
+import { CommunicationType } from '../src/Manage/CompanyAPI'
 type Ticket = components['schemas']['Ticket']
 
 dotenv.config({ path: path.join(__dirname, '.env') })
@@ -136,8 +136,8 @@ describe('Automate', () => {
       assert(cwa.SystemAPI)
       done()
     })
-    it('should have TicketAPI', (done) => {
-      assert(cwa.TicketAPI)
+    it('should have TicketsAPI', (done) => {
+      assert(cwa.TicketsAPI)
       done()
     })
     it('should have UserProfilesAPI', (done) => {
@@ -156,7 +156,7 @@ describe('Automate', () => {
           assert(computer.ComputerName)
           done()
         })
-        .catch((error: any) => done(error))
+        .catch((error) => done(error))
     })
   })
 })
@@ -261,6 +261,35 @@ describe('Manage', () => {
       })
     })
   })
+
+  describe('pagination', () => {
+    it('should return an array of CommunicationTypes', (done) => {
+      cwm
+        .paginate(cwm.CompanyAPI.getCompanyCommunicationTypes, { pageSize: 2, startPage: 1 }, {})
+        .then((results) => {
+          assert(Array.isArray(results))
+          assert(results.length > 0)
+          const firstType = <CommunicationType>results.pop()
+          assert(firstType.id)
+          assert(firstType.description)
+          assert(firstType._info)
+          done()
+        })
+        .catch((err) => done(err))
+    })
+
+    it('should return the same number of items', (done) => {
+      cwm
+        .paginate(cwm.CompanyAPI.getCompanyCommunicationTypes, { pageSize: 2, startPage: 1 }, {})
+        .then((pagedResults) => {
+          return cwm.CompanyAPI.getCompanyCommunicationTypes().then((unPagedResults) => {
+            assert(unPagedResults.length === pagedResults.length)
+            done()
+          })
+        })
+        .catch((err) => done(err))
+    })
+  })
 })
 
 describe('utils', () => {

package/.github/workflows/codeql-analysis.yml

@@ -1,70 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master, dev ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master, dev ]
-  schedule:
-    - cron: '20 19 * * 4'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript', 'typescript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://git.io/codeql-language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

package/.github/workflows/node.js.yml

@@ -1,42 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ master, dev ]
-  pull_request:
-    branches: [ master, dev ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [12.x, 14.x, 16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test
-      env:
-        MANAGE_API_COMPANY: ${{ secrets.MANAGE_API_COMPANY }}
-        MANAGE_API_URL: ${{ secrets.MANAGE_API_URL }}
-        MANAGE_API_PUBLIC_KEY: ${{ secrets.MANAGE_API_PUBLIC_KEY }}
-        MANAGE_API_PRIVATE_KEY: ${{ secrets.MANAGE_API_PRIVATE_KEY }}
-        MANAGE_API_CLIENT_ID: ${{ secrets.MANAGE_API_CLIENT_ID }}
-
-        AUTOMATE_API_URL: ${{ secrets.AUTOMATE_API_URL }}
-        AUTOMATE_API_USER: ${{ secrets.AUTOMATE_API_USER }}
-        AUTOMATE_API_PASSWORD: ${{ secrets.AUTOMATE_API_PASSWORD }}
-        AUTOMATE_API_CLIENT_ID: ${{ secrets.AUTOMATE_API_CLIENT_ID }}

package/.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-  - "8"
-  - "10"
-  - "12"
-  - "14"
-  - "16"
-after_script:
-  - npm run coveralls
-before_script:
-  - npm run build

package/generator/automate-generator.js

@@ -1,75 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { getAutomateJson } = require('./automate-json')
-const path = require('path')
-const fs = require('fs')
-const { ESLint } = require('eslint')
-const { generateAPIClass } = require('./generator')
-
-const eslint = new ESLint({ fix: true })
-
-async function generate() {
-  const automate = getAutomateJson()
-  const {
-    paths,
-    components: { schemas },
-  } = automate
-
-  const sections = {}
-
-  const automateTempFolder = path.join(__dirname, 'Automate')
-
-  if (!fs.existsSync(automateTempFolder)) {
-    fs.mkdirSync(automateTempFolder)
-  }
-
-  Object.keys(paths).forEach((url) => {
-    const methods = paths[url]
-    const section = paths[url][Object.keys(methods).pop()].section
-
-    if (!sections[section]) {
-      sections[section] = []
-    }
-
-    sections[section].push({ url, methods })
-  })
-
-  for (const section of Object.keys(sections)) {
-    const apiName = section.charAt(0).toUpperCase() + section.slice(1)
-    const operations = sections[section]
-
-    const file = generateAPIClass({ apiName, operations, generatorType: 'Automate' })
-    const fileName = path.join(automateTempFolder, `${apiName}API.ts`)
-
-    if (fs.existsSync(fileName)) {
-      fs.rmSync(fileName)
-    }
-
-    console.log('Creating file', fileName)
-    fs.writeFileSync(fileName, file)
-  }
-
-  console.log('running eslint')
-  const results = await eslint.lintFiles(['generator/Automate/**/*.ts'])
-  await ESLint.outputFixes(results)
-  const formatter = await eslint.loadFormatter('stylish')
-  const resultText = formatter.format(results)
-  console.log('eslint results', resultText)
-
-  console.log('copying files to src/')
-  const files = fs.readdirSync(path.join(__dirname, 'Automate'))
-  files.forEach((file) => {
-    const automateFolder = path.join(__dirname, '../src', 'Automate')
-    if (!fs.existsSync(automateFolder)) {
-      fs.mkdirSync(automateFolder)
-    }
-    const src = path.join(automateTempFolder, file)
-    const dest = path.join(automateFolder, file)
-    console.log(`${src} ==> ${dest}`)
-    fs.copyFileSync(src, dest)
-  })
-  fs.rmSync(automateTempFolder, { recursive: true })
-  console.log('temp folder removed')
-}
-
-console.log('generating static Automate client files')
-generate().then(() => console.log('done'))

package/generator/automate-json.js

@@ -1,61 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const fs = require('fs')
-const path = require('path')
-
-/**
- * @internal
- */
-function getAutomateJson() {
-  const sections = []
-
-  const files = fs.readdirSync(path.join(__dirname, 'automate-json'))
-  files.forEach((fileName) => {
-    const section = require(path.join(__dirname, 'automate-json', fileName))
-
-    Object.keys(section.paths).forEach((path) => {
-      Object.keys(section.paths[path]).forEach((method) => {
-        const definition = section.paths[path][method]
-        const operationId = definition.operationId.split('_').pop()
-        section.paths[path][method] = {
-          ...definition,
-          // manually define api section
-          // clean up operation names
-          operationId: operationId.charAt(0).toLowerCase() + operationId.slice(1),
-          section: fileName.replace('.json', ''),
-        }
-      })
-    })
-    sections.push(section)
-  })
-
-  const automate = {
-    openapi: '',
-    info: {},
-    components: {
-      requestBodies: {},
-      schemas: {},
-    },
-    paths: {},
-  }
-
-  sections.forEach((section) => {
-    const {
-      openapi,
-      info,
-      components: { requestBodies, schemas },
-      paths,
-    } = section
-
-    automate.openapi = openapi
-    automate.info = { ...info }
-    automate.components.requestBodies = { ...requestBodies, ...automate.components.requestBodies }
-    automate.components.schemas = { ...schemas, ...automate.components.schemas }
-    automate.paths = { ...paths, ...automate.paths }
-  })
-
-  return automate
-}
-
-module.exports = {
-  getAutomateJson,
-}

package/generator/automate-types.js

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const openapiTS = require('openapi-typescript')
-const fs = require('fs')
-const path = require('path')
-const { getAutomateJson } = require('./automate-json.js')
-
-const automate = await getAutomateJson()
-const types = await openapiTS(automate)
-fs.writeFileSync(path.join(__dirname, 'AutomateTypes.ts'), types)
-fs.copyFileSync(
-  path.join(__dirname, 'AutomateTypes.ts'),
-  path.join(__dirname, '../src/Automate/AutomateTypes.ts'),
-)
-fs.rmSync(path.join(__dirname, 'AutomateTypes.ts'))
-console.log('done')

package/generator/generator.d.ts

@@ -1,67 +0,0 @@
-type Method = 'get' | 'post' | 'patch' | 'delete' | 'put'
-type ResponseTypes =
-  | 'application/json'
-  | 'text/json'
-  | 'application/xml'
-  | 'text/xml'
-  | 'application/x-www-form-urlencoded'
-
-type Content = {
-  [T in ResponseTypes]: {
-    schema: Schema
-  }
-}
-
-type RequestBody = {
-  required?: boolean
-  content: Content
-}
-
-type Responses = {
-  200?: {
-    description: string
-    content: Content
-  }
-  204?: {
-    description: string
-    content: Content
-  }
-}
-
-type Schema = {
-  type: string
-  enum?: Array<string>
-  format?: string
-  items?: {
-    type?: string
-    $ref?: string
-  }
-}
-
-type Parameter = {
-  name: string
-  in: string
-  required?: boolean
-  explode?: boolean
-  schema?: Schema
-}
-
-type Methods = {
-  [T in Method]: Operation
-}
-
-type Operation = {
-  tags?: Array<string>
-  method: string
-  operationId: string
-  parameters: Array<Parameter>
-  requestBody: {
-    $ref: string
-  }
-  responses: Responses
-}
-
-type Components = {
-  schemas: Record<string, Schema>
-  requestBodies: Record<string, RequestBody>
-}

package/generator/generator.js

@@ -1,255 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { getAutomateJson } = require('./automate-json')
-
-const automateSchema = getAutomateJson()
-
-const typeMapSanitize = (input = '') => {
-  switch (input) {
-    case 'integer':
-      return 'number'
-    case 'application/octet-stream':
-      return 'OctetStreamResponse'
-    case 'application/pdf':
-      return 'PDFResponse'
-    case 'text/html':
-      return 'HTMLResponse'
-    default:
-      return sanitizeType(input)
-  }
-}
-
-// remove invalid var name from the name of the type
-const sanitizeType = (input = '') => input.replace(/\./g, '').replace(/\//g, '')
-const generateTypeDef = ({ typeName, schemaType }) => {
-  let name = sanitizeType(typeName)
-
-  return schemaType === 'schemas'
-    ? `export type ${name} = schemas['${typeName}']`
-    : `export type ${name} = requestBodies['${typeName}']`
-}
-
-/**
- * @typedef {object} Operations
- * @property {string} url
- * @property {{}} methods
- */
-
-/**
- * decipher supplied definition files
- * @param {{}} options
- * @param {string} options.apiName
- * @param {} options.operations
- * @param {'Manage' | 'Automate'} options.generatorType
- */
-function generateAPIClass({ apiName, operations = [], generatorType }) {
-  // types holder for generating type aliases
-  // type Types = Record<string, string>
-  // system name, sanitized name
-  const types = {}
-  const requestBodies = {}
-
-  // loop over each defined operation for this module
-  const functions = operations.map(({ url, methods }) =>
-    Object.keys(methods)
-      .map((method) => {
-        const { responses, operationId, parameters = [], requestBody } = methods[method]
-        const queryParams = parameters.filter(({ in: in_ }) => in_ === 'query')
-        const pathParams = parameters.filter(({ in: in_ }) => in_ === 'path')
-
-        // store generated names/types
-        const functionParams = [] // args to the class function
-        const requestParams = [] // args to this.request
-        let bodyParam = {}
-
-        // generally if a post command is defined
-        if (requestBody) {
-          if (requestBody.content && requestBody.content['application/json']) {
-            const schema = requestBody.content['application/json'].schema
-            if (schema.type === 'array') {
-              if (schema.items) {
-                const ref = schema.items.$ref
-                const tempName = ref.split('/').pop()
-                bodyParam.type = `Array<${tempName}>`
-                bodyParam.name = tempName.charAt(0).toLowerCase() + tempName.slice(1) + 's'
-
-                types[tempName] = {
-                  schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-                }
-              }
-            } else if (schema.$ref) {
-              const ref = schema.$ref
-              bodyParam.type = ref.split('/').pop()
-              if (requestBody.description) {
-                bodyParam.name = requestBody.description
-              } else {
-                bodyParam.name = ref.split('.').pop()
-              }
-              types[bodyParam.type] = {
-                schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-              }
-              // if clause for MonitorAlertSuspensions_PostSuspension
-            } else if (!schema.description) {
-              bodyParam.type = schema.type
-              bodyParam.name = schema.type
-            }
-          } else if (requestBody.content && requestBody.content['multipart/form-data']) {
-            const schema = requestBody.content['multipart/form-data'].schema
-            if (schema.$ref) {
-              const ref = schema.$ref
-              bodyParam.type = ref.split('/').pop()
-              bodyParam.name = bodyParam.type.charAt(0).toLowerCase() + bodyParam.type.slice(1)
-              types[bodyParam.type] = {
-                schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-              }
-            }
-          } else if (requestBody.$ref) {
-            const ref = requestBody.$ref
-            // make sensible names by splitting the generated refs
-            bodyParam.name = requestBody.$ref.split('/').pop().split('.').pop().split('_').pop()
-            bodyParam.type = requestBody.$ref.split('/').pop()
-            types[bodyParam.type] = {
-              schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-            }
-          } else {
-            bodyParam.name = requestBody.description
-            bodyParam.type = 'object'
-          }
-
-          bodyParam.name = sanitizeType(bodyParam.name)
-        }
-
-        if (pathParams.length > 0) {
-          pathParams.forEach((parameter) => {
-            functionParams.push(`${parameter.name}: ${typeMapSanitize(parameter.schema.type)}`)
-          })
-        }
-        requestParams.push(`path: \`${url.replaceAll(/({.+?})/g, (_, p1) => `$${p1}`)}\``)
-        requestParams.push(`method: '${method}'`)
-
-        if (requestBody) {
-          functionParams.push(`${bodyParam.name}: ${typeMapSanitize(bodyParam.type)}`)
-          requestParams.push(`data: ${bodyParam.name}`)
-        }
-
-        if (queryParams.length > 0) {
-          functionParams.push('params: CommonParameters = {}')
-          requestParams.push(`params`)
-        }
-        let returnType
-        if (responses[204]) {
-          returnType = 'NoContentResponse'
-        } else {
-          const { description, content } = responses[Object.keys(responses).pop()]
-
-          if (responses['default']) {
-            returnType = 'any'
-            if (responses['default'].description) {
-              returnType = `${returnType}`
-            }
-          } else if (content) {
-            const { schema } = content[Object.keys(content).pop()]
-
-            if (schema.items) {
-              if (schema.items.$ref) {
-                const ref = schema.items.$ref
-                const tempName = ref.split('/').pop()
-                returnType = `Array<${tempName}>`
-                types[tempName] = {
-                  schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-                }
-              } else if (schema.items.additionalProperties?.$ref) {
-                const ref = schema.items.additionalProperties.$ref
-                const tempName = ref.split('/').pop()
-                returnType = `Array<${tempName}>`
-                types[tempName] = {
-                  schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-                }
-              } else if (schema.type) {
-                if (schema.items.type) {
-                  returnType = `Array<${schema.items.type}>`
-                } else {
-                  returnType = schema.type
-                }
-              }
-            } else if (schema.$ref) {
-              const ref = schema.$ref
-              // fix for incorrect types from ResultSetWithCount
-              if (ref.includes('LabTech.Database.ResultSetWithCount')) {
-                const schemaName = ref.split('/').pop()
-                const resultSchema = automateSchema.components.schemas[schemaName]
-                const ResultSetRef = resultSchema.properties.ResultSet.items.$ref
-                const tempName = ResultSetRef.split('/').pop()
-                returnType = `Array<${tempName}>`
-                types[tempName] = {
-                  schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-                }
-              } else {
-                returnType = schema.$ref.split('/').pop()
-                types[returnType] = {
-                  schemaType: ref.includes('requestBodies') ? 'requestBody' : 'schemas',
-                }
-              }
-            } else {
-              returnType = schema.type
-            }
-          } else {
-            returnType = description.split(' ').pop()
-          }
-        }
-
-        returnType = typeMapSanitize(returnType)
-
-        if (!returnType) {
-          returnType = 'any'
-        }
-
-        return `
-   ${operationId}(${functionParams.map((param) => param).join(', ')}): Promise<${returnType}> {
-    return this.request({
-      ${requestParams.map((param) => param).join(', ')}
-    })
-   }`
-      })
-      .join('\n'),
-  )
-
-  // use true/false map to generate required types for this module
-  const typeDefs = Object.keys(
-    // sort keys to order imports
-    Object.keys(types)
-      .sort()
-      .reduce((obj, key) => {
-        obj[key] = types[key]
-        return obj
-      }, {}),
-  ).map((type) => generateTypeDef({ typeName: type, schemaType: types[type].schemaType }))
-
-  return `/* This file was auto-generated, do not manually edit. */
-import ${generatorType} from '../${generatorType}'
-import { components } from '../${generatorType}Types'
-${
-  generatorType === 'Manage'
-    ? "import { CommonParameters, CWMOptions } from '../ManageAPI'"
-    : "import { CommonParameters, CWAOptions } from '../AutomateAPI'"
-}
-import { NoContentResponse, OctetStreamResponse, PDFResponse, HTMLResponse } from '../types'
-type schemas = components['schemas']
-${generatorType === 'Automate' ? `type requestBodies = components['requestBodies']` : ''}
-${typeDefs.join('\n')}
-
-/**
- * @public
- */
-export default class ${apiName}API extends ${generatorType} {
-  constructor(props: ${generatorType === 'Manage' ? 'CWMOptions' : 'CWAOptions'}) {
-    super(props)
-  }
-
-  ${functions.join('\n')}
-}
-  `
-}
-
-module.exports = {
-  generateAPIClass,
-}