@clickview/ship-it 0.0.1

package/lib/src/inversify.config.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainer = void 0;
+var inversify_1 = require("inversify");
+var api_clients_1 = require("./api-clients");
+var services_1 = require("./services");
+var commands_1 = require("./commands");
+var tasks_1 = require("./tasks");
+var types_1 = require("./types");
+function createContainer(config) {
+    var container = new inversify_1.Container();
+    /**
+     * Misc
+     */
+    container.bind(types_1.MISC.GitLabConfig).toConstantValue(config.gitLab);
+    /**
+     * Clients
+     */
+    container.bind(types_1.API_CLIENTS.GitLabApiClient).to(api_clients_1.GitLabApiClient);
+    /**
+     * Services
+     */
+    container.bind(types_1.SERVICES.GitLabService).to(services_1.GitLabService).inSingletonScope();
+    /**
+     * Tasks
+     */
+    container.bind(types_1.TASKS.ValidateTask).to(tasks_1.ValidateTask);
+    container.bind(types_1.TASKS.VersionTask).to(tasks_1.VersionTask);
+    container.bind(types_1.TASKS.CreateBranchTask).to(tasks_1.CreateBranchTask);
+    container.bind(types_1.TASKS.ValidateCommitsTask).to(tasks_1.ValidateCommitsTask);
+    container.bind(types_1.TASKS.BumpVersionTxtTask).to(tasks_1.BumpVersionTxtTask);
+    container.bind(types_1.TASKS.CreateMergeRequestTask).to(tasks_1.CreateMergeRequestTask);
+    container.bind(types_1.TASKS.ValidateDescriptionsTask).to(tasks_1.ValidateDescriptionsTask);
+    container.bind(types_1.TASKS.CreateReleaseNotesTask).to(tasks_1.CreateReleaseNotesTask);
+    container.bind(types_1.TASKS.BumpPackagesTask).to(tasks_1.BumpPackagesTask);
+    /**
+     * Commands
+     */
+    container.bind(types_1.COMMANDS.StatusCommand).to(commands_1.StatusCommand);
+    container.bind(types_1.COMMANDS.VersionCommand).to(commands_1.VersionCommand);
+    container.bind(types_1.COMMANDS.CreateBranchCommand).to(commands_1.CreateBranchCommand);
+    container.bind(types_1.COMMANDS.CreateMergeRequestCommand).to(commands_1.CreateMergeRequestCommand);
+    container.bind(types_1.COMMANDS.ReleaseCommand).to(commands_1.ReleaseCommand);
+    container.bind(types_1.COMMANDS.CreateReleaseNotesCommand).to(commands_1.CreateReleaseNotesCommand);
+    container.bind(types_1.COMMANDS.BumpPackagesCommand).to(commands_1.BumpPackagesCommand);
+    return container;
+}
+exports.createContainer = createContainer;

package/lib/src/services/GitLabService.js

