@sasjs/cli 3.23.7 → 3.24.1

package/build/commands/fs/fsCommand.d.ts

@@ -7,5 +7,6 @@ export declare class FSCommand extends TargetCommand {
     getOutputPath(): Promise<string>;
     execute(): Promise<ReturnCode>;
     compile(): Promise<ReturnCode>;
+    deploy(): Promise<ReturnCode.Success | ReturnCode.InternalError>;
     sync(): Promise<ReturnCode.Success | ReturnCode.InternalError>;
 }

package/build/commands/fs/fsCommand.js

@@ -112,6 +112,7 @@ var FsSubCommand;
 (function (FsSubCommand) {
     FsSubCommand["Compile"] = "compile";
     FsSubCommand["Sync"] = "sync";
+    FsSubCommand["Deploy"] = "deploy";
 })(FsSubCommand || (FsSubCommand = {}));
 var syntax = 'fs <subCommand> [options]';
 var usage = 'Usage: sasjs fs <subCommand> [options]';
@@ -146,6 +147,15 @@ var syncCommandExamples = [
     }
 ];
 var syncCommandParseOptions = __assign(__assign({}, parseOptions), { local: { type: 'string', alias: 'l' }, remote: { type: 'string', alias: 'r' } });
+var deployCommandSyntax = 'fs <subCommand> <local> <remote> [options]';
+var deployCommandUsage = 'sasjs fs deploy <localFolder> <remoteFolder> [options]';
+var deployCommandDescription = 'Compiles and deploys a local directory tree with one on a remote SAS server.';
+var deployCommandExamples = [
+    {
+        command: 'sasjs fs deploy <path/of/folder> --output <path/of/outputProgram>',
+        description: 'deploys a SAS program with the contents of a local directory'
+    }
+];
 var FSCommand = /** @class */ (function (_super) {
     __extends(FSCommand, _super);
     function FSCommand(args) {
@@ -164,6 +174,12 @@ var FSCommand = /** @class */ (function (_super) {
                 commandOptions.description = compileCommandDescription;
                 commandOptions.examples = compileCommandExamples;
                 break;
+            case FsSubCommand.Deploy:
+                commandOptions.syntax = deployCommandSyntax;
+                commandOptions.usage = deployCommandUsage;
+                commandOptions.description = deployCommandDescription;
+                commandOptions.examples = deployCommandExamples;
+                break;
             case FsSubCommand.Sync:
                 commandOptions.syntax = syncCommandSyntax;
                 commandOptions.usage = syncCommandUsage;
@@ -210,7 +226,7 @@ var FSCommand = /** @class */ (function (_super) {
                     }
                 }
                 if (!outputPath) {
-                    return [2 /*return*/, path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, 'fs-sync', (0, utils_2.generateTimestamp)())];
+                    return [2 /*return*/, path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, "fs-".concat(this.parsed.subCommand), (0, utils_2.generateTimestamp)())];
                 }
                 if (path_1.default.isAbsolute(outputPath)) {
                     return [2 /*return*/, path_1.default.join(outputPath, (0, utils_2.generateTimestamp)())];
@@ -228,10 +244,14 @@ var FSCommand = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.compile()];
                     case 1: return [2 /*return*/, _a.sent()];
                     case 2:
-                        if (!(this.parsed.subCommand === FsSubCommand.Sync)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.sync()];
+                        if (!(this.parsed.subCommand === FsSubCommand.Deploy)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.deploy()];
                     case 3: return [2 /*return*/, _a.sent()];
-                    case 4: return [2 /*return*/, command_1.ReturnCode.InvalidCommand];
+                    case 4:
+                        if (!(this.parsed.subCommand === FsSubCommand.Sync)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.sync()];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: return [2 /*return*/, command_1.ReturnCode.InvalidCommand];
                 }
             });
         });
@@ -264,6 +284,64 @@ var FSCommand = /** @class */ (function (_super) {
             });
         });
     };
