connectwise-rest 0.23.3 → 1.0.0

package/generator/generator.d.ts

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,255 @@
+/* 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,
+}

package/generator/manage-generator.js

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs')
+const path = require('path')
+const { ESLint } = require('eslint')
+const { generateAPIClass } = require('./generator.js')
+const spec = require('./manage-json/manage.json')
+
+const eslint = new ESLint({ fix: true })
+
+async function generate() {
+  const {
+    paths,
+    components: { schemas },
+  } = spec
+
+  const tempFolder = path.join(__dirname, 'Manage')
+  const sections = {}
+
+  // generate temp directory
+  if (!fs.existsSync(tempFolder)) {
+    fs.mkdirSync(tempFolder)
+  }
+
+  Object.keys(paths).forEach((url) => {
+    const methods = paths[url]
+    const [_, section, ...rest] = url.split('/')
+
+    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: 'Manage' })
+    const fileName = path.join(tempFolder, `${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/Manage/**/*.ts'])
+  await ESLint.outputFixes(results)
+  const formatter = await eslint.loadFormatter('stylish')
+  const resultText = formatter.format(results)
+  console.log(resultText)
+
+  console.log('copying files to src/')
+  const files = fs.readdirSync(tempFolder)
+  files.forEach((file) => {
+    const manageFolder = path.join(__dirname, '../src', 'Manage')
+    if (!fs.existsSync(manageFolder)) {
+      fs.mkdirSync(manageFolder)
+    }
+    const src = path.join(tempFolder, file)
+    const dest = path.join(manageFolder, file)
+    console.log(`${src} ==> ${dest}`)
+    fs.copyFileSync(src, dest)
+  })
+  fs.rmSync(tempFolder, { recursive: true })
+  console.log('temp folder removed')
+}
+
+console.log('generating static Manage client files')
+generate().then(() => console.log('done'))

package/generator/manage-types.js

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const openapiTS = require('openapi-typescript')
+const fs = require('fs')
+const path = require('path')
+const spec = require('./manage-json/manage.json')
+
+const types = await openapiTS(spec)
+fs.writeFileSync(path.join(__dirname, 'manage-types.ts'), types)
+fs.copyFileSync(
+  path.join(__dirname, 'manage-types.ts'),
+  path.join(__dirname, '../src/ManageTypes.ts'),
+)
+fs.rmSync(path.join(__dirname, 'manage-types.ts'))
+console.log('done')

package/package.json

@@ -1,14 +1,26 @@
 {
   "name": "connectwise-rest",
-  "version": "0.23.3",
-  "description": "A nodejs module for interacting with the ConnectWise REST API.",
-  "main": "index.js",
+  "version": "1.0.0",
+  "description": "A nodejs module for interacting with the ConnectWise Manage and Automate REST APIs.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "nyc mocha",
-    "jsdoc": "jsdoc src -r -c ./docs/jsdoc.json -d docs",
-    "jsdocmd": "jsdoc2md src/**/*.js > doc.md",
-    "eslint": "eslint --ext .js src/",
-    "coveralls": "nyc report --reporter=text-lcov | coveralls"
+    "clean:docs": "npx rimraf docs/",
+    "clean:generator": "npx rimraf generator/Manage/*.ts generator/Automate/*.ts",
+    "clean:dist": "npx rimraf dist/",
+    "clean:src": "npx rimraf src/Manage/ & npx rimraf src/Automate/",
+    "clean": "npm run clean:dist & npm run clean:generator & npm run clean:src",
+    "test": "npx nyc mocha -r ts-node/register",
+    "pregenerate": "npm run clean",
+    "generate:automate": "node generator/automate-generator.js",
+    "generate:manage": "node generator/manage-generator.js",
+    "generate": "npm run generate:automate & npm run generate:manage",
+    "build": "npx tsc",
+    "postbuild": "npm run lint",
+    "lint": "npx eslint -c .eslintrc --fix",
+    "coveralls": "npx nyc report --reporter=text-lcov > ./.nyc_output/lcov.info",
+    "docs": "npx typedoc src/index.ts",
+    "gh-pages": "npx gh-pages -d docs"
   },
   "repository": {
     "type": "git",
@@ -16,6 +28,8 @@
   },
   "keywords": [
     "connectwise",
+    "connectwise manage",
+    "connectwise automate",
     "rest",
     "api",
     "nodejs"
@@ -30,23 +44,36 @@
   },
   "homepage": "https://github.com/covenanttechnologysolutions/connectwise-rest",
   "dependencies": {
-    "promise-retry": "^1.1.1",
-    "request": "^2.88.0"
+    "axios": "^0.26.1",
+    "promise-retry": "^2.0.1"
   },
   "devDependencies": {
-    "coveralls": "^3.0.3",
-    "dotenv": "^6.2.0",
-    "eslint": "^5.16.0",
-    "eslint-plugin-promise": "^4.0.1",
-    "jsdoc": "^3.6.3",
-    "jsdoc-to-markdown": "^5.0.0",
-    "lodash": "^4.17.15",
-    "mocha": "^5.2.0",
+    "@microsoft/api-documenter": "^7.16.0",
+    "@microsoft/api-extractor": "^7.19.5",
+    "@types/eslint": "^8.4.1",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.21",
+    "@types/promise-retry": "^1.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.15.0",
+    "@typescript-eslint/parser": "^5.15.0",
+    "coveralls": "^3.1.1",
+    "dotenv": "^16.0.0",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "gh-pages": "^3.2.3",
+    "lodash": "^4.17.21",
+    "mocha": "^9.2.2",
     "mocha-lcov-reporter": "^1.3.0",
-    "nyc": "^14.1.1",
-    "should": "^13.2.3"
+    "nyc": "^15.1.0",
+    "openapi-typescript": "^5.2.0",
+    "prettier": "^2.6.0",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.7.0",
+    "typedoc": "^0.22.13",
+    "typescript": "^4.6.2"
   },
   "engines": {
-    "node": ">=6.0.0"
+    "node": ">=16"
   }
 }

