@sasjs/cli 6.4.5 → 6.4.6

package/build/commands/add/addCredential.js

@@ -67,13 +67,11 @@ var saveConfig_1 = require("./internal/saveConfig");
  * @param {boolean} insecure- boolean to use insecure connection, default is false. lf true the server will not reject any connection which is not authorized with the list of supplied CAs
  */
 var addCredential = function (target, insecure, targetScope) { return __awaiter(void 0, void 0, void 0, function () {
-    var httpsAgentOptions, serverUrl, filePath_1, _a, _b, client, secret, _c, access_token, refresh_token, _d, userName, password, client, _e, access_token, refresh_token, filePath;
+    var serverUrl, filePath_1, requestTarget, _a, _b, client, secret, _c, access_token, refresh_token, _d, userName, password, client, _e, access_token, refresh_token, filePath;
     var _f, _g, _h;
     return __generator(this, function (_j) {
         switch (_j.label) {
             case 0:
-                httpsAgentOptions = insecure
-                    ? __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) : target.httpsAgentOptions;
                 if (insecure)
                     (_f = process.logger) === null || _f === void 0 ? void 0 : _f.warn('Executing with insecure connection.');
                 if (!!target.serverUrl) return [3 /*break*/, 3];
@@ -87,6 +85,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 (_g = process.logger) === null || _g === void 0 ? void 0 : _g.info("Target configuration has been saved to ".concat(filePath_1, " ."));
                 _j.label = 3;
             case 3:
+                requestTarget = (0, utils_1.targetWithInsecureHttps)(target, insecure);
                 _a = target.serverType;
                 switch (_a) {
                     case types_1.ServerType.SasViya: return [3 /*break*/, 4];
@@ -97,7 +96,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
             case 4: return [4 /*yield*/, (0, input_1.getCredentialsInputForViya)(target.name)];
             case 5:
                 _b = _j.sent(), client = _b.client, secret = _b.secret;
-                return [4 /*yield*/, (0, exports.getTokens)(target, client, secret).catch(function (err) {
+                return [4 /*yield*/, (0, exports.getTokens)(requestTarget, client, secret).catch(function (err) {
                         throw err;
                     })];
             case 6:
@@ -123,7 +122,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 target = new types_1.Target(__assign(__assign({}, target.toJson(false)), { authConfigSas9: { userName: userName, password: password } }));
                 _j.label = 14;
             case 14: return [3 /*break*/, 23];
-            case 15: return [4 /*yield*/, (0, utils_1.isSasJsServerInServerMode)(target)];
+            case 15: return [4 /*yield*/, (0, utils_1.isSasJsServerInServerMode)(requestTarget)];
             case 16:
                 if (!(_j.sent())) {
                     process.logger.info('No need to authenticate against the sasjs server running in desktop mode.');
@@ -132,7 +131,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 return [4 /*yield*/, (0, input_1.getCredentialsInputSasjs)(target)];
             case 17:
                 client = (_j.sent()).client;
-                return [4 /*yield*/, (0, exports.getTokens)(target, client, '')];
+                return [4 /*yield*/, (0, exports.getTokens)(requestTarget, client, '')];
             case 18:
                 _e = _j.sent(), access_token = _e.access_token, refresh_token = _e.refresh_token;
                 if (!(targetScope === targetScope_1.TargetScope.Local)) return [3 /*break*/, 20];

package/build/commands/add/internal/input.d.ts

@@ -17,6 +17,13 @@ export declare function getAndValidateSasViyaFields(target: Target, scope: Targe
 export declare function getAndValidateSasjsFields(target: Target, scope: TargetScope, insecure: boolean, authenticateCallback: (target: Target, insecure: boolean, targetScope: TargetScope) => Promise<Target>): Promise<{
     target: Target;
 }>;
+/**
+ * Lists the compute contexts a target can execute in.
+ *
+ * `insecure` is the user's `--insecure` choice, and it is carried by the
+ * request only: the target that is saved afterwards is the one passed in.
+ */
+export declare function getComputeContexts(target: Target, scope: TargetScope, insecure: boolean): Promise<any[]>;
 export declare const getCredentialsInputForViya: (targetName: string) => Promise<{
     client: string;
     secret: string;

package/build/commands/add/internal/input.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -56,6 +45,7 @@ exports.getAndValidateServerUrl = getAndValidateServerUrl;
 exports.getAndValidateSas9Fields = getAndValidateSas9Fields;
 exports.getAndValidateSasViyaFields = getAndValidateSasViyaFields;
 exports.getAndValidateSasjsFields = getAndValidateSasjsFields;
+exports.getComputeContexts = getComputeContexts;
 var input_1 = require("@sasjs/utils/input");
 var types_1 = require("@sasjs/utils/types");
 var utils_1 = require("@sasjs/utils");
@@ -256,45 +246,27 @@ var shouldAuthenticate = function () { return __awaiter(void 0, void 0, void 0,
 exports.shouldAuthenticate = shouldAuthenticate;
 function getAndValidateSasViyaFields(target, scope, serverUrl, insecure, authenticateCallback) {
     return __awaiter(this, void 0, void 0, function () {
-        var contextName, httpsAgentOptions, sasjs, contexts, contextNumberErrorMessage, contextNumber;
+        var contextName, contexts, contextNumberErrorMessage, contextNumber;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     contextName = 'SAS Job Execution compute context';
                     return [4 /*yield*/, (0, exports.shouldAuthenticate)()];
                 case 1:
-                    if (!_a.sent()) return [3 /*break*/, 8];
+                    if (!_a.sent()) return [3 /*break*/, 5];
                     return [4 /*yield*/, authenticateCallback(target, insecure, scope)];
                 case 2:
                     target = _a.sent();
-                    httpsAgentOptions = insecure
-                        ? __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) : target.httpsAgentOptions;
-                    sasjs = (0, utils_2.getSASjs)(target);
-                    contexts = [];
-                    if (!(scope === targetScope_1.TargetScope.Local)) return [3 /*break*/, 4];
-                    dotenv_1.default.config({
-                        path: path_1.default.join(process.projectDir, ".env.".concat(target.name))
-                    });
-                    return [4 /*yield*/, sasjs.getComputeContexts(process.env.ACCESS_TOKEN)];
+                    return [4 /*yield*/, getComputeContexts(target, scope, insecure)];
                 case 3:
                     contexts = _a.sent();
-                    return [3 /*break*/, 6];
-                case 4:
-                    if (!target.authConfig || !target.authConfig.access_token) {
-                        throw new Error("No access token available for target ".concat(target.name, ". Please run `sasjs add cred -t ").concat(target.name, "` to authenticate."));
-                    }
-                    return [4 /*yield*/, sasjs.getComputeContexts(target.authConfig.access_token)];
-                case 5:
-                    contexts = _a.sent();
-                    _a.label = 6;
-                case 6:
                     contextNumberErrorMessage = "Context number must be between 1 and ".concat(contexts.length);
                     return [4 /*yield*/, (0, input_1.getChoice)('Please pick your SAS Viya execution context: ', contextNumberErrorMessage, contexts.map(function (c, i) { return ({ title: c.name, value: i }); }))];
-                case 7:
+                case 4:
                     contextNumber = _a.sent();
                     contextName = contexts[contextNumber].name;
                     return [2 /*return*/, { contextName: contextName, target: target }];
-                case 8: return [2 /*return*/, {
+                case 5: return [2 /*return*/, {
                         contextName: contextName,
                         target: target
                     }];
@@ -318,6 +290,30 @@ function getAndValidateSasjsFields(target, scope, insecure, authenticateCallback
         });
     });
 }
+/**
+ * Lists the compute contexts a target can execute in.
+ *
+ * `insecure` is the user's `--insecure` choice, and it is carried by the
+ * request only: the target that is saved afterwards is the one passed in.
+ */
+function getComputeContexts(target, scope, insecure) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sasjs;
+        return __generator(this, function (_a) {
+            sasjs = (0, utils_2.getSASjs)((0, utils_2.targetWithInsecureHttps)(target, insecure));
+            if (scope === targetScope_1.TargetScope.Local) {
+                dotenv_1.default.config({
+                    path: path_1.default.join(process.projectDir, ".env.".concat(target.name))
+                });
+                return [2 /*return*/, sasjs.getComputeContexts(process.env.ACCESS_TOKEN)];
+            }
+            if (!target.authConfig || !target.authConfig.access_token) {
+                throw new Error("No access token available for target ".concat(target.name, ". Please run `sasjs add cred -t ").concat(target.name, "` to authenticate."));
+            }
+            return [2 /*return*/, sasjs.getComputeContexts(target.authConfig.access_token)];
+        });
+    });
+}
 function getAndValidateAppLoc(targetName, target) {
     return __awaiter(this, void 0, void 0, function () {
         var errorMessage, appLoc;

package/build/commands/add/spec/addCredential.spec.js

@@ -68,6 +68,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -116,6 +127,96 @@ describe('addCredential', function () {
         });
     }); });
 });
+describe('addCredential - insecure connections', function () {
+    var viyaTarget = function () {
+        return new utils_1.Target({
+            name: 'test-insecure',
+            serverUrl: 'https://sas.example.com',
+            serverType: utils_1.ServerType.SasViya,
+            appLoc: '/test',
+            contextName: utils_2.contextName
+        });
+    };
+    beforeEach(function () {
+        process.projectDir = '.';
+        setupMocks();
+    });
+    afterEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.restoreAllMocks();
+                    return [4 /*yield*/, fileUtils.deleteFile(path_1.default.join('.', '.env.test-insecure'))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('uses an insecure agent for the token request when insecure is true', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy, requestTarget;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), true, types_1.TargetScope.Local)];
+                case 1:
+                    _a.sent();
+                    expect(getSASjsSpy).toHaveBeenCalled();
+                    requestTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(requestTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+                        allowInsecureRequests: true,
+                        rejectUnauthorized: false
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('does not write the insecure options to the saved target', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var saveSpy, _a, _b, call;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), true, types_1.TargetScope.Local)];
+                case 1:
+                    _d.sent();
+                    saveSpy = configUtils.saveToLocalConfig;
+                    expect(saveSpy).toHaveBeenCalled();
+                    try {
+                        for (_a = __values(saveSpy.mock.calls), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            call = _b.value;
+                            expect(call[0].httpsAgentOptions).toBeUndefined();
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the request target alone when insecure is false', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy, requestTarget;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), false, types_1.TargetScope.Local)];
+                case 1:
+                    _a.sent();
+                    requestTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(requestTarget.httpsAgentOptions).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 describe('validateTargetName', function () {
     it('should return the target name if valid', function () {
         var targetName = 'validTarget';

package/build/commands/add/spec/input.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/add/spec/input.spec.js

@@ -0,0 +1,159 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var targetScope_1 = require("../../../types/targetScope");
+var configUtils = __importStar(require("../../../utils/config"));
+var input_1 = require("../internal/input");
+describe('getComputeContexts', function () {
+    var contexts = [{ name: 'SAS Job Execution compute context' }];
+    var target = new utils_1.Target({
+        name: 'test-target',
+        serverUrl: 'https://sas.example.com',
+        serverType: utils_1.ServerType.SasViya,
+        appLoc: '/Public/app',
+        authConfig: {
+            client: 'client',
+            secret: 'secret',
+            access_token: 't0k3n',
+            refresh_token: 'r3fr3sh'
+        }
+    });
+    var setup = function () {
+        var contextsSpy = jest.fn().mockResolvedValue(contexts);
+        var getSASjsSpy = jest
+            .spyOn(configUtils, 'getSASjs')
+            .mockReturnValue({ getComputeContexts: contextsSpy });
+        return { contextsSpy: contextsSpy, getSASjsSpy: getSASjsSpy };
+    };
+    afterEach(function () {
+        jest.restoreAllMocks();
+    });
+    it('sends the insecure options with the request when insecure is true', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, contextsSpy, getSASjsSpy, usedTarget;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), contextsSpy = _a.contextsSpy, getSASjsSpy = _a.getSASjsSpy;
+                    return [4 /*yield*/, expect((0, input_1.getComputeContexts)(target, targetScope_1.TargetScope.Global, true)).resolves.toEqual(contexts)];
+                case 1:
+                    _b.sent();
+                    usedTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(usedTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+                        allowInsecureRequests: true,
+                        rejectUnauthorized: false
+                    }));
+                    expect(contextsSpy).toHaveBeenCalledWith('t0k3n');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('sends the target as it is when insecure is false', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = setup().getSASjsSpy;
+                    return [4 /*yield*/, (0, input_1.getComputeContexts)(target, targetScope_1.TargetScope.Global, false)];
+                case 1:
+                    _a.sent();
+                    expect(getSASjsSpy.mock.calls[0][0]).toBe(target);
+                    expect(target.httpsAgentOptions).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('throws when a global target has no access token', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var targetWithoutToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setup();
+                    targetWithoutToken = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { authConfig: { client: 'client', secret: 'secret' } }));
+                    return [4 /*yield*/, expect((0, input_1.getComputeContexts)(targetWithoutToken, targetScope_1.TargetScope.Global, false)).rejects.toThrow(/No access token available/)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/commands/auth/login.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -197,10 +186,9 @@ var authLogin = function (target_1) {
                     if (!target.serverUrl) {
                         throw new Error("Target '".concat(target.name, "' does not have a serverUrl configured."));
                     }
-                    if (insecure) {
-                        target = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) }));
+                    target = (0, utils_2.targetWithInsecureHttps)(target, insecure);
+                    if (insecure)
                         (_d = process.logger) === null || _d === void 0 ? void 0 : _d.warn('Executing with insecure connection.');
-                    }
                     isTty = !!process.stdin.isTTY;
                     envUser = process.env.SAS_USERNAME;
                     envPass = process.env.SAS_PASSWORD;

package/build/utils/index.d.ts

@@ -6,5 +6,6 @@ export * from './loadEnvVariables';
 export * from './saveLog';
 export * from './setConstants';
 export * from './setProjectDir';
+export * from './target';
 export * from './utils';
 export * from './validateTargetName';

package/build/utils/index.js

@@ -22,5 +22,6 @@ __exportStar(require("./loadEnvVariables"), exports);
 __exportStar(require("./saveLog"), exports);
 __exportStar(require("./setConstants"), exports);
 __exportStar(require("./setProjectDir"), exports);
+__exportStar(require("./target"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./validateTargetName"), exports);

package/build/utils/spec/target.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/spec/target.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var target_1 = require("../target");
+describe('targetWithInsecureHttps', function () {
+    var target = new utils_1.Target({
+        name: 'test-target',
+        serverUrl: 'https://sas.example.com',
+        serverType: utils_1.ServerType.SasViya,
+        appLoc: '/Public/app'
+    });
+    it('returns the target itself when insecure is false', function () {
+        expect((0, target_1.targetWithInsecureHttps)(target, false)).toBe(target);
+    });
+    it('returns a copy that accepts unverifiable certificates when insecure is true', function () {
+        var insecureTarget = (0, target_1.targetWithInsecureHttps)(target, true);
+        expect(insecureTarget).not.toBe(target);
+        expect(insecureTarget.serverUrl).toEqual(target.serverUrl);
+        expect(insecureTarget.appLoc).toEqual(target.appLoc);
+        expect(insecureTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+            allowInsecureRequests: true,
+            rejectUnauthorized: false
+        }));
+    });
+    it('leaves the original target unchanged', function () {
+        (0, target_1.targetWithInsecureHttps)(target, true);
+        expect(target.httpsAgentOptions).toBeUndefined();
+    });
+    it('keeps the httpsAgentOptions the target already carries', function () {
+        var withCaPath = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: { caPath: '/etc/ssl/private/intermediate.pem' } }));
+        var insecureTarget = (0, target_1.targetWithInsecureHttps)(withCaPath, true);
+        expect(insecureTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+            caPath: '/etc/ssl/private/intermediate.pem',
+            allowInsecureRequests: true,
+            rejectUnauthorized: false
+        }));
+        expect(withCaPath.httpsAgentOptions).toEqual(expect.not.objectContaining({ allowInsecureRequests: true }));
+    });
+});

package/build/utils/target.d.ts

@@ -0,0 +1,15 @@
+import { Target } from '@sasjs/utils/types';
+/**
+ * The target to make requests with, given the user's `--insecure` choice.
+ *
+ * Returns the target itself when `insecure` is false, and a copy whose
+ * `httpsAgentOptions` accept certificates that cannot be verified otherwise
+ * when it is true - a self-signed certificate, or a chain with the
+ * intermediate missing.
+ *
+ * The copy is deliberate: `--insecure` is a property of the invocation, not of
+ * the target, so the settings must not reach the configuration that is saved
+ * afterwards. Callers keep the original target for persistence and pass this
+ * one to `getSASjs` and to anything else that opens a connection.
+ */
+export declare const targetWithInsecureHttps: (target: Target, insecure: boolean) => Target;

package/build/utils/target.js

@@ -0,0 +1,34 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetWithInsecureHttps = void 0;
+var types_1 = require("@sasjs/utils/types");
+/**
+ * The target to make requests with, given the user's `--insecure` choice.
+ *
+ * Returns the target itself when `insecure` is false, and a copy whose
+ * `httpsAgentOptions` accept certificates that cannot be verified otherwise
+ * when it is true - a self-signed certificate, or a chain with the
+ * intermediate missing.
+ *
+ * The copy is deliberate: `--insecure` is a property of the invocation, not of
+ * the target, so the settings must not reach the configuration that is saved
+ * afterwards. Callers keep the original target for persistence and pass this
+ * one to `getSASjs` and to anything else that opens a connection.
+ */
+var targetWithInsecureHttps = function (target, insecure) {
+    return insecure
+        ? new types_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) }))
+        : target;
+};
+exports.targetWithInsecureHttps = targetWithInsecureHttps;

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.4.5"
+  "version": "6.4.6"
 }