trm-core
Version:
TRM (Transport Request Manager) Core
192 lines (191 loc) • 8.17 kB
JavaScript
"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) {
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TrmPackage = exports.DEFAULT_VERSION = void 0;
const semver = __importStar(require("semver"));
const logger_1 = require("../logger");
const manifest_1 = require("../manifest");
const registry_1 = require("../registry");
exports.DEFAULT_VERSION = "1.0.0";
class TrmPackage {
constructor(packageName, registry, manifest) {
this.packageName = packageName;
this.registry = registry;
this.manifest = manifest;
this._remoteArtifacts = {};
this._remoteContent = {};
}
setDevclass(devclass) {
this._devclass = devclass;
return this;
}
getDevclass() {
return this._devclass;
}
exists() {
return __awaiter(this, arguments, void 0, function* (version = 'latest') {
return (yield this.registry.packageExists(this.packageName, version));
});
}
canPublishReleases() {
return __awaiter(this, void 0, void 0, function* () {
if (this._userAuthorizations === undefined) {
var view;
try {
view = yield this._viewLatest();
}
catch (e) {
this._canPublishReleasesCause = e.message;
if (e.response && typeof (e.response) === "object") {
view = e.response;
}
else {
throw e;
}
}
this._userAuthorizations = view.userAuthorizations;
}
return {
canPublishReleases: this._userAuthorizations.canCreateReleases,
cause: this._canPublishReleasesCause
};
});
}
fetchRemoteArtifact() {
return __awaiter(this, arguments, void 0, function* (version = 'latest') {
if (!this._remoteArtifacts[version]) {
this._remoteArtifacts[version] = yield this.registry.getArtifact(this.packageName, version);
}
return this._remoteArtifacts[version];
});
}
fetchRemoteManifest() {
return __awaiter(this, arguments, void 0, function* (version = 'latest') {
const artifact = yield this.fetchRemoteArtifact(version);
this.manifest = artifact.getManifest();
this._remoteArtifacts[this.manifest.get().version] = this._remoteArtifacts[version];
return this._remoteArtifacts[version].getManifest();
});
}
fetchRemoteContent() {
return __awaiter(this, arguments, void 0, function* (version = 'latest', r3transConfig) {
if (!this._remoteContent[version]) {
const artifact = yield this.fetchRemoteArtifact(version);
const manifest = artifact.getManifest();
const actualVersion = manifest.get().version;
this._remoteArtifacts[version] = yield artifact.getContent(r3transConfig);
this._remoteArtifacts[actualVersion] = this._remoteArtifacts[version];
}
return this._remoteArtifacts[version];
});
}
publish(data) {
return __awaiter(this, void 0, void 0, function* () {
const artifact = data.artifact;
const trmManifest = artifact.getManifest().get();
const packageName = trmManifest.name;
if (packageName !== this.packageName) {
throw new Error(`Cannot publish package ${packageName}: expected name is ${this.packageName}`);
}
const packageVersion = trmManifest.version;
const readme = data.readme || '';
logger_1.Logger.loading(`Publishing "${packageName}" ${packageVersion} to registry "${this.registry.name}"...`, false);
yield this.registry.publishArtifact(packageName, packageVersion, artifact, readme);
this.manifest = new manifest_1.Manifest(trmManifest);
return this;
});
}
compareRegistry(registry) {
return registry_1.Registry.compare(this.registry, registry);
}
compareName(name) {
return this.packageName.trim().toUpperCase() === name.trim().toUpperCase();
}
_viewLatest() {
return __awaiter(this, void 0, void 0, function* () {
return (yield this.registry.view(this.packageName, 'latest'));
});
}
static create(manifest, registry) {
return __awaiter(this, void 0, void 0, function* () {
return new TrmPackage(manifest.get().name, registry, manifest);
});
}
static compare(o1, o2) {
return o1.compareName(o2.packageName) && o1.compareRegistry(o2.registry);
}
static normalizeVersion(packageName, version, registry) {
return __awaiter(this, void 0, void 0, function* () {
const oPackage = new TrmPackage(packageName, registry);
const usingLatest = version.trim().toLowerCase() === 'latest';
if (!usingLatest) {
version = semver.clean(version);
if (!version) {
throw new Error('Version not supported.');
}
}
const exists = yield oPackage.exists();
if (!exists) {
if (usingLatest) {
version = exports.DEFAULT_VERSION;
}
}
else {
if (!usingLatest) {
const versionExists = yield oPackage.exists(version);
if (versionExists) {
throw new Error(`Package "${packageName}" versioned ${version} already published.`);
}
}
else {
const oManifest = yield oPackage.fetchRemoteManifest('latest');
const latestPublishedManifest = oManifest.get();
version = semver.inc(latestPublishedManifest.version, 'patch');
}
}
return version;
});
}
}
exports.TrmPackage = TrmPackage;