@itentialopensource/adapter-utils 4.44.9

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@itentialopensource/adapter-utils",
+  "version": "4.44.9",
+  "description": "Itential Adapter Utility Libraries",
+  "scripts": {
+    "preinstall": "node utils/setup.js",
+    "lint": "eslint . --ext .json --ext .js",
+    "lint:errors": "eslint --quiet . --ext .json --ext .js",
+    "test:unit": "mocha test/unit/lib/requestHandlerTest.js --LOG=error && mocha test/unit/lib/restHandlerTest.js --LOG=error && mocha test/unit/lib/propertyUtilTest.js --LOG=error && mocha test/unit/lib/translatorUtilTest.js --LOG=error && mocha test/unit/lib/dbUtilTest.js --LOG=error",
+    "test:integration": "mocha test/integration/lib/requestHandlerTest.js --LOG=error && mocha test/integration/lib/restHandlerTest.js --LOG=error",
+    "test:cover": "nyc --reporter html --reporter text mocha --recursive --reporter dot test/*",
+    "test": "npm run test:unit && npm run test:integration",
+    "deploy": "npm publish --registry=http://registry.npmjs.org --access=public",
+    "build": "npm run deploy"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">= 8.0.0",
+    "npm": ">= 6.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.com:itentialopensource/adapter-utils.git"
+  },
+  "author": "Itential",
+  "homepage": "https://gitlab.com/itentialopensource/adapter-utils#readme",
+  "dependencies": {
+    "ajv": "^6.12.0",
+    "async-lock": "1.2.0",
+    "cookie": "^0.4.0",
+    "crypto-js": "^3.1.9-1",
+    "ejs": "^2.7.1",
+    "form-data": "^2.5.1",
+    "fs-extra": "^8.1.0",
+    "https-proxy-agent": "^2.2.1",
+    "json-query": "^2.2.2",
+    "jsontoxml": "^1.0.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongodb": "^3.3.3",
+    "querystring": "^0.2.0",
+    "readline-sync": "^1.4.10",
+    "socks-proxy-agent": "^4.0.2",
+    "uuid": "^8.3.2",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {
+    "chai": "^4.3.4",
+    "eslint": "^7.29.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.23.4",
+    "eslint-plugin-json": "^3.0.0",
+    "mocha": "^9.0.1",
+    "nyc": "^15.1.0",
+    "strip-ansi": "^7.0.0",
+    "strip-ansi-cli": "^3.0.1",
+    "testdouble": "^3.16.1",
+    "winston": "^3.3.3"
+  },
+  "peerDependencies": {},
+  "private": false
+}

package/propertiesSchema.json