package/src/Automate/AVTemplatePoliciesAPI.ts

@@ -0,0 +1,114 @@
+/* This file was auto-generated, do not manually edit. */
+import Automate from '../Automate'
+import { components } from '../AutomateTypes'
+import { CommonParameters, CWAOptions } from '../AutomateAPI'
+import { NoContentResponse, OctetStreamResponse, PDFResponse, HTMLResponse } from '../types'
+type schemas = components['schemas']
+type requestBodies = components['requestBodies']
+export type LabTechModelsAVTemplatePolicy = schemas['LabTech.Models.AVTemplatePolicy']
+export type LabTechModelsAVTemplatePolicyData = schemas['LabTech.Models.AVTemplatePolicyData']
+export type LabTechModelsGroup = schemas['LabTech.Models.Group']
+export type LabTechModelsTemplateAvailableProperty =
+  schemas['LabTech.Models.TemplateAvailableProperty']
+export type LabTechModelsTemplateProperty = schemas['LabTech.Models.TemplateProperty']
+
+/**
+ * @public
+ */
+export default class AVTemplatePoliciesAPI extends Automate {
+  constructor(props: CWAOptions) {
+    super(props)
+  }
+
+  getAntivirusTemplatePolicyList(params: CommonParameters = {}): Promise<object> {
+    return this.request({
+      path: `/api/v1/AVTemplatePolicies`,
+      method: 'get',
+      params,
+    })
+  }
+
+  postAntivirusTemplatePolicy(
+    AVTemplatePolicy: LabTechModelsAVTemplatePolicy,
+  ): Promise<LabTechModelsAVTemplatePolicy> {
+    return this.request({
+      path: `/api/v1/AVTemplatePolicies`,
+      method: 'post',
+      data: AVTemplatePolicy,
+    })
+  }
+
+  getAntivirusTemplatePolicyDataList(params: CommonParameters = {}): Promise<object> {
+    return this.request({
+      path: `/api/v1/AVTemplatePolicyData`,
+      method: 'get',
+      params,
+    })
+  }
+
+  postAntivirusTemplatePolicyData(
+    AVTemplatePolicyData: LabTechModelsAVTemplatePolicyData,
+  ): Promise<LabTechModelsAVTemplatePolicyData> {
+    return this.request({
+      path: `/api/v1/AVTemplatePolicyData`,
+      method: 'post',
+      data: AVTemplatePolicyData,
+    })
+  }
+
+  getGroupList(params: CommonParameters = {}): Promise<Array<LabTechModelsGroup>> {
+    return this.request({
+      path: `/api/v1/Groups`,
+      method: 'get',
+      params,
+    })
+  }
+
+  postGroup(Group: LabTechModelsGroup): Promise<LabTechModelsGroup> {
+    return this.request({
+      path: `/api/v1/Groups`,
+      method: 'post',
+      data: Group,
+    })
+  }
+
+  getTemplateAvailablePropertyList(
+    params: CommonParameters = {},
+  ): Promise<Array<LabTechModelsTemplateAvailableProperty>> {
+    return this.request({
+      path: `/api/v1/TemplateAvailableProperties`,
+      method: 'get',
+      params,
+    })
+  }
+
+  postTemplateAvailableProperty(
+    TemplateAvailableProperty: LabTechModelsTemplateAvailableProperty,
+  ): Promise<LabTechModelsTemplateAvailableProperty> {
+    return this.request({
+      path: `/api/v1/TemplateAvailableProperties`,
+      method: 'post',
+      data: TemplateAvailableProperty,
+    })
+  }
+
+  getTemplatePropertyList(
+    params: CommonParameters = {},
+  ): Promise<Array<LabTechModelsTemplateProperty>> {
+    return this.request({
+      path: `/api/v1/TemplateProperties`,
+      method: 'get',
+      params,
+    })
+  }
+
+  postTemplateProperty(
+    TemplateProperty: LabTechModelsTemplateProperty,
+  ): Promise<LabTechModelsTemplateProperty> {
+    return this.request({
+      path: `/api/v1/TemplateProperties`,
+      method: 'post',
+      data: TemplateProperty,
+    })
+  }
+}