trm-core
Version:
TRM (Transport Request Manager) Core
208 lines (207 loc) • 10.3 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 logger_1 = require("../../logger");
const commons_1 = require("../../commons");
const trmPackage_1 = require("../../trmPackage");
const inquirer_1 = require("../../inquirer");
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"));
exports.init = {
name: 'init',
run: (context) => __awaiter(void 0, void 0, void 0, function* () {
logger_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) {
logger_1.Logger.log(`Public registry, checking if logged in`, true);
yield registry.whoAmI();
logger_1.Logger.log(`Public registry, checking if package name is ok`, true);
if (parsedPackageName.organization && parsedPackageName.organization.length > 20) {
throw new Error(`Invalid org "${parsedPackageName.organization}": length must be 20 characters long or less.`);
}
if (parsedPackageName.name.length > 20) {
throw new Error(`Invalid package name "${parsedPackageName.name}": length must be 20 characters long or less.`);
}
}
if (!context.rawInput.contextData) {
context.rawInput.contextData = {};
}
if (!context.rawInput.systemData) {
context.rawInput.systemData = {
releaseTimeout: 180
};
}
if (!context.rawInput.publishData) {
context.rawInput.publishData = {
keepLatestReleaseManifestValues: true,
customizingTransports: []
};
}
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 (typeof (context.rawInput.publishData.customizingTransports) === 'string') {
context.rawInput.publishData.customizingTransports = context.rawInput.publishData.customizingTransports.split(',').map(o => {
try {
return new transport_1.Transport(o.trim());
}
catch (e) {
throw new Error(`Invalid customizing transport values: trkorr.`);
}
});
}
if (!context.rawInput.packageData.version) {
context.rawInput.packageData.version = 'latest';
}
var normalizeVersion = true;
var normalizedVersion;
logger_1.Logger.loading(`Checking package version...`);
while (normalizeVersion) {
normalizedVersion = yield trmPackage_1.TrmPackage.normalizeVersion(context.rawInput.packageData.name, context.rawInput.packageData.version, registry);
if (normalizedVersion !== context.rawInput.packageData.version) {
logger_1.Logger.info(`Version ${context.rawInput.packageData.version} -> ${normalizedVersion}`);
if (!context.rawInput.contextData.noInquirer) {
const inq = yield inquirer_1.Inquirer.prompt([{
name: 'acceptNormalized',
message: `Continue publish as version ${normalizedVersion}?`,
type: 'confirm',
default: true
}, {
name: 'inputVersion',
message: `Input version to publish`,
type: 'input',
when: (hash) => {
return !hash.acceptNormalized;
},
validate: (input) => {
if (!input) {
return false;
}
else {
if (input.trim().toLowerCase() === 'latest') {
return true;
}
else {
return (0, semver_1.clean)(input) ? true : false;
}
}
}
}]);
if (inq.acceptNormalized) {
normalizeVersion = false;
context.rawInput.packageData.version = normalizedVersion;
}
else {
normalizeVersion = true;
context.rawInput.packageData.version = inq.inputVersion;
}
}
else {
normalizeVersion = false;
context.rawInput.packageData.version = normalizedVersion;
}
}
else {
normalizeVersion = false;
}
}
logger_1.Logger.info(`Release publish version: ${chalk_1.default.bold(context.rawInput.packageData.version)}`);
context.runtime = {
rollback: false,
trmPackage: {
package: new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry),
registry,
manifest: Object.assign(Object.assign({}, context.rawInput.packageData.manifest), {
name: context.rawInput.packageData.name,
version: context.rawInput.packageData.version,
private: context.rawInput.publishData.private
})
},
systemData: {
transportTargets: [],
devcTransport: undefined,
tadirTransport: undefined,
releasedTransports: []
},
packageData: {
tadir: []
}
};
logger_1.Logger.loading(`Reading ${systemConnector_1.SystemConnector.getDest()} transport targets...`);
context.runtime.systemData.transportTargets = (yield systemConnector_1.SystemConnector.getTransportTargets()).sort((a, b) => {
if (a.systyp === 'V') {
return -1;
}
else if (b.systyp === 'V') {
return 1;
}
else {
return 0;
}
});
if (context.rawInput.publishData.skipCustomizingTransports) {
context.rawInput.publishData.customizingTransports = [];
}
logger_1.Logger.loading(`Checking package "${context.rawInput.packageData.name}"...`);
const packageExists = yield context.runtime.trmPackage.package.exists();
const canPublishReleases = yield context.runtime.trmPackage.package.canPublishReleases();
if (!canPublishReleases.canPublishReleases) {
if (canPublishReleases.cause) {
logger_1.Logger.error(canPublishReleases.cause);
}
throw new Error(`You are not not authorized to publish "${context.rawInput.packageData.name}" releases.`);
}
if (!packageExists) {
logger_1.Logger.info(`First time publishing "${context.rawInput.packageData.name}". Congratulations!`);
}
else {
context.runtime.trmPackage.latestReleaseManifest = (yield context.runtime.trmPackage.package.fetchRemoteManifest('latest')).get();
if (context.runtime.trmPackage.manifest.private === undefined) {
context.runtime.trmPackage.manifest.private = context.runtime.trmPackage.latestReleaseManifest.private;
}
else {
const validateVisibility = (0, inquirer_1.validatePackageVisibility)(context.rawInput.packageData.registry.getRegistryType(), context.rawInput.packageData.name, context.runtime.trmPackage.manifest.private, context.runtime.trmPackage.latestReleaseManifest ? context.runtime.trmPackage.latestReleaseManifest.private : undefined);
if (validateVisibility !== true) {
throw new Error(validateVisibility);
}
}
}
}),
revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
logger_1.Logger.log('Rollback init step', true);
if (context.runtime && context.runtime.rollback) {
logger_1.Logger.success(`Rollback executed.`);
}
})
};