trm-client 6.1.1 → 7.0.0

package/dist/command/implementations/Login.js

@@ -0,0 +1,66 @@
+"use strict";
+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.Login = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const registryAlias_1 = require("../../registryAlias");
+const trm_registry_types_1 = require("trm-registry-types");
+class Login extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.onlyRegistryAlias = true;
+        this.registerOpts.registryAuthBlacklist = [trm_registry_types_1.AuthenticationType.NO_AUTH];
+        this.command.description(`Log into a registry.`);
+        this.command.addHelpText(`before`, `This command has no effect when trying to login into a registry that doesn't require authentication.`);
+        this.command.option(`-A, --registry-auth <authentication>`, `Registry authentication (JSON or path to JSON file).`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = this.getRegistry();
+            var authData;
+            if (this.parseJsonArg('registryAuth')) {
+                if (!this.getRegistryAuthError()) {
+                    authData = registry.getAuthData();
+                }
+            }
+            else {
+                var continueLogin;
+                try {
+                    const whoami = yield registry.whoAmI();
+                    continueLogin = (yield trm_commons_1.Inquirer.prompt({
+                        type: "confirm",
+                        name: "continue",
+                        message: `Already logged in as "${whoami.user}". Do you want to logout?`,
+                        default: false
+                    })).continue;
+                }
+                catch (_a) {
+                    continueLogin = true;
+                }
+                if (continueLogin) {
+                    yield registry.authenticate({});
+                    authData = registry.getAuthData();
+                }
+            }
+            if (authData) {
+                registryAlias_1.RegistryAlias.update(registry.name, authData);
+                try {
+                    yield this.registryWhoAmI();
+                }
+                catch (_b) {
+                    registryAlias_1.RegistryAlias.update(registry.name);
+                }
+            }
+        });
+    }
+}
+exports.Login = Login;

package/dist/command/implementations/Logout.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Logout extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Logout.js