@@ -0,0 +1,840 @@
+{
+  "$id": "adapter-systemx",
+  "type": "object",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "properties": {
+    "host": {
+      "type": "string",
+      "description": "hostname of the server",
+      "default": "",
+      "examples": [
+        "systemx.customer.com"
+      ]
+    },
+    "port": {
+      "type": "integer",
+      "description": "port on which to connect to the server",
+      "default": 443,
+      "minimum": 1,
+      "maximum": 65535
+    },
+    "base_path": {
+      "type": "string",
+      "description": "a base path that is consistent across api calls",
+      "default": "",
+      "examples": [
+        "/system/api"
+      ]
+    },
+    "version": {
+      "type": "string",
+      "description": "api version this adapter integrates with",
+      "default": "",
+      "examples": [
+        "v1",
+        "v2.6",
+        "4.5.1"
+      ]
+    },
+    "cache_location": {
+      "type": "string",
+      "description": "Where cache of information should be located redis or local memory",
+      "default": "none",
+      "enum": [
+        "redis",
+        "local",
+        "none"
+      ]
+    },
+    "encode_pathvars": {
+      "type": "boolean",
+      "description": "When true the path variables are encoded in the url",
+      "default": true
+    },
+    "save_metric": {
+      "type": [
+        "boolean",
+        "string"
+      ],
+      "description": "When true the metrics collected by the adapter will be stored in mongo or in the adapter. If a full path is provided, metrics will be saved in the path provided.",
+      "default": false
+    },
+    "stub": {
+      "type": "boolean",
+      "description": "When true will not connect to the remote server, but will use a static object for all responses",
+      "default": false
+    },
+    "protocol": {
+      "type": "string",
+      "description": "the protocol to use to connect to server",
+      "default": "http",
+      "enum": [
+        "http",
+        "https"
+      ]
+    },
+    "authentication": {
+      "$ref": "#/definitions/authentication"
+    },
+    "healthcheck": {
+      "$ref": "#/definitions/healthcheck"
+    },
+    "throttle": {
+      "$ref": "#/definitions/throttle"
+    },
+    "request": {
+      "$ref": "#/definitions/request"
+    },
+    "proxy": {
+      "$ref": "#/definitions/proxy"
+    },
+    "ssl": {
+      "$ref": "#/definitions/ssl"
+    },
+    "mongo": {
+      "$ref": "#/definitions/mongo"
+    }
+  },
+  "required": [
+    "host",
+    "port",
+    "authentication",
+    "healthcheck"
+  ],
+  "definitions": {
+    "authentication": {
+      "type": "object",
+      "properties": {
+        "auth_method": {
+          "type": "string",
+          "description": "The authentication method for requests",
+          "default": "basic user_password",
+          "enum": [
+            "basic user_password",
+            "static_token",
+            "jwt_token",
+            "request_token",
+            "no_authentication"
+          ]
+        },
+        "username": {
+          "type": "string",
+          "description": "The username used for requests",
+          "default": "",
+          "examples": [
+            "username"
+          ]
+        },
+        "password": {
+          "type": "string",
+          "description": "The password used for requests. If it was retrieved through the encrypt password call, use the exact return including the {code} or {crypt}",
+          "default": "",
+          "examples": [
+            "password",
+            "{code}password",
+            "{crypt}password"
+          ]
+        },
+        "token": {
+          "type": "string",
+          "description": "The token used for requests",
+          "default": "",
+          "examples": [
+            "sdadafdsf_dummytoken_adfkdhfkajd"
+          ]
+        },
+        "token_user_field": {
+          "type": "string",
+          "description": "The field to send the user credential when getting a token",
+          "default": "username",
+          "examples": [
+            "username"
+          ]
+        },
+        "token_password_field": {
+          "type": "string",
+          "description": "The field to send the password credential when getting a token",
+          "default": "password",
+          "examples": [
+            "password"
+          ]
+        },
+        "token_result_field": {
+          "type": "string",
+          "description": "The field to pull the result from when getting a token",
+          "default": "token",
+          "examples": [
+            "token"
+          ]
+        },
+        "token_URI_path": {
+          "type": "string",
+          "description": "The path used to retrieve a token",
+          "default": "",
+          "examples": [
+            "/api/version/authenticate"
+          ]
+        },
+        "invalid_token_error": {
+          "type": "integer",
+          "description": "http error status number which defines an invalid token",
+          "default": 401,
+          "minimum": 0,
+          "maximum": 1000
+        },
+        "token_timeout": {
+          "type": "integer",
+          "description": "How long a token is valid (in milliseconds), -1 (always get token), 0 use expiration returned with token",
+          "default": -1,
+          "minimum": -1,
+          "maximum": 3600000
+        },
+        "token_cache": {
+          "type": "string",
+          "description": "Whether tokens should be stored in redis or local memory",
+          "default": "local",
+          "enum": [
+            "redis",
+            "local"
+          ]
+        },
+        "auth_field": {
+          "type": [
+            "string",
+            "array"
+          ],
+          "description": "The field in which to pass the token",
+          "default": "header.headers.X-AUTH-TOKEN",
+          "examples": [
+            "header.headers.X-AUTH-TOKEN",
+            "header.headers.Authorization",
+            "header.auth",
+            "body.token",
+            "url"
+          ]
+        },
+        "auth_field_format": {
+          "type": [
+            "string",
+            "array"
+          ],
+          "description": "The format used to pass the authentication -- variables {token}, {username}, {password} will be replaced with the proper values. {b64}...{/b64} will base64 encode everything between the start and end tag.",
+          "default": "{token}",
+          "examples": [
+            "{token}",
+            "Token {token}",
+            "{username}:{password}",
+            "Basic {b64}{username}:{password}{/b64}",
+            "token={token}"
+          ]
+        },
+        "auth_logging": {
+          "type": "boolean",
+          "description": "This property turns on logging of Authentication Information and should only be true when debugging authentication and connectivity",
+          "default": false
+        },
+        "client_id": {
+          "type": "string",
+          "description": "The client id for OAuth requests - can also use username depending on schema",
+          "default": ""
+        },
+        "client_secret": {
+          "type": "string",
+          "description": "The client secret for OAuth requests - can also use password depending on schema",
+          "default": ""
+        },
+        "grant_type": {
+          "type": "string",
+          "description": "The grant type for OAuth requests - can also provide in schema",
+          "default": ""
+        }
+      },
+      "required": [
+        "auth_method"
+      ],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "auth_method": {
+                "enum": [
+                  "basic user_password"
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "username",
+              "password",
+              "auth_field",
+              "auth_field_format"
+            ]
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "auth_method": {
+                "enum": [
+                  "request_token"
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "username",
+              "password",
+              "auth_field",
+              "auth_field_format"
+            ]
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "auth_method": {
+                "enum": [
+                  "static_token"
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "token",
+              "auth_field",
+              "auth_field_format"
+            ]
+          }
+        }
+      ]
+    },
+    "healthcheck": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "The type of healthcheck to run",
+          "default": "intermittent",
+          "enum": [
+            "none",
+            "startup",
+            "intermittent"
+          ]
+        },
+        "frequency": {
+          "type": "integer",
+          "description": "How often the healthcheck should run (in milliseconds).",
+          "default": 300000,
+          "minimum": 60000,
+          "maximum": 3600000
+        },
+        "protocol": {
+          "type": "string",
+          "description": "The protocol used to check the health of the system",
+          "default": "REST",
+          "enum": [
+            "REST"
+          ]
+        },
+        "URI_Path": {
+          "type": "string",
+          "description": "The path used to check the health of the system",
+          "default": "",
+          "examples": [
+            "/api/version/ping"
+          ]
+        },
+        "query_object": {
+          "type": "object",
+          "description": "Query object { device: xxxxx } to be placed into the healthcheck, will be converted to query string by the adapter"
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "type": {
+                "enum": [
+                  "intermittent"
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "frequency"
+            ]
+          }
+        }
+      ]
+    },
+    "throttle": {
+      "type": "object",
+      "properties": {
+        "throttle_enabled": {
+          "type": "boolean",
+          "description": "Whether to use throttling",
+          "default": false
+        },
+        "number_pronghorns": {
+          "type": "integer",
+          "description": "whether the throttling is being done in a single Pronghorn instance or whether requests are being throttled across multiple pronghorns",
+          "default": 1,
+          "minimum": 1,
+          "maximum": 20
+        },
+        "sync_async": {
+          "type": "string",
+          "description": "should the queue handle request synchronously or asynchronously",
+          "default": "sync",
+          "examples": [
+            "async",
+            "sync"
+          ]
+        },
+        "max_in_queue": {
+          "type": "integer",
+          "description": "the maximum number of requests that Pronghorn should allow into the queue before rejecting requests",
+          "default": 1000,
+          "minimum": 1,
+          "maximum": 5000
+        },
+        "concurrent_max": {
+          "type": "integer",
+          "description": "defines the number of request that Pronghorn can send to System at one time",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 1000
+        },
+        "expire_timeout": {
+          "type": "integer",
+          "description": "After the request has completed, Pronghorn will wait the additional expire timeout time (in milliseconds) prior to sending in the next request.",
+          "default": 0,
+          "minimum": 0,
+          "maximum": 60000
+        },
+        "avg_runtime": {
+          "type": "integer",
+          "description": "an approximate average of how long it takes System to handle each request",
+          "default": 200,
+          "minimum": 50,
+          "maximum": 60000
+        },
+        "priorities": {
+          "type": "array",
+          "description": "define your priorities here",
+          "items": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "number",
+                "description": "Defines a priority - this number is what is passed in on a priority request"
+              },
+              "percent": {
+                "type": "number",
+                "description": "this is the percent of the queue that comes before the priority request (0 is front of queue, 100 is last in queue)"
+              }
+            }
+          }
+        }
+      },
+      "required": [
+        "throttle_enabled"
+      ],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "throttle_enabled": {
+                "enum": [
+                  true
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "number_pronghorns",
+              "sync_async",
+              "max_in_queue",
+              "concurrent_max",
+              "expire_timeout",
+              "avg_runtime"
+            ]
+          }
+        }
+      ]
+    },
+    "request": {
+      "type": "object",
+      "properties": {
+        "number_redirects": {
+          "type": "integer",
+          "description": "how many redirects before it gives up on the request",
+          "default": 0,
+          "minimum": 0,
+          "maximum": 20
+        },
+        "number_retries": {
+          "type": "integer",
+          "description": "how many attempt to make before it gives up on the request",
+          "default": 3,
+          "minimum": 0,
+          "maximum": 20
+        },
+        "limit_retry_error": {
+          "type": [
+            "integer",
+            "array"
+          ],
+          "description": "http error status number which defines that no capacity was available and thus after waiting a short interval the adapter can retry the request. Supports an array of numbers or strings including a range provided as '###-###'",
+          "default": 0
+        },
+        "failover_codes": {
+          "type": "array",
+          "description": "An array of codes where it is ok to try another method",
+          "items": {
+            "type": "integer"
+          }
+        },
+        "attempt_timeout": {
+          "type": "integer",
+          "description": "how long Pronghorn should wait before aborting the attempt",
+          "default": 5000,
+          "minimum": 1000,
+          "maximum": 3600000
+        },
+        "global_request": {
+          "type": "object",
+          "description": "Global Request data that is overriden by the request object",
+          "properties": {
+            "payload": {
+              "type": "object",
+              "description": "payload fields that will be appended to the provided payload (excluding GET calls)"
+            },
+            "uriOptions": {
+              "type": "object",
+              "description": "options that will be appended to all GET calls"
+            },
+            "addlHeaders": {
+              "type": "object",
+              "description": "headers that will be appended to the headers for the call"
+            },
+            "authData": {
+              "type": "object",
+              "description": "authentication data that will be appended to the payload for authentication calls"
+            }
+          }
+        },
+        "healthcheck_on_timeout": {
+          "type": "boolean",
+          "description": "Should the system run a healthcheck on timeout",
+          "default": false
+        },
+        "return_raw": {
+          "type": "boolean",
+          "description": "Will include the raw response with the data that is returned",
+          "default": false
+        },
+        "archiving": {
+          "type": "boolean",
+          "description": "Archives each request/response and corresponding metrics",
+          "default": false
+        },
+        "return_request": {
+          "type": "boolean",
+          "description": "This property turns on returning the response information - need to be carefull in case credentials are in the path",
+          "default": false
+        }
+      },
+      "required": [
+        "number_retries",
+        "limit_retry_error",
+        "attempt_timeout",
+        "healthcheck_on_timeout"
+      ]
+    },
+    "proxy": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether or not there is a proxy for the Server",
+          "default": false
+        },
+        "host": {
+          "type": "string",
+          "description": "hostname of the proxy for the server",
+          "default": "",
+          "examples": [
+            "proxy.customer.com"
+          ]
+        },
+        "port": {
+          "type": "integer",
+          "description": "port on which to connect to the proxy for the server",
+          "default": 443,
+          "minimum": 1,
+          "maximum": 65535
+        },
+        "protocol": {
+          "type": "string",
+          "description": "the protocol to use to connect to the proxy",
+          "default": "http",
+          "enum": [
+            "http",
+            "https",
+            "socks4",
+            "socks5",
+            "tls"
+          ]
+        },
+        "username": {
+          "type": "string",
+          "description": "username for proxy authentication",
+          "default": ""
+        },
+        "password": {
+          "type": "string",
+          "description": "password for proxy authentication",
+          "default": ""
+        }
+      },
+      "required": [
+        "enabled"
+      ],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "enabled": {
+                "enum": [
+                  true
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "host",
+              "port"
+            ]
+          }
+        }
+      ]
+    },
+    "ssl": {
+      "type": "object",
+      "properties": {
+        "ecdhCurve": {
+          "type": "string",
+          "description": "Do we need to set the autoCurve on this request",
+          "default": "",
+          "examples": [
+            "auto"
+          ]
+        },
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether or not ssl is enabled on Server",
+          "default": false
+        },
+        "accept_invalid_cert": {
+          "type": "boolean",
+          "description": "Whether the adapter should accept invalid certificates",
+          "default": false
+        },
+        "ca_file": {
+          "type": "string",
+          "description": "The fully qualified path name to the CA file used for SSL",
+          "default": "",
+          "examples": [
+            "security/ca.pem"
+          ]
+        },
+        "key_file": {
+          "type": "string",
+          "description": "The fully qualified path name to the key file used for SSL",
+          "default": "",
+          "examples": [
+            "security/key.pem"
+          ]
+        },
+        "cert_file": {
+          "type": "string",
+          "description": "The fully qualified path name to the Cert file used for SSL",
+          "default": "",
+          "examples": [
+            "security/cert.pem"
+          ]
+        },
+        "secure_protocol": {
+          "type": "string",
+          "description": "What protocol to set on the ssl request",
+          "default": "",
+          "examples": [
+            "SSLv2_method",
+            "SSLv3_method"
+          ]
+        },
+        "ciphers": {
+          "type": "string",
+          "description": "Hyphen separated list of acceptable ciphers",
+          "default": "",
+          "examples": [
+            "DHE-RSA-AES256-SHA"
+          ]
+        }
+      },
+      "required": [
+        "enabled"
+      ],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "enabled": {
+                "enum": [
+                  true
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "accept_invalid_cert",
+              "ciphers"
+            ]
+          }
+        },
+        {
+          "if": {
+            "allOf": [
+              {
+                "properties": {
+                  "enabled": {
+                    "enum": [
+                      true
+                    ]
+                  }
+                }
+              },
+              {
+                "properties": {
+                  "accept_invalid_cert": {
+                    "enum": [
+                      false
+                    ]
+                  }
+                }
+              }
+            ]
+          },
+          "then": {
+            "required": [
+              "ca_file"
+            ]
+          }
+        }
+      ]
+    },
+    "mongo": {
+      "type": "object",
+      "properties": {
+        "host": {
+          "type": "string",
+          "description": "host where mongo database can be found",
+          "default": "",
+          "examples": [
+            "localhost"
+          ]
+        },
+        "port": {
+          "type": "integer",
+          "description": "port on which to connect to the mongo database",
+          "default": 443,
+          "minimum": 0,
+          "maximum": 65535
+        },
+        "database": {
+          "type": "string",
+          "description": "The name of the database to store adapter information in",
+          "default": "",
+          "examples": [
+            "adapter-xyz"
+          ]
+        },
+        "username": {
+          "type": "string",
+          "description": "The user to connect to the database with",
+          "default": "",
+          "examples": [
+            "username"
+          ]
+        },
+        "password": {
+          "type": "string",
+          "description": "The password to connect to the database with",
+          "default": "",
+          "examples": [
+            "password"
+          ]
+        },
+        "replSet": {
+          "type": "string",
+          "description": "The replica set for the database",
+          "default": "",
+          "examples": [
+            "my_repolica_set"
+          ]
+        },
+        "db_ssl": {
+          "type": "object",
+          "description": "SSL for mongo database connection",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether or not ssl is enabled on Database Server",
+              "default": false
+            },
+            "accept_invalid_cert": {
+              "type": "boolean",
+              "description": "Whether the adapter should accept invalid certificates",
+              "default": false
+            },
+            "ca_file": {
+              "type": "string",
+              "description": "The fully qualified path name to the CA file used for Database SSL",
+              "default": "",
+              "examples": [
+                "security/ca.pem"
+              ]
+            },
+            "key_file": {
+              "type": "string",
+              "description": "The fully qualified path name to the key file used for Database SSL",
+              "default": "",
+              "examples": [
+                "security/key.pem"
+              ]
+            },
+            "cert_file": {
+              "type": "string",
+              "description": "The fully qualified path name to the Cert file used for Database SSL",
+              "default": "",
+              "examples": [
+                "security/cert.pem"
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}