@@ -0,0 +1,252 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabService = void 0;
+require("reflect-metadata");
+var inversify_1 = require("inversify");
+var lodash_1 = __importDefault(require("lodash"));
+var semver_1 = __importDefault(require("semver"));
+var types_1 = require("../types");
+var api_clients_1 = require("../api-clients");
+var GitLabService = /** @class */ (function () {
+    function GitLabService(apiClient) {
+        this._apiClient = apiClient;
+    }
+    GitLabService.prototype.getProjects = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mergeRequests, projectIds, projects;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._projects)
+                            return [2 /*return*/, this._projects];
+                        return [4 /*yield*/, this._apiClient.getMergeRequests(options)];
+                    case 1:
+                        mergeRequests = _a.sent();
+                        if (!(mergeRequests === null || mergeRequests === void 0 ? void 0 : mergeRequests.length))
+                            throw new Error('Could not find any merge requests for the specified options');
+                        projectIds = lodash_1.default.uniqBy(mergeRequests, function (m) { return m.projectId; }).map(function (m) { return m.projectId; });
+                        return [4 /*yield*/, this._apiClient.getProjectsByIds(projectIds)];
+                    case 2:
+                        projects = _a.sent();
+                        if (!(projects === null || projects === void 0 ? void 0 : projects.length) || projects.length !== projectIds.length)
+                            throw new Error('Could not find all projects for the found merge requests');
+                        return [2 /*return*/, (this._projects = projects.map(function (p) { return (__assign(__assign({}, p), { mergeRequests: mergeRequests.filter(function (mr) { return mr.projectId === p.id; }) })); }))];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.getDevCommitsSince = function (projectId, sinceSha) {
+        return __awaiter(this, void 0, void 0, function () {
+            var commits, lastDevCommit, title;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.getCommitsSince(projectId, 'dev', sinceSha)];
+                    case 1:
+                        commits = _a.sent();
+                        lastDevCommit = lodash_1.default.last(commits);
+                        title = lastDevCommit === null || lastDevCommit === void 0 ? void 0 : lastDevCommit.title.toLowerCase();
+                        if ((title === null || title === void 0 ? void 0 : title.includes('merge')) &&
+                            (title === null || title === void 0 ? void 0 : title.includes('master')) &&
+                            (title === null || title === void 0 ? void 0 : title.includes('dev'))) {
+                            commits.pop();
+                        }
+                        if (!(commits === null || commits === void 0 ? void 0 : commits.length))
+                            throw new Error("Could not find any commits in dev for projectId: ".concat(projectId, " since ").concat(sinceSha));
+                        return [2 /*return*/, commits];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.getBranch = function (projectId, branchName) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.getBranch(projectId, branchName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.createBranch = function (project, branchFrom, branchName, cherryPick) {
+        return __awaiter(this, void 0, void 0, function () {
+            var newBranch_1, i, mr, newBranch;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!cherryPick) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this._apiClient.createBranch(project.id, branchName, 'master')];
+                    case 1:
+                        newBranch_1 = _a.sent();
+                        if (!newBranch_1)
+                            throw new Error("Failed to create branch from master for projectId: ".concat(project.id));
+                        i = 0;
+                        _a.label = 2;
+                    case 2:
+                        if (!(i < project.mergeRequests.length)) return [3 /*break*/, 5];
+                        mr = project.mergeRequests[i];
+                        if (!mr.mergeCommit)
+                            throw new Error("Could not find the merge commit sha for MR: ".concat(mr.title, " in projectId: ").concat(project.id));
+                        return [4 /*yield*/, this._apiClient.cherryPick(project.id, mr.mergeCommit, branchName)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, newBranch_1];
+                    case 6: return [4 /*yield*/, this._apiClient.createBranch(project.id, branchName, branchFrom)];
+                    case 7:
+                        newBranch = _a.sent();
+                        if (!newBranch)
+                            throw new Error("Failed to create branch from master for projectId: ".concat(project.id));
+                        return [2 /*return*/, newBranch];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.getMergeRequest = function (projectId, branchName) {
+        return this._apiClient.getMergeRequest(projectId, branchName, 'master');
+    };
+    GitLabService.prototype.createMergeRequest = function (projectId, branchName, description) {
+        return this._apiClient.createMergeRequest(projectId, branchName, 'master', branchName, description);
+    };
+    GitLabService.prototype.bumpVersionTxt = function (projectId, branchName, newVersion) {
+        return __awaiter(this, void 0, void 0, function () {
+            var versionTxt, buff, text;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.getFile(projectId, 'version.txt', branchName)];
+                    case 1:
+                        versionTxt = _a.sent();
+                        if (!versionTxt)
+                            return [2 /*return*/, false];
+                        buff = Buffer.from(versionTxt.content, 'base64');
+                        text = buff.toString('utf-8');
+                        if (text === newVersion)
+                            return [2 /*return*/, false];
+                        return [4 /*yield*/, this._apiClient.updateFile(projectId, 'version.txt', branchName, newVersion, 'Bumping version.txt')];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.getFile = function (projectId, branchName, file) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.getFile(projectId, file, branchName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.updateFile = function (projectId, filePath, branchName, content, commit) {
+        return this._apiClient.updateFile(projectId, filePath, branchName, content, commit);
+    };
+    GitLabService.prototype.commit = function (projectId, branchName, commitMessage, files) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.commit(projectId, branchName, files, commitMessage)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GitLabService.prototype.getCurrentVersionTag = function (projectId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tags, tagNames, sortedTagNames, currentVersion, currentTag;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._apiClient.getLatestTags(projectId)];
+                    case 1:
+                        tags = _a.sent();
+                        if (!(tags === null || tags === void 0 ? void 0 : tags.length))
+                            return [2 /*return*/, null];
+                        tagNames = tags.map(function (t) { return t.name; }).filter(function (t) { return semver_1.default.valid(t); });
+                        if (!tagNames.length)
+                            return [2 /*return*/, null];
+                        sortedTagNames = semver_1.default.sort(tagNames);
+                        currentVersion = lodash_1.default.last(sortedTagNames);
+                        currentTag = tags.find(function (t) { return t.name === currentVersion; });
+                        if (!currentTag)
+                            return [2 /*return*/, null];
+                        return [2 /*return*/, currentTag];
+                }
+            });
+        });
+    };
+    GitLabService = __decorate([
+        (0, inversify_1.injectable)(),
+        __param(0, (0, inversify_1.inject)(types_1.API_CLIENTS.GitLabApiClient)),
+        __metadata("design:paramtypes", [api_clients_1.GitLabApiClient])
+    ], GitLabService);
+    return GitLabService;
+}());
+exports.GitLabService = GitLabService;

package/lib/src/services/index.js

@@ -0,0 +1,17 @@
+"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 __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(require("./GitLabService"), exports);