@sasjs/cli 6.2.7 → 6.4.0

package/build/commands/compile/internal/spec/compileTestFile.spec.js

@@ -51,6 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var __1 = require("../");
+var compileTestFile_1 = require("../compileTestFile");
 var utils_1 = require("@sasjs/utils");
 var test_1 = require("../../../../utils/test");
 var path_1 = __importDefault(require("path"));
@@ -391,6 +392,163 @@ describe('compileTestFile', function () {
                 }
             });
         }); });
+        it('should write the coverage report to the build folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var report, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 2:
+                        report = _b.apply(_a, [_c.sent()]);
+                        expect(report.summary).toEqual({
+                            services: { covered: 0, total: 4, percentage: 0 },
+                            jobs: { covered: 0, total: 0, percentage: 0 },
+                            macros: { covered: 0, total: 0, percentage: 0 },
+                            overall: { covered: 0, total: 4, percentage: 0 }
+                        });
+                        // the same rows the console table lists, standalone tests included
+                        expect(report.files[['services', 'common', 'appinit.sas'].join('/')]).toEqual({ Type: 'service', Coverage: 'not covered' });
+                        expect(report.files[['tests', 'jobs', 'jobs', 'testJob.test.sas'].join('/')]).toEqual({ Type: 'test', Coverage: 'standalone' });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should key the report by project-relative paths, never build machine paths', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var macroPath, tableSpy, report, _a, _b, tableRows;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        macroPath = path_1.default.join(sasjsPath, 'macros', 'uncoveredmacro.sas');
+                        tableSpy = jest
+                            .spyOn(process.logger, 'table')
+                            .mockImplementation(function () { return ''; });
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroPath, '%macro uncoveredmacro(); %mend uncoveredmacro;')];
+                    case 1:
+                        _c.sent();
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, , 5, 7]);
+                        return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 3:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 4:
+                        report = _b.apply(_a, [_c.sent()]);
+                        // macros are keyed like services and jobs, in the report and in the
+                        // console table alike - a build machine path in either would make the
+                        // same project produce different output elsewhere.
+                        expect(report.files['macros/uncoveredmacro.sas']).toEqual({
+                            Type: 'macro',
+                            Coverage: 'not covered'
+                        });
+                        expect(Object.keys(report.files).filter(function (key) { return path_1.default.isAbsolute(key); })).toEqual([]);
+                        expect(report.summary.macros).toEqual({
+                            covered: 0,
+                            total: 1,
+                            percentage: 0
+                        });
+                        tableRows = tableSpy.mock.calls[0][0];
+                        expect(tableRows).toContainEqual([
+                            'macros/uncoveredmacro.sas',
+                            'macro',
+                            'not covered'
+                        ]);
+                        expect(tableRows.flat().filter(function (cell) { return path_1.default.isAbsolute(cell); })).toEqual([]);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, (0, utils_1.deleteFile)(macroPath)];
+                    case 6:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should mark covered files in the report, not just the gaps', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var macroPath, macroTestPath, tableSpy, report, _a, _b, tableRows;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        macroPath = path_1.default.join(sasjsPath, 'macros', 'coveredmacro.sas');
+                        macroTestPath = path_1.default.join(sasjsPath, 'macros', 'coveredmacro.test.sas');
+                        tableSpy = jest
+                            .spyOn(process.logger, 'table')
+                            .mockImplementation(function () { return ''; });
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroPath, '%macro coveredmacro(); %mend coveredmacro;')];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroTestPath, '%put testing coveredmacro;')];
+                    case 2:
+                        _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, , 6, 9]);
+                        return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 4:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 5:
+                        report = _b.apply(_a, [_c.sent()]);
+                        expect(report.files['macros/coveredmacro.sas']).toEqual({
+                            Type: 'macro',
+                            Coverage: 'covered'
+                        });
+                        expect(report.summary.macros).toEqual({
+                            covered: 1,
+                            total: 1,
+                            percentage: 100
+                        });
+                        tableRows = tableSpy.mock.calls[0][0];
+                        expect(tableRows).toContainEqual([
+                            'macros/coveredmacro.sas',
+                            'macro',
+                            'covered'
+                        ]);
+                        return [3 /*break*/, 9];
+                    case 6: return [4 /*yield*/, (0, utils_1.deleteFile)(macroPath)];
+                    case 7:
+                        _c.sent();
+                        return [4 /*yield*/, (0, utils_1.deleteFile)(macroTestPath)];
+                    case 8:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should not write a coverage report when no tests were compiled', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var coveragePath, testFlow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        coveragePath = path_1.default.join(buildPath, compileTestFile_1.coverageFileName);
+                        // remove the report the compile wrote, so the assertion below is about
+                        // the no-tests path and not about a file left over from it
+                        return [4 /*yield*/, (0, utils_1.deleteFile)(coveragePath)];
+                    case 2:
+                        // remove the report the compile wrote, so the assertion below is about
+                        // the no-tests path and not about a file left over from it
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_1.deleteFolder)(path_1.default.join(buildPath, 'tests'))];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, (0, __1.compileTestFlow)(target)];
+                    case 4:
+                        testFlow = _a.sent();
+                        expect(testFlow).toBeUndefined();
+                        return [4 /*yield*/, expect((0, utils_1.fileExists)(coveragePath)).resolves.toEqual(false)];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('should log a warning is testFolders was used in root or target configuration', function () { return __awaiter(void 0, void 0, void 0, function () {
             var testTarget, testConfig, expectedWarn;
             return __generator(this, function (_a) {

package/build/commands/help/help.js

@@ -97,6 +97,7 @@ function printHelpText() {
                         "compiles the services specified in the ".concat(chalk_1.default.cyanBright('serviceFolders'), " property of the 'serviceConfig' in your target and common configuration."),
                         "A single file is compiled by naming its type as a sub command - ".concat(chalk_1.default.cyanBright('job'), ", ").concat(chalk_1.default.cyanBright('service'), ", ").concat(chalk_1.default.cyanBright('test'), " or ").concat(chalk_1.default.cyanBright('identify'), ", which works the type out from the file itself - together with ").concat(chalk_1.default.cyanBright('--source'), " (or ").concat(chalk_1.default.cyanBright('-s'), ")."),
                         "The compiled file is written to the ".concat(chalk_1.default.cyanBright('jobs'), " or ").concat(chalk_1.default.cyanBright('services'), " folder of sasjsbuild for its type, or below ").concat(chalk_1.default.cyanBright('--output'), " (or ").concat(chalk_1.default.cyanBright('-o'), ") when given."),
+                        "The test coverage report is written to ".concat(chalk_1.default.cyanBright('coverage.json'), " in the build folder alongside ").concat(chalk_1.default.cyanBright('testFlow.json'), "."),
                         "command example: sasjs compile identify --source sasjs/jobs/daily/load.sas --target myTarget"
                     ]
                 },

package/build/types/index.d.ts

@@ -2,6 +2,6 @@ export { CommandBase } from './command/commandBase';
 export { File, FilePath } from './file';
 export { Folder } from './folder';
 export { TargetScope } from './targetScope';
-export { TestFlow, Coverage, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
+export { TestFlow, Coverage, CoverageReport, CoverageSummary, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
 export { Flow, FlowWave, FlowWaveJob } from './flow';
 export * from './log';

package/build/types/testing.d.ts

@@ -12,6 +12,7 @@ export declare enum CoverageType {
 }
 export declare enum CoverageState {
     notCovered = "not covered",
+    covered = "covered",
     standalone = "standalone"
 }
 export interface Coverage {
@@ -20,6 +21,38 @@ export interface Coverage {
         Coverage: CoverageState;
     };
 }
+/**
+ * Totals for one group of files (services, jobs, macros or all of them).
+ * `percentage` is rounded to a whole number, matching the figure printed in
+ * the console summary.
+ */
+export interface CoverageSummary {
+    covered: number;
+    total: number;
+    percentage: number;
+}
+/**
+ * The content of the coverage report `sasjs compile` writes to
+ * `coverage.json` in the build folder.
+ *
+ * `summary` carries the same totals as the console output. `files` is a
+ * complete per-file map - every service, job and macro the compile found,
+ * each marked `covered` or `not covered`, plus standalone tests - keyed by
+ * project-relative path (`services/common/appinit.sas`,
+ * `macros/mymacro.sas`), never by a path from the machine that compiled it.
+ *
+ * The console table renders this same map, so the rows a reader sees and the
+ * keys a consumer reads are the same, covered rows included.
+ */
+export interface CoverageReport {
+    summary: {
+        services: CoverageSummary;
+        jobs: CoverageSummary;
+        macros: CoverageSummary;
+        overall: CoverageSummary;
+    };
+    files: Coverage;
+}
 export interface TestResultDescription {
     TEST_DESCRIPTION: string;
     TEST_RESULT: TestResultStatus.pass | TestResultStatus.fail;

package/build/types/testing.js

@@ -11,6 +11,7 @@ var CoverageType;
 var CoverageState;
 (function (CoverageState) {
     CoverageState["notCovered"] = "not covered";
+    CoverageState["covered"] = "covered";
     CoverageState["standalone"] = "standalone";
 })(CoverageState || (exports.CoverageState = CoverageState = {}));
 var TestResultStatus;

package/build/utils/auth.d.ts

@@ -59,3 +59,33 @@ export declare function getNewAccessToken(sasjsInstance: SASjs, clientId: string
     access_token: string;
     refresh_token: string;
 }>;
+/**
+ * Mints a token pair from the local login of a SASjs Server target.
+ *
+ * SASjs Server has no secret-less OAuth client and no password grant: the
+ * tokens it issues come from its own sign-in flow, the one its web app uses.
+ * Reproducing that flow here is what makes `sasjs auth login` usable on a SASjs
+ * target from CI, where there is no browser to visit /SASjsLogon and no
+ * administrator-registered client secret to fall back on:
+ *
+ *   GET  /                     sets the XSRF-TOKEN cookie
+ *   POST /SASLogon/login       creates the session
+ *   POST /SASLogon/authorize   returns a single-use authorization code
+ *   POST /SASjsApi/auth/token  exchanges it for an access/refresh pair
+ *
+ * @param {Target} target - the SASJS target to authenticate against.
+ * @param {string} user - the SASjs Server username.
+ * @param {string} pass - the SASjs Server password.
+ * @param {string} [clientId] - the registered client to authorize, usually from
+ *   the SASJS_CLIENT environment variable. When absent, the target's configured
+ *   client is used, and failing that the first registered client if the account
+ *   is an administrator.
+ * @returns the token pair, the client that was authorized, and the display name
+ *   the server reports for the user.
+ */
+export declare function getTokensWithSasjsLogin(target: Target, user: string, pass: string, clientId?: string): Promise<{
+    access_token: string;
+    refresh_token: string;
+    client: string;
+    displayName?: string;
+}>;

package/build/utils/auth.js

@@ -1,4 +1,37 @@
 "use strict";
+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) {
@@ -35,6 +68,34 @@ 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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SAS_CLI_CLIENT_ID = exports.getAuthUrl = void 0;
 exports.getAuthCode = getAuthCode;
@@ -42,6 +103,9 @@ exports.refreshTokens = refreshTokens;
 exports.getTokensWithPasswordGrant = getTokensWithPasswordGrant;
 exports.fetchLoggedInUser = fetchLoggedInUser;
 exports.getNewAccessToken = getNewAccessToken;
+exports.getTokensWithSasjsLogin = getTokensWithSasjsLogin;
+var axios_1 = __importDefault(require("axios"));
+var https = __importStar(require("https"));
 var utils_1 = require("@sasjs/utils");
 var node_1 = require("@sasjs/adapter/node");
 /**
@@ -217,3 +281,169 @@ function getNewAccessToken(sasjsInstance, clientId, clientSecret, target) {
         });
     });
 }
+/**
+ * Mints a token pair from the local login of a SASjs Server target.
+ *
+ * SASjs Server has no secret-less OAuth client and no password grant: the
+ * tokens it issues come from its own sign-in flow, the one its web app uses.
+ * Reproducing that flow here is what makes `sasjs auth login` usable on a SASjs
+ * target from CI, where there is no browser to visit /SASjsLogon and no
+ * administrator-registered client secret to fall back on:
+ *
+ *   GET  /                     sets the XSRF-TOKEN cookie
+ *   POST /SASLogon/login       creates the session
+ *   POST /SASLogon/authorize   returns a single-use authorization code
+ *   POST /SASjsApi/auth/token  exchanges it for an access/refresh pair
+ *
+ * @param {Target} target - the SASJS target to authenticate against.
+ * @param {string} user - the SASjs Server username.
+ * @param {string} pass - the SASjs Server password.
+ * @param {string} [clientId] - the registered client to authorize, usually from
+ *   the SASJS_CLIENT environment variable. When absent, the target's configured
+ *   client is used, and failing that the first registered client if the account
+ *   is an administrator.
+ * @returns the token pair, the client that was authorized, and the display name
+ *   the server reports for the user.
+ */
+function getTokensWithSasjsLogin(target, user, pass, clientId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var baseUrl, cookies, safeDecode, collectCookies, instance, call, fail, login, client, clients, authorized, code, tokens;
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    baseUrl = target.serverUrl.replace(/\/+$/, '');
+                    cookies = new Map();
+                    safeDecode = function (value) {
+                        try {
+                            return decodeURIComponent(value);
+                        }
+                        catch (_a) {
+                            return value;
+                        }
+                    };
+                    collectCookies = function (setCookie) {
+                        var entries = Array.isArray(setCookie)
+                            ? setCookie
+                            : setCookie
+                                ? [setCookie]
+                                : [];
+                        entries.forEach(function (entry) {
+                            var pair = entry.split(';')[0];
+                            var index = pair.indexOf('=');
+                            if (index > 0) {
+                                cookies.set(pair.slice(0, index).trim(), pair.slice(index + 1).trim());
+                            }
+                        });
+                    };
+                    instance = axios_1.default.create({
+                        baseURL: baseUrl,
+                        validateStatus: function () { return true; },
+                        // The login request carries the password in a body, so a redirect must not
+                        // replay it to wherever 'Location' points. A redirect is a configuration
+                        // problem (proxy, SSO front end) - report it instead of following it.
+                        maxRedirects: 0,
+                        httpsAgent: target.httpsAgentOptions
+                            ? new https.Agent(target.httpsAgentOptions)
+                            : undefined,
+                        headers: { Accept: 'application/json' }
+                    });
+                    call = function (method, path, data) { return __awaiter(_this, void 0, void 0, function () {
+                        var headers, xsrf, response;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    headers = {};
+                                    if (cookies.size) {
+                                        headers.Cookie = __spreadArray([], __read(cookies), false).map(function (_a) {
+                                            var _b = __read(_a, 2), name = _b[0], value = _b[1];
+                                            return "".concat(name, "=").concat(value);
+                                        })
+                                            .join('; ');
+                                    }
+                                    xsrf = cookies.get('XSRF-TOKEN');
+                                    if (xsrf)
+                                        headers['X-XSRF-TOKEN'] = safeDecode(xsrf);
+                                    return [4 /*yield*/, instance.request({
+                                            method: method,
+                                            url: path,
+                                            data: data,
+                                            headers: headers
+                                        })];
+                                case 1:
+                                    response = _a.sent();
+                                    if (response.status >= 300 && response.status < 400) {
+                                        throw new Error("".concat(baseUrl).concat(path, " answered with a ").concat(response.status, " redirect to ") +
+                                            "'".concat(response.headers.location || 'unknown', "'. It is not followed: ") +
+                                            "the sign-in request carries the password. Point the target at the " +
+                                            "final URL.");
+                                    }
+                                    collectCookies(response.headers['set-cookie']);
+                                    return [2 /*return*/, response];
+                            }
+                        });
+                    }); };
+                    fail = function (message) {
+                        return new Error("".concat(message, "\nCheck that '").concat(user, "' can sign in to ").concat(target.serverUrl, ", and that ") +
+                            "the client id is set (SASJS_CLIENT) if the account is not an administrator.");
+                    };
+                    // GET / serves the single page app but sets the XSRF cookie the login needs.
+                    return [4 /*yield*/, call('get', '/')];
+                case 1:
+                    // GET / serves the single page app but sets the XSRF cookie the login needs.
+                    _k.sent();
+                    return [4 /*yield*/, call('post', '/SASLogon/login', {
+                            username: user,
+                            password: pass
+                        })];
+                case 2:
+                    login = _k.sent();
+                    if (login.status !== 200 || !((_a = login.data) === null || _a === void 0 ? void 0 : _a.loggedIn)) {
+                        throw fail("Login failed for user '".concat(user, "' on ").concat(target.serverUrl, " (HTTP ").concat(login.status, ")."));
+                    }
+                    client = clientId || ((_b = target.authConfig) === null || _b === void 0 ? void 0 : _b.client) || '';
+                    if (!!client) return [3 /*break*/, 4];
+                    return [4 /*yield*/, call('get', '/SASjsApi/client')];
+                case 3:
+                    clients = _k.sent();
+                    if (Array.isArray(clients.data) && clients.data.length) {
+                        client = clients.data[0].clientId;
+                        // Say which one was picked: the listing order is the server's, and a
+                        // silent choice here is impossible to debug from the tokens alone.
+                        (_c = process.logger) === null || _c === void 0 ? void 0 : _c.info("Using the first registered client ('".concat(client, "'). Set SASJS_CLIENT ") +
+                            "to authorize a specific client.");
+                    }
+                    _k.label = 4;
+                case 4:
+                    if (!client) {
+                        throw fail('No client id is available to authorize.');
+                    }
+                    return [4 /*yield*/, call('post', '/SASLogon/authorize', {
+                            clientId: client
+                        })];
+                case 5:
+                    authorized = _k.sent();
+                    code = (_d = authorized.data) === null || _d === void 0 ? void 0 : _d.code;
+                    if (!code) {
+                        throw fail("Authorization failed for client '".concat(client, "' (HTTP ").concat(authorized.status, ")."));
+                    }
+                    return [4 /*yield*/, call('post', '/SASjsApi/auth/token', {
+                            clientId: client,
+                            code: code
+                        })];
+                case 6:
+                    tokens = _k.sent();
+                    if (!((_e = tokens.data) === null || _e === void 0 ? void 0 : _e.accessToken)) {
+                        throw fail("The token endpoint returned no access token (HTTP ".concat(tokens.status, ")."));
+                    }
+                    return [2 /*return*/, {
+                            access_token: tokens.data.accessToken,
+                            refresh_token: tokens.data.refreshToken || '',
+                            client: client,
+                            displayName: ((_g = (_f = login.data) === null || _f === void 0 ? void 0 : _f.user) === null || _g === void 0 ? void 0 : _g.displayName) || ((_j = (_h = login.data) === null || _h === void 0 ? void 0 : _h.user) === null || _j === void 0 ? void 0 : _j.username)
+                        }];
+            }
+        });
+    });
+}

