@sasjs/adapter
Version:
JavaScript adapter for SAS
1,381 lines (1,270 loc) • 1.38 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["SASjs"] = factory();
else
root["SASjs"] = factory();
})(self, () => {
return /******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 2656:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.decodeToken = exports.hasTokenExpired = exports.isRefreshTokenExpiring = exports.isAccessTokenExpiring = void 0;
const jwt_decode_1 = __importDefault(__webpack_require__(6245));
/**
* Checks if the Access Token is expired or is expiring in 1 hour. A default Access Token
* lasts 12 hours. If the Access Token expires, the Refresh Token is used to fetch a new
* Access Token. In the case that the Refresh Token is expired, 1 hour is enough to let
* most jobs finish.
* @param {string} token- token string that will be evaluated
* @param {number} timeToLiveSeconds - the amount of time that the token has before it expires, defaults to 3600
* @returns {boolean} a value indicating whether the token is about to expire
*/
function isAccessTokenExpiring(token, timeToLiveSeconds = 3600) {
if (!token) {
return true;
}
return isTokenExpiring(token, timeToLiveSeconds);
}
exports.isAccessTokenExpiring = isAccessTokenExpiring;
/**
* Checks if the Refresh Token is expired or expiring in 30 secs. A default Refresh Token
* lasts 30 days. Once the Refresh Token expires, the user must re-authenticate (provide
* credentials in a browser to obtain an authorisation code). 30 seconds is enough time
* to make a request for a final Access Token.
* @param {string} token- token string that will be evaluated
* @param {number} timeToLiveSeconds - the amount of time that the token has before it expires, defaults to 30
* @returns {boolean} a value indicating whether the token is about to expire
*/
function isRefreshTokenExpiring(token, timeToLiveSeconds = 30) {
if (!token) {
return true;
}
return isTokenExpiring(token, timeToLiveSeconds);
}
exports.isRefreshTokenExpiring = isRefreshTokenExpiring;
/**
* Checks if the given token has expired.
* @param {string} token- token string that will be evaluated
* @returns {boolean} a value indicating whether the token has expired
*/
function hasTokenExpired(token) {
if (!token) {
return true;
}
return isTokenExpiring(token, 0);
}
exports.hasTokenExpired = hasTokenExpired;
function isTokenExpiring(token, timeToLiveSeconds) {
const payload = (0, jwt_decode_1.default)(token);
const timeToLive = payload.exp - new Date().valueOf() / 1000;
return timeToLive <= timeToLiveSeconds;
}
function decodeToken(token) {
let payload;
try {
payload = (0, jwt_decode_1.default)(token);
}
catch (err) {
throw new Error('Invalid token supplied.');
}
return payload;
}
exports.decodeToken = decodeToken;
//# sourceMappingURL=auth.js.map
/***/ }),
/***/ 6799:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
__exportStar(__webpack_require__(2656), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 3259:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.prefixMessage = void 0;
const prefixMessage = (err, messagePrefix) => {
if (typeof err === 'object') {
if (err.hasOwnProperty('message')) {
err.message = messagePrefix + err.message;
}
else {
if (err.hasOwnProperty('body')) {
if (typeof err.body === 'object') {
err.message = err.body.message
? messagePrefix + err.body.message
: messagePrefix;
}
if (typeof err.body === 'string') {
let body;
try {
body = JSON.parse(err.body);
}
catch (error) {
err.message = messagePrefix;
return err;
}
body.message = body.message
? messagePrefix + body.message
: messagePrefix;
err.body = body;
return err;
}
}
else
return Object.assign(Object.assign({}, err), { message: messagePrefix });
}
}
if (typeof err === 'string')
err = messagePrefix + err;
return err;
};
exports.prefixMessage = prefixMessage;
//# sourceMappingURL=errorModifier.js.map
/***/ }),
/***/ 9778:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
__exportStar(__webpack_require__(3259), exports);
__exportStar(__webpack_require__(1064), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 1064:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ServerTypeError = void 0;
const types_1 = __webpack_require__(3900);
class ServerTypeError extends Error {
constructor(validOptions = []) {
validOptions = [...new Set(validOptions)];
let options = validOptions.length
? validOptions.join(', ').trim()
: [types_1.ServerType.SasViya, types_1.ServerType.Sas9, types_1.ServerType.Sasjs]
.join(', ')
.trim();
options = options.replace(/,\s([^,]*)$/, ' and $1');
super(`Invalid server type: valid option${validOptions.length !== 1 ? 's' : ''} ${validOptions.length !== 1 ? 'are' : 'is'} ${options}`);
this.name = 'ServerTypeError';
Object.setPrototypeOf(this, ServerTypeError.prototype);
}
}
exports.ServerTypeError = ServerTypeError;
//# sourceMappingURL=serverTypeError.js.map
/***/ }),
/***/ 6467:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isSpecialMissing = exports.choiceValidator = exports.confirmationValidator = exports.urlValidator = void 0;
const valid_url_1 = __importDefault(__webpack_require__(481));
const urlValidator = (value, errorMessage) => !!valid_url_1.default.isHttpUri(value) ||
!!valid_url_1.default.isHttpsUri(value) ||
value === '' ||
errorMessage;
exports.urlValidator = urlValidator;
const confirmationValidator = (value) => value === true || value === false;
exports.confirmationValidator = confirmationValidator;
const choiceValidator = (value, numberOfChoices, errorMessage) => (value > 0 && value <= numberOfChoices) || errorMessage;
exports.choiceValidator = choiceValidator;
// This regex will match special missing
// `a-z` or `_` or `.` or '.[a-z]'
const isSpecialMissing = (value) => {
// This regex can't cover the case with `..` two dots, so if we receive it that is false special missing
if (typeof value === 'string' && value.includes('..'))
return false;
const regex = new RegExp('^(\\.)?[a-z_.]{1}$', 'i');
return regex.test(value);
};
exports.isSpecialMissing = isSpecialMissing;
//# sourceMappingURL=validators.js.map
/***/ }),
/***/ 8239:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ConfigTypes = void 0;
var ConfigTypes;
(function (ConfigTypes) {
ConfigTypes["Build"] = "buildConfig";
ConfigTypes["Service"] = "serviceConfig";
ConfigTypes["Job"] = "jobConfig";
ConfigTypes["Test"] = "testConfig";
ConfigTypes["Doc"] = "docConfig";
ConfigTypes["Deploy"] = "deployConfig";
ConfigTypes["Stream"] = "streamConfig";
ConfigTypes["Auth"] = "authConfig";
})(ConfigTypes = exports.ConfigTypes || (exports.ConfigTypes = {}));
//# sourceMappingURL=config.js.map
/***/ }),
/***/ 2427:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=configuration.js.map
/***/ }),
/***/ 189:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=decodedToken.js.map
/***/ }),
/***/ 3692:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=extraResponseAttributes.js.map
/***/ }),
/***/ 4729:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.LineEndings = void 0;
var LineEndings;
(function (LineEndings) {
LineEndings["CRLF"] = "\r\n";
LineEndings["LF"] = "\n";
})(LineEndings = exports.LineEndings || (exports.LineEndings = {}));
//# sourceMappingURL=file.js.map
/***/ }),
/***/ 6939:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.MemberType = void 0;
var MemberType;
(function (MemberType) {
MemberType["service"] = "service";
MemberType["file"] = "file";
MemberType["folder"] = "folder";
})(MemberType = exports.MemberType || (exports.MemberType = {}));
//# sourceMappingURL=fileTree.js.map
/***/ }),
/***/ 3327:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=hash.js.map
/***/ }),
/***/ 5165:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=httpsAgentOptions.js.map
/***/ }),
/***/ 3900:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
__exportStar(__webpack_require__(8239), exports);
__exportStar(__webpack_require__(2427), exports);
__exportStar(__webpack_require__(189), exports);
__exportStar(__webpack_require__(3692), exports);
__exportStar(__webpack_require__(6939), exports);
__exportStar(__webpack_require__(3327), exports);
__exportStar(__webpack_require__(5165), exports);
__exportStar(__webpack_require__(4069), exports);
__exportStar(__webpack_require__(8932), exports);
__exportStar(__webpack_require__(4), exports);
__exportStar(__webpack_require__(2015), exports);
__exportStar(__webpack_require__(8515), exports);
__exportStar(__webpack_require__(5313), exports);
__exportStar(__webpack_require__(8979), exports);
__exportStar(__webpack_require__(4729), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 4069:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isMacroVars = void 0;
const isMacroVars = (arg) => arg && typeof arg.macroVars === 'object' && !Array.isArray(arg.macroVars);
exports.isMacroVars = isMacroVars;
//# sourceMappingURL=macro.js.map
/***/ }),
/***/ 8932:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=sasAuthResponse.js.map
/***/ }),
/***/ 4:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.SASJsFileType = void 0;
var SASJsFileType;
(function (SASJsFileType) {
SASJsFileType["service"] = "Service";
SASJsFileType["job"] = "Job";
SASJsFileType["test"] = "Test";
SASJsFileType["file"] = "File"; // Should be used when file content is not considered as Service, Job or Test and is used as raw content
})(SASJsFileType = exports.SASJsFileType || (exports.SASJsFileType = {}));
//# sourceMappingURL=sasJsFileType.js.map
/***/ }),
/***/ 2015:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=serverError.js.map
/***/ }),
/***/ 8515:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ServerType = void 0;
var ServerType;
(function (ServerType) {
ServerType["SasViya"] = "SASVIYA";
ServerType["Sas9"] = "SAS9";
ServerType["Sasjs"] = "SASJS";
})(ServerType = exports.ServerType || (exports.ServerType = {}));
//# sourceMappingURL=serverType.js.map
/***/ }),
/***/ 5313:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=servicePack.js.map
/***/ }),
/***/ 8979:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Target = void 0;
const config_1 = __webpack_require__(8239);
const serverType_1 = __webpack_require__(8515);
const targetValidators_1 = __webpack_require__(6781);
class Target {
constructor(json, config = {}) {
this._serverType = serverType_1.ServerType.SasViya;
this.getConfig = (key, json) => {
const config = this._config[key] || {};
return Object.assign(Object.assign({}, config), json[key]);
};
try {
if (!json) {
throw new Error('Invalid target: Input JSON is null or undefined.');
}
this._config = config;
this._name = (0, targetValidators_1.validateTargetName)(json.name);
this._serverUrl = (0, targetValidators_1.validateServerUrl)(json.serverUrl);
this._serverType = (0, targetValidators_1.validateServerType)(json.serverType);
this._httpsAgentOptions = (0, targetValidators_1.validateHttpsAgentOptions)(json.httpsAgentOptions);
this._appLoc = (0, targetValidators_1.validateAppLoc)(json.appLoc);
this._contextName = (0, targetValidators_1.validateContextName)(json.contextName, this._serverType);
this._serverName = (0, targetValidators_1.validateServerName)(json.serverName, this._serverType);
this._syncFolder = (0, targetValidators_1.validateSyncFolder)(json.syncFolder);
this._repositoryName = (0, targetValidators_1.validateRepositoryName)(json.repositoryName, this._serverType);
if (json.docConfig) {
this._docConfig = (0, targetValidators_1.validateDocConfig)(this.getConfig(config_1.ConfigTypes.Doc, json));
}
if (json.authConfig) {
this._authConfig = (0, targetValidators_1.validateAuthConfig)(this.getConfig(config_1.ConfigTypes.Auth, json));
}
if (json.authConfigSas9) {
this._authConfigSas9 = (0, targetValidators_1.validateAuthConfigSas9)(json.authConfigSas9);
}
if (json.buildConfig) {
this._buildConfig = (0, targetValidators_1.validateBuildConfig)(this.getConfig(config_1.ConfigTypes.Build, json), this._name);
}
if (json.deployConfig) {
this._deployConfig = (0, targetValidators_1.validateDeployConfig)(this.getConfig(config_1.ConfigTypes.Deploy, json));
}
else {
this._deployConfig = (0, targetValidators_1.validateDeployConfig)({
deployServicePack: true,
deployScripts: []
});
}
if (json.serviceConfig) {
this._serviceConfig = (0, targetValidators_1.validateServiceConfig)(this.getConfig(config_1.ConfigTypes.Service, json));
}
if (json.jobConfig) {
this._jobConfig = (0, targetValidators_1.validateJobConfig)(this.getConfig(config_1.ConfigTypes.Job, json));
}
if (json.streamConfig) {
this._streamConfig = (0, targetValidators_1.validateStreamConfig)(this.getConfig(config_1.ConfigTypes.Stream, json));
}
if (json.testConfig) {
this._testConfig = (0, targetValidators_1.validateTestConfig)(this.getConfig(config_1.ConfigTypes.Test, json));
}
if (json.macroFolders && json.macroFolders.length) {
this._macroFolders = json.macroFolders;
}
if (json.programFolders && json.programFolders.length) {
this._programFolders = json.programFolders;
}
if (json.binaryFolders && json.binaryFolders.length) {
this._binaryFolders = json.binaryFolders;
}
if (json.syncDirectories && json.syncDirectories.length) {
this._syncDirectories = (0, targetValidators_1.validateSyncDirectories)(json.syncDirectories);
}
if (json.sasjsBuildFolder) {
this._sasjsBuildFolder = (0, targetValidators_1.validateSasjsBuildFolder)(json.sasjsBuildFolder);
}
if (json.sasjsResultsFolder) {
this._sasjsResultsFolder = (0, targetValidators_1.validateSasjsResultsFolder)(json.sasjsResultsFolder);
}
}
catch (e) {
throw new Error(`Error parsing target: ${e.message}`);
}
}
get name() {
return this._name;
}
get serverUrl() {
return this._serverUrl;
}
get serverType() {
return this._serverType;
}
get httpsAgentOptions() {
return this._httpsAgentOptions;
}
get appLoc() {
return this._appLoc;
}
get docConfig() {
return this._docConfig;
}
get authConfig() {
return this._authConfig;
}
get authConfigSas9() {
return this._authConfigSas9;
}
get buildConfig() {
return this._buildConfig;
}
get deployConfig() {
return this._deployConfig;
}
get serviceConfig() {
return this._serviceConfig;
}
get jobConfig() {
return this._jobConfig;
}
get streamConfig() {
return this._streamConfig;
}
get macroFolders() {
return this._macroFolders;
}
get programFolders() {
return this._programFolders;
}
get binaryFolders() {
return this._binaryFolders;
}
get contextName() {
return this._contextName;
}
get serverName() {
return this._serverName;
}
get repositoryName() {
return this._repositoryName;
}
get testConfig() {
return this._testConfig;
}
get syncFolder() {
return this._syncFolder;
}
get syncDirectories() {
return this._syncDirectories;
}
get sasjsBuildFolder() {
return this._sasjsBuildFolder;
}
get sasjsResultsFolder() {
return this._sasjsResultsFolder;
}
toJson(withDefaults = true) {
var _a, _b, _c;
const json = {
name: this.name,
serverUrl: this.serverUrl,
serverType: this.serverType,
httpsAgentOptions: this.httpsAgentOptions,
appLoc: this.appLoc,
docConfig: this.docConfig,
deployConfig: this.deployConfig
};
if ((_a = this.macroFolders) === null || _a === void 0 ? void 0 : _a.length)
json.macroFolders = this.macroFolders;
if ((_b = this.programFolders) === null || _b === void 0 ? void 0 : _b.length)
json.programFolders = this.programFolders;
if ((_c = this.binaryFolders) === null || _c === void 0 ? void 0 : _c.length)
json.binaryFolders = this.binaryFolders;
if (this.authConfig) {
json.authConfig = this.authConfig;
}
if (this.authConfigSas9) {
json.authConfigSas9 = this.authConfigSas9;
}
if (this.sasjsBuildFolder) {
json.sasjsBuildFolder = this.sasjsBuildFolder;
}
else if (withDefaults) {
json.sasjsBuildFolder = targetValidators_1.DEFAULT_SASJS_BUILD_FOLDER;
}
if (this.sasjsResultsFolder) {
json.sasjsResultsFolder = this.sasjsResultsFolder;
}
else if (withDefaults) {
json.sasjsResultsFolder = targetValidators_1.DEFAULT_SASJS_RESULTS_FOLDER;
}
if (this.syncDirectories) {
json.syncDirectories = this.syncDirectories;
}
else if (withDefaults) {
json.syncDirectories = [];
}
if (this.buildConfig) {
json.buildConfig = this.buildConfig;
}
else if (withDefaults)
json.buildConfig = {
initProgram: '',
termProgram: '',
buildOutputFileName: `${this.name}.sas`,
macroVars: {}
};
if (this.jobConfig) {
json.jobConfig = this.jobConfig;
}
else if (withDefaults)
json.jobConfig = {
jobFolders: [],
initProgram: '',
termProgram: '',
macroVars: {}
};
if (this.serviceConfig) {
json.serviceConfig = this.serviceConfig;
}
else if (withDefaults)
json.serviceConfig = {
serviceFolders: [],
initProgram: '',
termProgram: '',
macroVars: {}
};
if (this.streamConfig) {
json.streamConfig = this.streamConfig;
}
else if (withDefaults)
json.streamConfig = {
streamWebFolder: '',
streamWeb: false,
webSourcePath: '',
streamServiceName: '',
assetPaths: []
};
if (this.testConfig) {
json.testConfig = this.testConfig;
}
else if (withDefaults)
json.testConfig = {
initProgram: '',
termProgram: '',
macroVars: {},
testSetUp: '',
testTearDown: ''
};
if (this.serverType === serverType_1.ServerType.SasViya) {
json.contextName = this.contextName;
}
else if (this.serverType === serverType_1.ServerType.Sas9) {
json.serverName = this.serverName;
json.repositoryName = this.repositoryName;
}
return json;
}
}
exports.Target = Target;
//# sourceMappingURL=target.js.map
/***/ }),
/***/ 6781:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.validateSasjsResultsFolder = exports.validateSasjsBuildFolder = exports.validateSyncDirectories = exports.validateRepositoryName = exports.validateSyncFolder = exports.validateServerName = exports.validateContextName = exports.validateStreamConfig = exports.validateDeployConfig = exports.validateJobConfig = exports.validateTestConfig = exports.validateServiceConfig = exports.validateBuildConfig = exports.validateAuthConfigSas9 = exports.validateAuthConfig = exports.validateDocConfig = exports.validateAppLoc = exports.validateHttpsAgentOptions = exports.validateServerUrl = exports.validateTargetName = exports.validateServerType = exports.DEFAULT_SASJS_RESULTS_FOLDER = exports.DEFAULT_SASJS_BUILD_FOLDER = void 0;
const valid_url_1 = __importDefault(__webpack_require__(481));
const _1 = __webpack_require__(3900);
const DEFAULT_CONTEXT_NAME = 'SAS Job Execution compute context';
const DEFAULT_SERVER_NAME = 'SASApp';
const DEFAULT_REPOSITORY_NAME = 'Foundation';
exports.DEFAULT_SASJS_BUILD_FOLDER = 'sasjsbuild';
exports.DEFAULT_SASJS_RESULTS_FOLDER = 'sasjsresults';
const validateServerType = (serverType) => {
if (!serverType) {
throw new Error('Invalid server type: `serverType` cannot be null or undefined.');
}
if (!(serverType === _1.ServerType.Sas9 ||
serverType === _1.ServerType.SasViya ||
serverType === _1.ServerType.Sasjs)) {
throw new Error(`Invalid server type: Supported values for \`serverType\` are ${_1.ServerType.SasViya}, ${_1.ServerType.Sas9} and ${_1.ServerType.Sasjs}.`);
}
return serverType;
};
exports.validateServerType = validateServerType;
const validateTargetName = (targetName) => {
if (!targetName) {
throw new Error('Invalid target name: `name` cannot be empty, null or undefined.');
}
if (targetName.trim().includes(' ')) {
throw new Error('Invalid target name: `name` cannot include spaces.');
}
if (!/^[a-zA-Z0-9\-]+$/i.test(targetName)) {
throw new Error('Invalid target name: `name` can only contain alphanumeric characters and dashes.');
}
return targetName;
};
exports.validateTargetName = validateTargetName;
const validateServerUrl = (serverUrl) => {
if (serverUrl === null || serverUrl === undefined) {
serverUrl = '';
}
if (serverUrl !== '' &&
!valid_url_1.default.isHttpUri(serverUrl) &&
!valid_url_1.default.isHttpsUri(serverUrl)) {
throw new Error('Invalid server URL: `serverUrl` should either be an empty string or a valid URL of the form http(s)://your-server.com(:port).');
}
return serverUrl;
};
exports.validateServerUrl = validateServerUrl;
const validateHttpsAgentOptions = (httpsAgentOptions) => {
if (!httpsAgentOptions)
return;
if (typeof httpsAgentOptions !== 'object') {
throw new Error('Invalid value: `httpsAgentOptions` should either be an empty or an object of `HttpsAgentOptions`');
}
if (httpsAgentOptions.allowInsecureRequests === null ||
httpsAgentOptions.allowInsecureRequests === undefined) {
httpsAgentOptions.allowInsecureRequests = false;
}
else if (typeof httpsAgentOptions.allowInsecureRequests !== 'boolean') {
throw new Error('Invalid value: `httpsAgentOptions.allowInsecureRequests` should either be an empty or a boolean');
}
if (typeof httpsAgentOptions.caPath !== 'string') {
httpsAgentOptions.caPath = undefined;
}
if (typeof httpsAgentOptions.keyPath !== 'string') {
httpsAgentOptions.keyPath = undefined;
}
if (typeof httpsAgentOptions.certPath !== 'string') {
httpsAgentOptions.certPath = undefined;
}
return httpsAgentOptions;
};
exports.validateHttpsAgentOptions = validateHttpsAgentOptions;
const validateAppLoc = (appLoc) => {
if (!appLoc) {
throw new Error('Invalid app location: `appLoc` cannot be empty, null or undefined.');
}
if (!appLoc.startsWith('/')) {
throw new Error('Invalid app location: `appLoc` must start with a `/`.');
}
return appLoc;
};
exports.validateAppLoc = validateAppLoc;
const validateDocConfig = (docConfig) => {
if (!docConfig) {
docConfig = {};
}
if (typeof docConfig.displayMacroCore !== 'boolean') {
docConfig.displayMacroCore = undefined;
}
if (typeof docConfig.enableLineage !== 'boolean') {
docConfig.enableLineage = undefined;
}
if (typeof docConfig.outDirectory !== 'string') {
docConfig.outDirectory = undefined;
}
if (typeof docConfig.dataControllerUrl === 'string') {
if (docConfig.dataControllerUrl !== '' &&
!valid_url_1.default.isHttpUri(docConfig.dataControllerUrl) &&
!valid_url_1.default.isHttpsUri(docConfig.dataControllerUrl)) {
throw new Error('Invalid Data Controller Url: `dataControllerUrl` should either be an empty string or a valid URL of the form http(s)://your-server.com(:port).');
}
}
else {
docConfig.dataControllerUrl = undefined;
}
return docConfig;
};
exports.validateDocConfig = validateDocConfig;
const validateAuthConfig = (authConfig) => {
if (!authConfig) {
throw new Error('Invalid auth config: JSON cannot be null or undefined.');
}
return authConfig;
};
exports.validateAuthConfig = validateAuthConfig;
const validateAuthConfigSas9 = (authConfigSas9) => {
if (!authConfigSas9) {
throw new Error('Invalid auth config for sas9: JSON cannot be null or undefined.');
}
if (!authConfigSas9.userName || !authConfigSas9.password) {
throw new Error('Invalid auth config for sas9: userName and password can not be empty');
}
return authConfigSas9;
};
exports.validateAuthConfigSas9 = validateAuthConfigSas9;
const validateBuildConfig = (buildConfig, defaultName) => {
if (!buildConfig) {
throw new Error('Invalid build config: JSON cannot be null or undefined.');
}
if (!buildConfig.buildOutputFileName) {
buildConfig.buildOutputFileName = `${defaultName}.sas`;
}
if (!buildConfig.initProgram) {
buildConfig.initProgram = '';
}
if (!buildConfig.termProgram) {
buildConfig.termProgram = '';
}
if (!buildConfig.macroVars) {
buildConfig.macroVars = {};
}
return buildConfig;
};
exports.validateBuildConfig = validateBuildConfig;
const validateServiceConfig = (serviceConfig) => {
if (!serviceConfig) {
throw new Error('Invalid service config: JSON cannot be null or undefined.');
}
if (!serviceConfig.initProgram) {
serviceConfig.initProgram = '';
}
if (!serviceConfig.termProgram) {
serviceConfig.termProgram = '';
}
if (!serviceConfig.serviceFolders) {
serviceConfig.serviceFolders = [];
}
if (!serviceConfig.macroVars) {
serviceConfig.macroVars = {};
}
return serviceConfig;
};
exports.validateServiceConfig = validateServiceConfig;
const validateTestConfig = (testConfig) => {
if (!testConfig) {
throw new Error('Invalid test config: JSON cannot be null or undefined.');
}
if (!testConfig.initProgram)
testConfig.initProgram = '';
if (!testConfig.termProgram)
testConfig.termProgram = '';
if (!testConfig.macroVars)
testConfig.macroVars = {};
if (!testConfig.testSetUp)
testConfig.testSetUp = '';
if (!testConfig.testTearDown)
testConfig.testTearDown = '';
return testConfig;
};
exports.validateTestConfig = validateTestConfig;
const validateJobConfig = (jobConfig) => {
if (!jobConfig) {
throw new Error('Invalid job config: JSON cannot be null or undefined.');
}
if (!jobConfig.initProgram) {
jobConfig.initProgram = '';
}
if (!jobConfig.termProgram) {
jobConfig.termProgram = '';
}
if (!jobConfig.jobFolders) {
jobConfig.jobFolders = [];
}
if (!jobConfig.macroVars) {
jobConfig.macroVars = {};
}
return jobConfig;
};
exports.validateJobConfig = validateJobConfig;
const validateDeployConfig = (deployConfig) => {
if (!deployConfig) {
throw new Error('Invalid deploy config: JSON cannot be null or undefined.');
}
deployConfig.deployServicePack = !!deployConfig.deployServicePack;
if (!deployConfig.deployScripts) {
deployConfig.deployScripts = [];
}
return deployConfig;
};
exports.validateDeployConfig = validateDeployConfig;
const validateStreamConfig = (streamConfig) => {
if (!streamConfig) {
throw new Error('Invalid stream config: JSON cannot be null or undefined.');
}
if (streamConfig.streamWeb !== true && streamConfig.streamWeb !== false) {
throw new Error('Invalid stream config: `streamWeb` cannot be a non-boolean value.');
}
if (streamConfig.streamWeb && !streamConfig.streamWebFolder) {
throw new Error('Invalid stream config: `streamWebFolder` cannot be empty, null or undefined when `streamWeb` is true.');
}
if (streamConfig.streamWeb && !streamConfig.webSourcePath) {
throw new Error('Invalid stream config: `webSourcePath` should contain the path to your frontend application eg build, dist, or src.');
}
if (streamConfig.streamLogo && typeof streamConfig.streamLogo !== 'string') {
streamConfig.streamLogo = undefined;
}
if (!streamConfig.assetPaths) {
streamConfig.assetPaths = [];
}
if (!streamConfig.streamServiceName) {
streamConfig.streamServiceName = 'clickme';
}
return streamConfig;
};
exports.validateStreamConfig = validateStreamConfig;
const validateContextName = (contextName, serverType) => {
if (serverType === _1.ServerType.SasViya && !contextName) {
return DEFAULT_CONTEXT_NAME;
}
return contextName;
};
exports.validateContextName = validateContextName;
const validateServerName = (serverName, serverType) => {
if (serverType === _1.ServerType.Sas9 && !serverName) {
return DEFAULT_SERVER_NAME;
}
return serverName;
};
exports.validateServerName = validateServerName;
const validateSyncFolder = (syncFolder) => {
if (typeof syncFolder !== 'string') {
return;
}
if (!syncFolder)
return;
return syncFolder;
};
exports.validateSyncFolder = validateSyncFolder;
const validateRepositoryName = (repositoryName, serverType) => {
if (serverType === _1.ServerType.Sas9 && !repositoryName) {
return DEFAULT_REPOSITORY_NAME;
}
return repositoryName;
};
exports.validateRepositoryName = validateRepositoryName;
const validateSyncDirectories = (syncDirectories) => {
if (!syncDirectories) {
throw new Error('Invalid syncDirectories config: JSON cannot be null or undefined.');
}
syncDirectories.forEach((obj) => {
if (!obj.local || !obj.remote)
throw new Error(`Invalid syncDirectory config: values of property 'local' and 'remote can not be empty or undefined`);
});
return syncDirectories;
};
exports.validateSyncDirectories = validateSyncDirectories;
const validateSasjsBuildFolder = (folderName) => {
if (typeof folderName !== 'string') {
throw new Error(`Invalid type of value (${typeof folderName}) is provided for property 'sasjsBuildFolder' in config. Required is string.`);
}
if (!folderName)
return exports.DEFAULT_SASJS_BUILD_FOLDER;
return folderName;
};
exports.validateSasjsBuildFolder = validateSasjsBuildFolder;
const validateSasjsResultsFolder = (folderName) => {
if (typeof folderName !== 'string') {
throw new Error(`Invalid type of value (${typeof folderName}) is provided for property 'sasjsResultsFolder' in config. Required is string.`);
}
if (!folderName)
return exports.DEFAULT_SASJS_RESULTS_FOLDER;
return folderName;
};
exports.validateSasjsResultsFolder = validateSasjsResultsFolder;
//# sourceMappingURL=targetValidators.js.map
/***/ }),
/***/ 9282:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/* provided dependency */ var process = __webpack_require__(4155);
/* provided dependency */ var console = __webpack_require__(5108);
// Currently in sync with Node.js lib/assert.js
// https://github.com/nodejs/node/commit/2a51ae424a513ec9a6aa3466baa0cc1d55dd4f3b
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var _require = __webpack_require__(2136),
_require$codes = _require.codes,
ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT,
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE,
ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE,
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
var AssertionError = __webpack_require__(5961);
var _require2 = __webpack_require__(9539),
inspect = _require2.inspect;
var _require$types = (__webpack_require__(9539).types),
isPromise = _require$types.isPromise,
isRegExp = _require$types.isRegExp;
var objectAssign = __webpack_require__(8162)();
var objectIs = __webpack_require__(5624)();
var RegExpPrototypeTest = __webpack_require__(1924)('RegExp.prototype.test');
var errorCache = new Map();
var isDeepEqual;
var isDeepStrictEqual;
var parseExpressionAt;
var findNodeAround;
var decoder;
function lazyLoadComparison() {
var comparison = __webpack_require__(9158);
isDeepEqual = comparison.isDeepEqual;
isDeepStrictEqual = comparison.isDeepStrictEqual;
}
// Escape control characters but not \n and \t to keep the line breaks and
// indentation intact.
// eslint-disable-next-line no-control-regex
var escapeSequencesRegExp = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
var meta = (/* unused pure expression or super */ null && (["\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006", "\\u0007", '\\b', '', '', "\\u000b", '\\f', '', "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b", "\\u001c", "\\u001d", "\\u001e", "\\u001f"]));
var escapeFn = function escapeFn(str) {
return meta[str.charCodeAt(0)];
};
var warned = false;
// The assert module provides functions that throw
// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.
var assert = module.exports = ok;
var NO_EXCEPTION_SENTINEL = {};
// All of the following functions must throw an AssertionError
// when a corresponding condition is not met, with a message that
// may be undefined if not provided. All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.
function innerFail(obj) {
if (obj.message instanceof Error) throw obj.message;
throw new AssertionError(obj);
}
function fail(actual, expected, message, operator, stackStartFn) {
var argsLen = arguments.length;
var internalMessage;
if (argsLen === 0) {
internalMessage = 'Failed';
} else if (argsLen === 1) {
message = actual;
actual = undefined;
} else {
if (warned === false) {
warned = true;
var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);
warn('assert.fail() with more than one argument is deprecated. ' + 'Please use assert.strictEqual() instead or only pass a message.', 'DeprecationWarning', 'DEP0094');
}
if (argsLen === 2) operator = '!=';
}
if (message instanceof Error) throw message;
var errArgs = {
actual: actual,
expected: expected,
operator: operator === undefined ? 'fail' : operator,
stackStartFn: stackStartFn || fail
};
if (message !== undefined) {
errArgs.message = message;
}
var err = new AssertionError(errArgs);
if (internalMessage) {
err.message = internalMessage;
err.generatedMessage = true;
}
throw err;
}
assert.fail = fail;
// The AssertionError is defined in internal/error.
assert.AssertionError = AssertionError;
function innerOk(fn, argLen, value, message) {
if (!value) {
var generatedMessage = false;
if (argLen === 0) {
generatedMessage = true;
message = 'No value argument passed to `assert.ok()`';
} else if (message instanceof Error) {
throw message;
}
var err = new AssertionError({
actual: value,
expected: true,
message: message,
operator: '==',
stackStartFn: fn
});
err.generatedMessage = generatedMessage;
throw err;
}
}
// Pure assertion tests whether a value is truthy, as determined
// by !!value.
function ok() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
innerOk.apply(void 0, [ok, args.length].concat(args));
}
assert.ok = ok;
// The equality assertion tests shallow, coercive equality with ==.
/* eslint-disable no-restricted-properties */
assert.equal = function equal(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
// eslint-disable-next-line eqeqeq
if (actual != expected) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: '==',
stackStartFn: equal
});
}
};
// The non-equality assertion tests for whether two objects are not
// equal with !=.
assert.notEqual = function notEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
// eslint-disable-next-line eqeqeq
if (actual == expected) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: '!=',
stackStartFn: notEqual
});
}
};
// The equivalence assertion tests a deep equality relation.
assert.deepEqual = function deepEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (isDeepEqual === undefined) lazyLoadComparison();
if (!isDeepEqual(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'deepEqual',
stackStartFn: deepEqual
});
}
};
// The non-equivalence assertion tests for any deep inequality.
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (isDeepEqual === undefined) lazyLoadComparison();
if (isDeepEqual(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notDeepEqual',
stackStartFn: notDeepEqual
});
}
};
/* eslint-enable */
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (isDeepEqual === undefined) lazyLoadComparison();
if (!isDeepStrictEqual(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'deepStrictEqual',
stackStartFn: deepStrictEqual
});
}
};
assert.notDeepStrictEqual = notDeepStrictEqual;
function notDeepStrictEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (isDeepEqual === undefined) lazyLoadComparison();
if (isDeepStrictEqual(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notDeepStrictEqual',
stackStartFn: notDeepStrictEqual
});
}
}
assert.strictEqual = function strictEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (!objectIs(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'strictEqual',
stackStartFn: strictEqual
});
}
};
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (arguments.length < 2) {
throw new ERR_MISSING_ARGS('actual', 'expected');
}
if (objectIs(actual, expected)) {
innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notStrictEqual',
stackStartFn: notStrictEqual
});
}
};
var Comparison = /*#__PURE__*/_createClass(function Comparison(obj, keys, actual) {
var _this = this;
_classCallCheck(this, Comparison);
keys.forEach(function (key) {
if (key in obj) {
if (actual !== undefined && typeof actual[key] === 'string' && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) {
_this[key] = actual[key];
} else {
_this[key] = obj[key];
}
}
});
});
function compareExceptionKey(actual, expected, key, message, keys, fn) {
if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
if (!message) {
// Create placeholder objects to create a nice output.
var a = new Comparison(actual, keys);
var b = new Comparison(expected, keys, actual);
var err = new AssertionError({
actual: a,
expected: b,
operator: 'deepStrictEqual',
stackStartFn: fn
});
err.actual = actual;
err.expected = expected;
err.operator = fn.name;
throw err;
}
innerFail({
actual: actual,
expected: expected,
message: message,
operator: fn.name,
stackStartFn: fn
});
}
}
function expectedException(actual, expected, msg, fn) {
if (typeof expected !== 'function') {
if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);
// assert.doesNotThrow does not accept objects.
if (arguments.length === 2) {
throw new ERR_INVALID_ARG_TYPE('expected', ['Function', 'RegExp'], expected);
}
// Handle primitives properly.
if (_typeof(actual) !== 'object' || actual === null) {
var err = new AssertionError({
actual: actual,
expected: expected,
message: msg,
operator: 'deepStrictEqual',
stackStartFn: fn
});
err.operator = fn.name;
throw err;
}
var keys = Object.keys(expected);
// Special handle errors to make sure the name and