+    FSCommand.prototype.deploy = function () {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function () {
+            var target, remoteFolderPath, localFolderPath, outputFolder, code, program, error_1, logPath;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getTargetInfo()];
+                    case 1:
+                        target = (_f.sent()).target;
+                        remoteFolderPath = this.remoteFolder;
+                        localFolderPath = this.localFolder;
+                        return [4 /*yield*/, this.getOutputPath()];
+                    case 2:
+                        outputFolder = _f.sent();
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 7, , 9]);
+                        (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info('generating compile program');
+                        return [4 /*yield*/, (0, utils_2.generateCompileProgram)(localFolderPath)];
+                    case 4:
+                        code = _f.sent();
+                        (_b = process.logger) === null || _b === void 0 ? void 0 : _b.info('setting fsTaregt at the start of compiled program');
+                        program = "%let fsTarget=".concat((0, utils_2.generatePathForSas)(remoteFolderPath), ";\n").concat(code);
+                        return [4 /*yield*/, createProgramFile(program, path_1.default.join(outputFolder, 'deploy.sas'))];
+                    case 5:
+                        _f.sent();
+                        (_c = process.logger) === null || _c === void 0 ? void 0 : _c.info('executing program to deploy a local directory tree');
+                        return [4 /*yield*/, (0, executeCode_1.executeCode)(target, program).then(function (_a) {
+                                var log = _a.log;
+                                return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
+                                            case 0: return [4 /*yield*/, (0, utils_1.saveLog)(log, path_1.default.join(outputFolder, 'deploy.log'), '', false)];
+                                            case 1:
+                                                _b.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            })];
+                    case 6:
+                        _f.sent();
+                        (_d = process.logger) === null || _d === void 0 ? void 0 : _d.success("A local directory tree has been successfully deployed to remote sas server");
+                        return [2 /*return*/, command_1.ReturnCode.Success];
+                    case 7:
+                        error_1 = _f.sent();
+                        logPath = path_1.default.join(outputFolder, 'error.log');
+                        return [4 /*yield*/, createErrorLogFile(error_1, logPath)];
+                    case 8:
+                        _f.sent();
+                        (_e = process.logger) === null || _e === void 0 ? void 0 : _e.error("An error has occurred. For more info see ".concat(logPath));
+                        return [2 /*return*/, command_1.ReturnCode.InternalError];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
     FSCommand.prototype.sync = function () {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         return __awaiter(this, void 0, void 0, function () {
@@ -294,7 +372,7 @@ var FSCommand = /** @class */ (function (_super) {
                             return [2 /*return*/, command_1.ReturnCode.Success];
                         }
                         _loop_1 = function (obj) {
-                            var outputFolder, program, log, remoteHashes, localHash, remoteHashMap_1, hashedDiff, syncProgram, syncLog, syncedHash, syncedHashMap, syncedResources_1, resourcesNotPresentLocally, error_1, logPath;
+                            var outputFolder, program, log, remoteHashes, localHash, remoteHashMap_1, hashedDiff, syncProgram, syncLog, syncedHash, syncedHashMap, syncedResources_1, resourcesNotPresentLocally, error_2, logPath;
                             return __generator(this, function (_v) {
                                 switch (_v.label) {
                                     case 0: return [4 /*yield*/, this_1.getOutputPath()];
@@ -390,9 +468,9 @@ var FSCommand = /** @class */ (function (_super) {
                                         }
                                         return [3 /*break*/, 17];
                                     case 15:
-                                        error_1 = _v.sent();
+                                        error_2 = _v.sent();
                                         logPath = path_1.default.join(outputFolder, 'error.log');
-                                        return [4 /*yield*/, createErrorLogFile(error_1, logPath)];
+                                        return [4 /*yield*/, createErrorLogFile(error_2, logPath)];
                                     case 16:
                                         _v.sent();
                                         (_m = process.logger) === null || _m === void 0 ? void 0 : _m.error("An error has occurred. For more info see ".concat(logPath));

package/build/commands/fs/spec/fsCommand.spec.js

@@ -153,6 +153,67 @@ describe('FSCommand', function () {
             });
         }); });
     });
+    describe('deploy', function () {
+        beforeEach(function () {
+            process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+            jest.spyOn(process.logger, 'error');
+            jest.spyOn(process.logger, 'info');
+            jest
+                .spyOn(configUtils, 'findTargetInConfiguration')
+                .mockImplementation(function () {
+                return Promise.resolve({ target: target, isLocal: true });
+            });
+            jest
+                .spyOn(FSModule, 'generateCompileProgram')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            jest
+                .spyOn(FileModule, 'createFile')
+                .mockImplementation(function () { return Promise.resolve(); });
+            jest
+                .spyOn(executeCodeModule, 'executeCode')
+                .mockImplementation(function () { return Promise.resolve({ log: '' }); });
+        });
+        it('should compile and deploy a local directory tree to a remote sas server', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(FileModule, 'createFile')
+                            .mockImplementation(function () { return Promise.resolve(); });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should return an internal error return code', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(FileModule, 'createFile')
+                            .mockImplementationOnce(function () { return Promise.reject({}); });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.InternalError);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
     describe('sync', function () {
         beforeEach(function () {
             process.logger = new utils_1.Logger(utils_1.LogLevel.Off);

package/package.json

@@ -52,7 +52,7 @@
   "dependencies": {
     "@sasjs/adapter": "4.1.0",
     "@sasjs/core": "4.45.4",
-    "@sasjs/lint": "2.0.1",
+    "@sasjs/lint": "2.1.2",
     "@sasjs/utils": "2.51.5",
     "adm-zip": "0.5.9",
     "chalk": "4.1.2",
@@ -101,5 +101,5 @@
     "typescript": "4.5.4",
     "util": "0.12.4"
   },
-  "version": "3.23.7"
+  "version": "3.24.1"
 }