package/build/utils/config.js

@@ -968,7 +968,7 @@ var saveTokens = function (targetName, access_token, refresh_token, client, secr
                 if (!isLocalTarget) return [3 /*break*/, 3];
                 VERBOSE = process.env.VERBOSE;
                 clientSecretContent = client
-                    ? "CLIENT=".concat(client, "\nSECRET=").concat(secret || '', "\n")
+                    ? "CLIENT=".concat(client, "\n").concat(secret ? "SECRET=".concat(secret, "\n") : '')
                     : '';
                 envFileContent = "".concat(clientSecretContent, "ACCESS_TOKEN=").concat(access_token, "\nREFRESH_TOKEN=").concat(refresh_token, "\n").concat(VERBOSE ? 'VERBOSE=' + VERBOSE + '\n' : '');
                 envFilePath = path_1.default.join(process.projectDir, ".env.".concat(targetName));
@@ -986,7 +986,7 @@ var saveTokens = function (targetName, access_token, refresh_token, client, secr
                 }
                 targetJson = __assign({}, target);
                 targetJson.authConfig = __assign(__assign(__assign({}, (targetJson.authConfig || {})), (client
-                    ? { client: client, secret: secret || '' }
+                    ? { client: client, secret: secret || undefined }
                     : { client: undefined, secret: undefined })), { access_token: access_token, refresh_token: refresh_token });
                 return [4 /*yield*/, saveToGlobalConfig(new utils_1.Target(targetJson), globalConfig.defaultTarget === targetName)];
             case 5:

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

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