@@ -0,0 +1,37 @@
+"use strict";
+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.Logout = void 0;
+const trm_commons_1 = require("trm-commons");
+const registryAlias_1 = require("../../registryAlias");
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_registry_types_1 = require("trm-registry-types");
+class Logout extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.onlyRegistryAlias = true;
+        this.registerOpts.registryAuthBlacklist = [trm_registry_types_1.AuthenticationType.NO_AUTH];
+        this.command.description(`Log out of a registry.`);
+        this.command.addHelpText(`before`, `This command has no effect when trying to login into a registry that doesn't require authentication.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = this.getRegistry();
+            if (this.hasRegistryAuthData()) {
+                registryAlias_1.RegistryAlias.update(registry.name);
+            }
+            else {
+                trm_commons_1.Logger.info(`Not logged in.`);
+            }
+        });
+    }
+}
+exports.Logout = Logout;

package/dist/command/implementations/Ping.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Ping extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/{commands/findDependencies.js → command/implementations/Ping.js}

@@ -9,23 +9,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findDependencies = findDependencies;
+exports.Ping = void 0;
 const trm_commons_1 = require("trm-commons");
 const trm_core_1 = require("trm-core");
-function findDependencies(commandArgs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        trm_commons_1.Logger.loading(`Searching for dependencies in package "${commandArgs.devclass}"...`);
-        yield (0, trm_core_1.findDependencies)({
-            contextData: {
-                noInquirer: commandArgs.noPrompts
-            },
-            packageData: {
-                package: commandArgs.devclass
-            },
-            printOptions: {
-                trmDependencies: true,
-                sapObjectDependencies: commandArgs.sapEntries
-            }
+const AbstractCommand_1 = require("../AbstractCommand");
+class Ping extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.command.description(`Ping trm-server (Used for testing purposes).`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            trm_commons_1.Logger.loading(`Pinging trm-server on ${trm_core_1.SystemConnector.getDest()}...`);
+            const pingValue = yield trm_core_1.SystemConnector.ping();
+            trm_commons_1.Logger.info(pingValue);
         });
-    });
+    }
 }
+exports.Ping = Ping;

package/dist/command/implementations/Publish.d.ts

@@ -0,0 +1,6 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Publish extends AbstractCommand {
+    protected init(): void;
+    private validateVersion;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Publish.js

@@ -0,0 +1,145 @@
+"use strict";
+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.Publish = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const utils_1 = require("../../utils");
+const semver_1 = require("semver");
+class Publish extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        if (this.name === 'pack') {
+            this.command.description(`Export a package to local file.`);
+            this.command.argument(`<filename>`, `Name (or path) of the file.`);
+            this.command.option(`--package <package>`, `Name of the package`);
+            this.command.option(`--version <version>`, `Version of the release`);
+        }
+        else {
+            this.registerOpts.requiresRegistry = true;
+            this.command.description(`Publish a package to a registry.`);
+            this.command.argument(`<package>`, `Name of the package.`);
+            this.command.argument(`[version]`, `Optional: Version of the release to publish.`);
+            this.command.option(`-i, --increment <increment>`, `Semantic versioning increment (used when no version is specified)`, `patch`);
+            this.command.option(`--pre-release`, `Publish as pre release`, false);
+            this.command.option(`--pre-release-identifier <identifier>`, `Identifier (needs to pre a pre release)`);
+            this.command.option(`--tag <tag>`, `Release tag(s) (separated by comma)`);
+            this.command.option(`--private`, `Package marked as private. Depending on the registry, visibility might not be changed after first publish.`);
+            this.command.option(`--readme <readme>`, `Release readme (markdown or path to markdown file)`);
+            this.command.option(`--no-keep-manifest`, `Don't default to previous release manifest values.`, false);
+        }
+        this.command.option(`-P, --sap-package <sap package>`, `SAP Package.`);
+        this.command.option(`-t, --timeout <seconds>`, `Transport release timeout (in seconds)`, `180`);
+        this.command.option(`-T, --target <target>`, `Transport release target.`);
+        this.command.option(`--no-lang-tr`, `Do not generate language (translation) transport.`, false);
+        this.command.option(`--no-cust-tr`, `Do not generate customizing transport.`, false);
+        this.command.option(`--cust <customizing>`, `Customizing transport(s) (separated by comma).`);
+        this.command.option(`--no-auto-deps`, `Do not look for dependencies.`, false);
+        this.command.option(`--authors <authors>`, `Release author(s) (separated by comma)`);
+        this.command.option(`--backwards-compatible`, `Backwards-compatible release (reserved for future use)`);
+        this.command.option(`--description <description>`, `Release description`);
+        this.command.option(`--git <git url>`, `Release git URL`);
+        this.command.option(`--keywords <keywords>`, `Release keyword(s) (separated by comma)`);
+        this.command.option(`--license <license>`, `Release license`);
+        this.command.option(`--website <website url>`, `Release website URL`);
+        this.command.option(`--dependencies <dependencies>`, `Release dependencies (JSON or path to JSON file)`);
+        this.command.option(`--sap-entries <sap entries>`, `Release SAP entries (JSON or path to JSON file)`);
+        this.command.option(`--post-activities <post activities>`, `Release post activities (JSON or path to JSON file)`);
+        this.command.option(`--no-prompts`, `No prompts (will force some decisions).`, false);
+    }
+    validateVersion(v) {
+        if ((0, semver_1.valid)(v)) {
+            return true;
+        }
+        else {
+            return 'Invalid semantic versioning';
+        }
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var registry;
+            if (this.name === 'pack') {
+                if (!this.args.noPrompts) {
+                    const pack = yield trm_commons_1.Inquirer.prompt([{
+                            name: 'package',
+                            type: 'input',
+                            message: 'Package name',
+                            default: this.args.package,
+                            when: !this.args.package
+                        }, {
+                            name: 'version',
+                            type: 'input',
+                            message: 'Release version',
+                            default: this.args.version,
+                            when: !this.args.version,
+                            validate: this.validateVersion
+                        }]);
+                    this.args.package = pack.package;
+                    this.args.version = pack.version;
+                }
+                if (this.validateVersion(this.args.version) !== true) {
+                    throw new Error(this.validateVersion(this.args.version));
+                }
+                registry = new trm_core_1.FileSystem(this.args.filename);
+            }
+            else {
+                registry = this.getRegistry();
+            }
+            const packages = yield this.getSystemPackages();
+            const result = yield (0, trm_core_1.publish)({
+                contextData: {
+                    logTemporaryFolder: (0, utils_1.getTempFolder)(),
+                    systemPackages: packages,
+                    noInquirer: this.args.noPrompts
+                },
+                packageData: {
+                    registry,
+                    name: this.args.package,
+                    version: this.args.version,
+                    devclass: this.args.sapPackage,
+                    inc: this.args.increment,
+                    preRelease: this.args.preRelease,
+                    preReleaseIdentifier: this.args.preReleaseIdentifier,
+                    tags: this.parseArrayArg('tag'),
+                    manifest: {
+                        authors: this.args.authors,
+                        backwardsCompatible: this.args.backwardsCompatible,
+                        description: this.args.description,
+                        git: this.args.git,
+                        keywords: this.args.keywords,
+                        license: this.args.license,
+                        website: this.args.website,
+                        dependencies: this.parseJsonArg('dependencies'),
+                        sapEntries: this.parseJsonArg('sapEntries'),
+                        postActivities: this.parseJsonArg('postActivities')
+                    },
+                },
+                publishData: {
+                    private: this.args.private,
+                    keepLatestReleaseManifestValues: !this.args.noKeepManifest,
+                    noLanguageTransport: this.args.noLangTr,
+                    noDependenciesDetection: this.args.noAutoDeps,
+                    skipCustomizingTransports: this.args.noCustTr,
+                    customizingTransports: this.args.cust,
+                    readme: this.parseTextArg('readme')
+                },
+                systemData: {
+                    releaseTimeout: this.parseNumberArg('timeout'),
+                    transportTarget: this.args.target
+                }
+            });
+            trm_commons_1.Logger.success(`+ ${result.trmPackage.manifest.get().name} v${result.trmPackage.manifest.get().version}`);
+        });
+    }
+}
+exports.Publish = Publish;

