trm-core
Version:
TRM (Transport Request Manager) Core
253 lines (252 loc) • 12.7 kB
JavaScript
;
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 __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.init = void 0;
const trm_commons_1 = require("trm-commons");
const commons_1 = require("../../commons");
const trmPackage_1 = require("../../trmPackage");
const semver_1 = require("semver");
const systemConnector_1 = require("../../systemConnector");
const registry_1 = require("../../registry");
const transport_1 = require("../../transport");
const chalk_1 = __importDefault(require("chalk"));
function nextPrerelease(version, identifier) {
const pre = (0, semver_1.prerelease)(version);
const currentId = pre && typeof pre[0] === "string" ? String(pre[0]) : undefined;
if (identifier) {
return pre && currentId === identifier
? (0, semver_1.inc)(version, "prerelease", identifier)
: `${(0, semver_1.valid)(version)}-${identifier}.0`;
}
else {
return (0, semver_1.inc)(version, "prerelease", currentId);
}
}
function getHighestPrerelease(versions, baseVersion, identifier) {
const base = (0, semver_1.parse)(baseVersion);
const filtered = versions.filter((v) => {
const parsed = (0, semver_1.parse)((0, semver_1.clean)(v) || v, { loose: true });
if (!parsed)
return false;
const pre = (0, semver_1.prerelease)(parsed.version);
if (!pre)
return false;
const vBase = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
if (vBase !== `${base.major}.${base.minor}.${base.patch}`)
return false;
return identifier
? pre[0] === identifier
: typeof pre[0] === "number" || pre.length === 1;
});
if (filtered.length === 0)
return null;
return filtered.sort(semver_1.rcompare)[0];
}
exports.init = {
name: 'init',
run: (context) => __awaiter(void 0, void 0, void 0, function* () {
trm_commons_1.Logger.log('Init step', true);
const registry = context.rawInput.packageData.registry;
const parsedPackageName = (0, commons_1.parsePackageName)({
fullName: context.rawInput.packageData.name
});
context.rawInput.packageData.name = parsedPackageName.fullName;
if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
trm_commons_1.Logger.log(`Public registry, checking if logged in`, true);
yield registry.whoAmI();
}
if (!context.rawInput.contextData) {
context.rawInput.contextData = {};
}
if (!context.rawInput.systemData) {
context.rawInput.systemData = {};
}
if (!context.rawInput.publishData) {
context.rawInput.publishData = {
keepLatestReleaseManifestValues: true
};
}
if (context.rawInput.packageData.manifest === undefined) {
context.rawInput.packageData.manifest = {};
}
if (!context.rawInput.packageData.manifest.authors) {
context.rawInput.packageData.manifest.authors = [];
}
if (!context.rawInput.packageData.manifest.dependencies) {
context.rawInput.packageData.manifest.dependencies = [];
}
if (!context.rawInput.packageData.manifest.keywords) {
context.rawInput.packageData.manifest.keywords = [];
}
if (context.rawInput.packageData.manifest.sapEntries === undefined) {
context.rawInput.packageData.manifest.sapEntries = {};
}
if (!context.rawInput.packageData.manifest.postActivities) {
context.rawInput.packageData.manifest.postActivities = [];
}
if (!context.rawInput.publishData.customizingTransports) {
context.rawInput.publishData.customizingTransports = [];
}
if (typeof (context.rawInput.publishData.customizingTransports) === 'string') {
context.rawInput.publishData.customizingTransports = context.rawInput.publishData.customizingTransports.split(',').map(trkorr => new transport_1.Transport(trkorr));
}
if (!context.rawInput.packageData.tags) {
context.rawInput.packageData.tags = [];
}
trm_commons_1.Logger.loading(`Validating version...`);
var automaticVersion = false;
var releasesInRegistry;
var latestReleaseManifest;
context.rawInput.packageData.version = (0, semver_1.clean)(context.rawInput.packageData.version || '');
try {
trm_commons_1.Logger.loading(`Getting package latest release from registry...`, true);
const packageData = yield registry.getPackage(context.rawInput.packageData.name, 'latest');
latestReleaseManifest = packageData.manifest;
releasesInRegistry = packageData.versions;
}
catch (_a) { }
if (!latestReleaseManifest) {
if (!context.rawInput.packageData.version || !(0, semver_1.valid)(context.rawInput.packageData.version)) {
context.rawInput.packageData.version = '1.0.0';
automaticVersion = true;
}
if (context.rawInput.packageData.preRelease) {
context.rawInput.packageData.version = nextPrerelease(context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
}
}
else {
if (!context.rawInput.packageData.version || !(0, semver_1.valid)(context.rawInput.packageData.version)) {
context.rawInput.packageData.version = (0, semver_1.inc)(latestReleaseManifest.version, context.rawInput.packageData.inc || "patch");
automaticVersion = true;
}
else {
if (releasesInRegistry.includes(context.rawInput.packageData.version)) {
throw new Error(`Version "${context.rawInput.packageData.version}" already published.`);
}
if (context.rawInput.packageData.preRelease) {
const highestPreRelease = getHighestPrerelease(releasesInRegistry, context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
if (highestPreRelease) {
context.rawInput.packageData.version = highestPreRelease;
automaticVersion = true;
}
context.rawInput.packageData.version = nextPrerelease(context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
}
}
if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
trm_commons_1.Logger.log(`Public registry, checking if visibility is the same as latest release`, true);
if (typeof (context.rawInput.publishData.private) === 'boolean' && context.rawInput.publishData.private !== latestReleaseManifest.private) {
throw new Error(`Cannot change package visibility to ${context.rawInput.publishData.private ? 'private' : 'public'}`);
}
}
}
if (automaticVersion) {
trm_commons_1.Logger.info(`Automatically set publish version to "${context.rawInput.packageData.version}"`);
if (!context.rawInput.contextData.noInquirer) {
context.rawInput.packageData.version = (yield trm_commons_1.Inquirer.prompt([{
type: 'confirm',
message: `Continue publish as version "${context.rawInput.packageData.version}"?`,
default: true,
name: 'acceptDefaultVersion'
}, {
type: 'input',
message: `Input publish version`,
name: 'version',
default: context.rawInput.packageData.version,
when: (hash) => {
return !hash.acceptDefaultVersion;
},
validate: (v) => {
if ((0, semver_1.valid)(v)) {
if (releasesInRegistry.includes(v)) {
return `Version "${v}" already published.`;
}
else {
return true;
}
}
else {
return `Invalid version`;
}
}
}])).version || context.rawInput.packageData.version;
}
}
var isPrivate;
if (registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
isPrivate = true;
}
else {
isPrivate = typeof (context.rawInput.publishData.private) === 'undefined' ? (latestReleaseManifest ? latestReleaseManifest.private : undefined) : context.rawInput.publishData.private;
if (typeof (isPrivate) === 'undefined') {
isPrivate = (yield trm_commons_1.Inquirer.prompt({
type: "list",
message: "Package visibility",
name: "private",
default: isPrivate,
choices: [{
name: `Public`,
value: false
}, {
name: `Private`,
value: true
}]
})).private;
}
}
trm_commons_1.Logger.loading(`Validating data...`);
yield registry.validatePublish(context.rawInput.packageData.name, context.rawInput.packageData.version, isPrivate);
if (!latestReleaseManifest) {
trm_commons_1.Logger.info(`First time publishing "${context.rawInput.packageData.name}". Congratulations!`, registry.getRegistryType() === registry_1.RegistryType.LOCAL);
}
trm_commons_1.Logger.info(`Ready to publish ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`);
trm_commons_1.Logger.info(`Package visibility: ${chalk_1.default.bold(isPrivate ? 'private' : 'public')}`);
context.runtime = {
stopWarningShown: context.rawInput.contextData.noStopWarning ? true : false,
trmPackage: {
package: new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry),
registry,
latestReleaseManifest,
releasesInRegistry,
manifest: Object.assign(Object.assign({}, context.rawInput.packageData.manifest), {
name: context.rawInput.packageData.name,
version: context.rawInput.packageData.version,
private: isPrivate
})
},
systemData: {
transportTargets: [],
devcTransport: undefined,
tadirTransport: undefined,
releasedTransports: [],
originCustomizing: [],
custTransports: []
},
packageData: {
tadir: []
},
abapGitData: {
dotAbapGit: undefined,
sourceCode: {
ignoredObjects: [],
zip: undefined
}
}
};
trm_commons_1.Logger.loading(`Reading ${systemConnector_1.SystemConnector.getDest()} transport targets...`);
context.runtime.systemData.transportTargets = yield systemConnector_1.SystemConnector.getTransportTargets();
if (context.rawInput.publishData.skipCustomizingTransports) {
context.rawInput.publishData.customizingTransports = [];
}
})
};