package/dist/command/implementations/Registry.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Registry extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Registry.js

@@ -0,0 +1,88 @@
+"use strict";
+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.Registry = void 0;
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_commons_1 = require("trm-commons");
+const registryAlias_1 = require("../../registryAlias");
+class Registry extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        if (this.name.includes('add')) {
+            this.command.description(`Add a new registry.`);
+            this.command.argument(`<registry name>`, `Name of the registry to generate. Name "${trm_core_1.PUBLIC_RESERVED_KEYWORD}" and "${trm_core_1.LOCAL_RESERVED_KEYWORD}" are protected and cannot be used.`);
+        }
+        else if (this.name.includes('rm')) {
+            this.command.description(`Remove a registry.`);
+            this.command.argument(`<registry name>`, `Name of the registry to delete. Registries "${trm_core_1.PUBLIC_RESERVED_KEYWORD}" and "${trm_core_1.LOCAL_RESERVED_KEYWORD}" are protected and cannot be deleted.`);
+        }
+        this.command.option(`-E, --registry-endpoint <endpoint>`, `Registry endpoint.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registryName = this.args.registryName.trim();
+            if (this.args.add && this.args.add.trim().toLowerCase() === 'add') {
+                var endpoint = this.args.endpoint;
+                if (registryName.toLowerCase() === trm_core_1.PUBLIC_RESERVED_KEYWORD) {
+                    throw new Error(`Registry name "${trm_core_1.PUBLIC_RESERVED_KEYWORD}" is a reserved keyword.`);
+                }
+                if (registryName.toLowerCase() === trm_core_1.LOCAL_RESERVED_KEYWORD) {
+                    throw new Error(`Registry name "${trm_core_1.LOCAL_RESERVED_KEYWORD}" is a reserved keyword.`);
+                }
+                const inq1 = yield trm_commons_1.Inquirer.prompt({
+                    type: "input",
+                    name: "endpoint",
+                    message: "Registry endpoint",
+                    default: endpoint,
+                    when: !endpoint
+                });
+                endpoint = inq1.endpoint || endpoint;
+                const registry = registryAlias_1.RegistryAlias.create(registryName, endpoint);
+                var pingSuccess = true;
+                try {
+                    const ping = yield registry.getRegistry().ping();
+                    if (ping.messages) {
+                        ping.messages.forEach(m => trm_commons_1.Logger.registryResponse(m));
+                    }
+                }
+                catch (e) {
+                    trm_commons_1.Logger.error(`Ping to registry "${registryName}" (${endpoint}) failed.`);
+                    pingSuccess = false;
+                    throw e;
+                }
+                finally {
+                    if (pingSuccess) {
+                        trm_commons_1.Logger.success(`Registry "${registryName}" added.`);
+                    }
+                    else {
+                        registryAlias_1.RegistryAlias.delete(registryName);
+                    }
+                }
+            }
+            else if (this.args.rm && this.args.rm.trim().toLowerCase() === 'rm') {
+                if (registryName.toLowerCase() === trm_core_1.PUBLIC_RESERVED_KEYWORD) {
+                    throw new Error(`Registry "${trm_core_1.PUBLIC_RESERVED_KEYWORD}" is protected and cannot be deleted.`);
+                }
+                if (registryName.toLowerCase() === trm_core_1.LOCAL_RESERVED_KEYWORD) {
+                    throw new Error(`Registry "${trm_core_1.LOCAL_RESERVED_KEYWORD}" is protected and cannot be deleted.`);
+                }
+                registryAlias_1.RegistryAlias.get(registryName);
+                registryAlias_1.RegistryAlias.delete(registryName);
+                trm_commons_1.Logger.success(`Registry "${registryName}" has been removed.`);
+            }
+            else {
+                throw new Error(`Unknown command.`);
+            }
+        });
+    }
+}
+exports.Registry = Registry;

package/dist/command/implementations/Settings.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Settings extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Settings.js

@@ -0,0 +1,42 @@
+"use strict";
+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.Settings = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const utils_1 = require("../../utils");
+class Settings extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.command.description(`Show/Set settings.`);
+        this.command.option(`-s, --set <property>`, `Property as KEY=VALUE.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const setArgument = this.args.set;
+            if (setArgument) {
+                const aSplit = setArgument.split('=');
+                if (aSplit.length !== 2) {
+                    throw new Error(`Invalid 'set' argument, must be in format KEY=VALUE.`);
+                }
+                const key = aSplit[0];
+                const value = aSplit[1];
+                utils_1.GlobalContext.getInstance().setSetting(key, value);
+            }
+            const settingsData = utils_1.GlobalContext.getInstance().getSettings();
+            Object.keys(settingsData).forEach(k => {
+                trm_commons_1.Logger.log(`${k}: ${settingsData[k]}`);
+            });
+        });
+    }
+}
+exports.Settings = Settings;

package/dist/command/implementations/Unpublish.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Unpublish extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Unpublish.js

@@ -0,0 +1,34 @@
+"use strict";
+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.Unpublish = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const semver_1 = require("semver");
+class Unpublish extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.command.description(`Unpublish a package release from registry.`);
+        this.command.argument(`<package>`, `Name of the package.`);
+        this.command.argument(`<version>`, `Version of the release.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, semver_1.valid)(this.args.version)) {
+                throw new Error(`Invalid version.`);
+            }
+            yield this.getRegistry().unpublish(this.args.package, this.args.version);
+            const sOutput = `- ${this.args.package} ${this.args.version}`;
+            trm_commons_1.Logger.success(sOutput);
+        });
+    }
+}
+exports.Unpublish = Unpublish;

package/dist/command/implementations/View.d.ts

@@ -0,0 +1,9 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class View extends AbstractCommand {
+    protected init(): void;
+    private printHeaderSection;
+    private printVersionSection;
+    private printManifestSection;
+    private printDependenciesSection;
+    protected handler(): Promise<void>;
+}