trm-core 9.10.5 → 10.0.0

package/dist/actions/commons/utils/releaseDeletionTransport.d.ts

@@ -0,0 +1,5 @@
+import { Transport } from "../../../transport";
+import { AbstractRegistry } from "../../../registry";
+import type { PackageCleanupContext } from "./packageCleanup";
+/** Releases and imports a deletion transport, retaining its original binaries for rollback. */
+export declare function releaseDeletionTransport(deletionTransport: Transport, registry: AbstractRegistry, context: PackageCleanupContext, retainSnapshot?: boolean): Promise<void>;

package/dist/actions/commons/utils/releaseDeletionTransport.js

@@ -0,0 +1,67 @@
+"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.releaseDeletionTransport = releaseDeletionTransport;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../../transport");
+const systemConnector_1 = require("../../../systemConnector");
+const registry_1 = require("../../../registry");
+const installRegistry_1 = require("./installRegistry");
+/** Releases and imports a deletion transport, retaining its original binaries for rollback. */
+function releaseDeletionTransport(deletionTransport_1, registry_2, context_1) {
+    return __awaiter(this, arguments, void 0, function* (deletionTransport, registry, context, retainSnapshot = true) {
+        //a local artifact can't generate deletion transports: the registry it was published to does.
+        //resolved before releasing, so an unreadable artifact leaves the transport untouched
+        const deletionRegistry = yield (0, installRegistry_1.resolveInstallRegistry)(registry);
+        yield deletionTransport.release(false, true);
+        const tocBinaries = (yield deletionTransport.download()).binaries;
+        //saving dummy binaries for a possible revert
+        if (retainSnapshot) {
+            context.revert.dele = {
+                trkorr: deletionTransport.trkorr,
+                entries: undefined,
+                binaries: tocBinaries
+            };
+        }
+        let deleBinaries;
+        try {
+            deleBinaries = yield deletionRegistry.delete(tocBinaries);
+        }
+        catch (e) {
+            // The transport is already released and can't be deleted: it's a harmless transport of copies.
+            // Nothing was imported, so there is nothing to restore and nothing to forward.
+            if (e instanceof registry_1.RegistryDeletionTransportUnavailableError && retainSnapshot) {
+                context.revert.dele = undefined;
+            }
+            throw e;
+        }
+        //upload transport binaries
+        trm_commons_1.Logger.loading(`Uploading transport...`);
+        context.runtime.dele = yield transport_1.Transport.upload(deletionTransport.trkorr, {
+            binary: deleBinaries,
+            trTarget: systemConnector_1.SystemConnector.getDest()
+        });
+        //3- import transport
+        trm_commons_1.Logger.loading(`Testing import...`);
+        const testRc = yield context.runtime.dele.import(true);
+        if (testRc < 0 || testRc > 8) {
+            throw new Error(`Test import of deletion transport failed: check logs.`);
+        }
+        trm_commons_1.Logger.loading(`Importing ${deletionTransport.trkorr}`, true);
+        // Mark before the mutating await: the import may change objects and still fail.
+        if (retainSnapshot) {
+            context.revert.deleImportStarted = true;
+        }
+        yield context.runtime.dele.import(false);
+        trm_commons_1.Logger.success(`Transport ${deletionTransport.trkorr} imported`, true);
+        deletionTransport = context.runtime.dele; //replace
+    });
+}

package/dist/actions/commons/utils/restoreTransport.d.ts

@@ -0,0 +1,6 @@
+import { TransportBinary } from "../../../trmPackage";
+import { Transport } from "../../../transport";
+/** Re-imports the transport snapshot captured before an install transport was replaced. */
+export declare function restoreTransport(snapshot: TransportBinary): Promise<void>;
+/** Deletes a generated transport before import, or restores its snapshot after replacement/import. */
+export declare function revertPreparedTransport(generated: Transport | undefined, snapshot: TransportBinary | undefined): Promise<void>;

package/dist/actions/commons/utils/restoreTransport.js

@@ -0,0 +1,50 @@
+"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.restoreTransport = restoreTransport;
+exports.revertPreparedTransport = revertPreparedTransport;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../../transport");
+const systemConnector_1 = require("../../../systemConnector");
+/** Re-imports the transport snapshot captured before an install transport was replaced. */
+function restoreTransport(snapshot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        trm_commons_1.Logger.loading(`Restoring transport ${snapshot.trkorr}...`, true);
+        const transport = yield transport_1.Transport.upload(snapshot.trkorr, {
+            binary: snapshot.binaries,
+            trTarget: systemConnector_1.SystemConnector.getDest()
+        });
+        //avoid test import, it should be fine?...
+        yield transport.import(false);
+        trm_commons_1.Logger.success(`Transport ${snapshot.trkorr} restored`, true);
+    });
+}
+/** Deletes a generated transport before import, or restores its snapshot after replacement/import. */
+function revertPreparedTransport(generated, snapshot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (generated) {
+            try {
+                if (yield generated.canBeDeleted()) {
+                    yield generated.delete();
+                    return;
+                }
+            }
+            catch (error) {
+                if (!snapshot) {
+                    throw error;
+                }
+            }
+        }
+        if (snapshot) {
+            yield restoreTransport(snapshot);
+        }
+    });
+}

package/dist/actions/commons/utils/retainedWorkflow.d.ts

@@ -0,0 +1,6 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+/** Executes a workflow and retains a one-shot, best-effort rollback journal after success. */
+export declare function executeRetainedWorkflow<T extends object>(name: string, steps: Step<T>[], context: T, callbacks?: any): Promise<{
+    context: T;
+    rollback: () => Promise<void>;
+}>;

package/dist/actions/commons/utils/retainedWorkflow.js

@@ -0,0 +1,49 @@
+"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.executeRetainedWorkflow = executeRetainedWorkflow;
+const workflowCallbacks_1 = require("../workflowCallbacks");
+/** Executes a workflow and retains a one-shot, best-effort rollback journal after success. */
+function executeRetainedWorkflow(name, steps, context, callbacks) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const completed = [];
+        const tracked = steps.map(step => (Object.assign(Object.assign({}, step), { run: (stepContext) => __awaiter(this, void 0, void 0, function* () {
+                yield step.run(stepContext);
+                completed.push(step);
+            }) })));
+        const result = yield (0, workflowCallbacks_1.executeWorkflow)(name, tracked, context, callbacks || {});
+        let rolledBack = false;
+        return {
+            context: result,
+            rollback: () => __awaiter(this, void 0, void 0, function* () {
+                if (rolledBack) {
+                    return;
+                }
+                rolledBack = true;
+                let firstError;
+                for (const step of [...completed].reverse()) {
+                    if (!step.revert) {
+                        continue;
+                    }
+                    try {
+                        yield step.revert(result);
+                    }
+                    catch (error) {
+                        firstError || (firstError = error);
+                    }
+                }
+                if (firstError) {
+                    throw firstError;
+                }
+            })
+        };
+    });
+}

package/dist/actions/commons/utils/withScopedPrefix.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs `fn` with a nested Logger/Inquirer prefix (chained onto whatever prefix was
+ * already active, if any), restoring the original prefix afterwards - even on error.
+ */
+export declare function withScopedPrefix<T>(prefix: string, fn: () => Promise<T>): Promise<T>;

package/dist/actions/commons/utils/withScopedPrefix.js

@@ -0,0 +1,32 @@
+"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.withScopedPrefix = withScopedPrefix;
+const trm_commons_1 = require("trm-commons");
+/**
+ * Runs `fn` with a nested Logger/Inquirer prefix (chained onto whatever prefix was
+ * already active, if any), restoring the original prefix afterwards - even on error.
+ */
+function withScopedPrefix(prefix, fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const originalLPrefix = trm_commons_1.Logger.getPrefix();
+        const originalIPrefix = trm_commons_1.Inquirer.getPrefix();
+        trm_commons_1.Logger.setPrefix(originalLPrefix ? `${originalLPrefix}-> ${prefix}` : prefix);
+        trm_commons_1.Inquirer.setPrefix(originalIPrefix ? `${originalIPrefix}-> ${prefix}` : prefix);
+        try {
+            return yield fn();
+        }
+        finally {
+            trm_commons_1.Logger.setPrefix(originalLPrefix);
+            trm_commons_1.Inquirer.setPrefix(originalIPrefix);
+        }
+    });
+}

package/dist/actions/commons/workflowCallbacks.d.ts

@@ -0,0 +1,21 @@
+import { Step, StepContext, WorkflowCallbacks, WorkflowError, WorkflowRevertError } from "@simonegaffurini/sammarksworkflow";
+/**
+ * Default callbacks used by TRM actions to log workflow, step, and rollback lifecycle events.
+ * Inputs and outputs are summarized with secrets redacted and binary/class instances collapsed.
+ */
+export declare const workflowCallbacks: WorkflowCallbacks<any>;
+/**
+ * Thrown by {@link executeWorkflow} when a step fails and one or more rollback steps fail too.
+ * `originalWorkflowError` is the step failure; `revertErrors` holds every rollback failure, in
+ * rollback order. `stepName` and `originalException` describe the first rollback failure.
+ */
+export declare class ActionWorkflowRevertError extends WorkflowRevertError {
+    revertErrors: WorkflowError[];
+    constructor(originalWorkflowError: WorkflowError, revertErrors: WorkflowError[]);
+}
+/**
+ * Executes a workflow with `callbacks`. The engine only reports rollback failures to
+ * `onRevertFailed` and rethrows the step failure: they are collected here, so a failed rollback
+ * is thrown as an {@link ActionWorkflowRevertError} carrying all of them.
+ */
+export declare function executeWorkflow<T extends StepContext>(name: string, steps: Array<Step<T>>, context: T, callbacks?: WorkflowCallbacks<T>): Promise<T>;

package/dist/actions/commons/workflowCallbacks.js

@@ -0,0 +1,157 @@
+"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.ActionWorkflowRevertError = exports.workflowCallbacks = void 0;
+exports.executeWorkflow = executeWorkflow;
+const trm_commons_1 = require("trm-commons");
+const sammarksworkflow_1 = __importStar(require("@simonegaffurini/sammarksworkflow"));
+const commons_1 = require("../../commons");
+/**
+ * Default callbacks used by TRM actions to log workflow, step, and rollback lifecycle events.
+ * Inputs and outputs are summarized with secrets redacted and binary/class instances collapsed.
+ */
+exports.workflowCallbacks = {
+    onWorkflowStart: (name, context) => {
+        trm_commons_1.Logger.log(`Starting workflow "${name}", input data: ${(0, trm_commons_1.inspect)((0, commons_1.summarizeForLog)(context.rawInput || context), { breakLength: Infinity, compact: true })}`, true);
+    },
+    onWorkflowFinish(name, context) {
+        trm_commons_1.Logger.log(`Workflow ${name} result: ${(0, trm_commons_1.inspect)((0, commons_1.summarizeForLog)(context.output || context), { breakLength: Infinity, compact: true })}`, true);
+    },
+    onStepStart(step) {
+        trm_commons_1.Logger.log(`Starting "${step.name}" step`, true);
+    },
+    onStepCompleted(step) {
+        trm_commons_1.Logger.log(`Completed "${step.name}" step`, true);
+    },
+    onStepFail(step, error) {
+        trm_commons_1.Logger.log(`Failed "${step.name}" step: ${error.message}`, true);
+    },
+    onRevertStart(step, context) {
+        trm_commons_1.Logger.log(`Starting revert "${step.name}" step`, true);
+        trm_commons_1.Logger.setPrefix(`(Rollback) `);
+        trm_commons_1.Inquirer.setPrefix(`(Rollback) `);
+    },
+    onRevertCompleted(step) {
+        trm_commons_1.Logger.removePrefix();
+        trm_commons_1.Inquirer.removePrefix();
+        trm_commons_1.Logger.log(`Completed revert "${step.name}" step`, true);
+    },
+    onRevertFailed(step, error) {
+        trm_commons_1.Logger.removePrefix();
+        trm_commons_1.Inquirer.removePrefix();
+        trm_commons_1.Logger.error(`Failed rollback: ${error.message}`, { important: true });
+        trm_commons_1.Logger.log(`Failed revert "${step.name}" step: ${error.message}`, true);
+    },
+};
+function isWorkflowError(error) {
+    // Checked by shape: the engine's ES5 error classes don't support `instanceof`.
+    return typeof (error === null || error === void 0 ? void 0 : error.stepName) === 'string' && 'originalException' in error;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The engine builds the message as `Workflow error executing '<step>': <String(exception)>`, which
+ * repeats the inner error class ("Error: ...") and, for nested workflows, every outer prefix.
+ * Describe the failing step path once, followed by the root cause message.
+ */
+function describeWorkflowError(error) {
+    const steps = [];
+    var cause = error;
+    while (isWorkflowError(cause) && !cause.originalWorkflowError) {
+        steps.push(cause.stepName);
+        cause = cause.originalException;
+    }
+    return `Workflow error executing '${steps.join("' > '")}': ${errorMessage(cause)}`;
+}
+/**
+ * Thrown by {@link executeWorkflow} when a step fails and one or more rollback steps fail too.
+ * `originalWorkflowError` is the step failure; `revertErrors` holds every rollback failure, in
+ * rollback order. `stepName` and `originalException` describe the first rollback failure.
+ */
+class ActionWorkflowRevertError extends sammarksworkflow_1.WorkflowRevertError {
+    constructor(originalWorkflowError, revertErrors) {
+        super(revertErrors[0].stepName, revertErrors[0].originalException, originalWorkflowError);
+        this.revertErrors = revertErrors;
+        // The engine's ES5 error classes return a plain Error: restore the prototype chain for `instanceof`.
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = 'ActionWorkflowRevertError';
+        this.message = [
+            describeWorkflowError(originalWorkflowError),
+            ...revertErrors.map(revertError => `Additionally, error reverting step '${revertError.stepName}': ${errorMessage(revertError.originalException)}`)
+        ].join('\n');
+    }
+}
+exports.ActionWorkflowRevertError = ActionWorkflowRevertError;
+/**
+ * Executes a workflow with `callbacks`. The engine only reports rollback failures to
+ * `onRevertFailed` and rethrows the step failure: they are collected here, so a failed rollback
+ * is thrown as an {@link ActionWorkflowRevertError} carrying all of them.
+ */
+function executeWorkflow(name_1, steps_1, context_1) {
+    return __awaiter(this, arguments, void 0, function* (name, steps, context, callbacks = exports.workflowCallbacks) {
+        const revertErrors = [];
+        try {
+            return yield (0, sammarksworkflow_1.default)(name, steps, context, Object.assign(Object.assign({}, callbacks), { onRevertFailed: (step, error, stepContext) => {
+                    var _a;
+                    revertErrors.push(new sammarksworkflow_1.WorkflowError(step.name, error));
+                    (_a = callbacks.onRevertFailed) === null || _a === void 0 ? void 0 : _a.call(callbacks, step, error, stepContext);
+                } }));
+        }
+        catch (error) {
+            // Reverts only run after a step failure, which the engine always rethrows as a WorkflowError.
+            if (isWorkflowError(error)) {
+                if (revertErrors.length > 0) {
+                    throw new ActionWorkflowRevertError(error, revertErrors);
+                }
+                const message = describeWorkflowError(error);
+                if (typeof error.stack === 'string' && error.stack.startsWith(`${error.name}: ${error.message}`)) {
+                    error.stack = `${error.name}: ${message}${error.stack.slice(`${error.name}: ${error.message}`.length)}`;
+                }
+                error.message = message;
+            }
+            throw error;
+        }
+    });
+}

package/dist/actions/index.d.ts

@@ -2,7 +2,10 @@ export * from "./commons";
 export * from "./installDependency";
 export * from "./checkPackageDependencies";
 export * from "./checkSapEntries";
+export * from "./checkEngines";
 export * from "./install";
+export * from "./uninstall";
 export * from "./publish";
+export { publish as publishV2, PublishActionInput as PublishV2ActionInput, PublishActionOutput as PublishV2ActionOutput, PublishWorkflowContext as PublishV2WorkflowContext } from "./publish";
 export * from "./cg3y";
 export * from "./cg3z";

package/dist/actions/index.js

@@ -14,11 +14,16 @@ 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 });
+exports.publishV2 = void 0;
 __exportStar(require("./commons"), exports);
 __exportStar(require("./installDependency"), exports);
 __exportStar(require("./checkPackageDependencies"), exports);
 __exportStar(require("./checkSapEntries"), exports);
+__exportStar(require("./checkEngines"), exports);
 __exportStar(require("./install"), exports);
+__exportStar(require("./uninstall"), exports);
 __exportStar(require("./publish"), exports);
+var publish_1 = require("./publish");
+Object.defineProperty(exports, "publishV2", { enumerable: true, get: function () { return publish_1.publish; } });
 __exportStar(require("./cg3y"), exports);
 __exportStar(require("./cg3z"), exports);

package/dist/actions/install/addNamespace.d.ts

@@ -1,3 +1,21 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+import { PackageHierarchy } from "../../commons";
+export declare function flattenDevclasses(pkg: PackageHierarchy): string[];
+/**
+ * Returns the namespace packages are installed into: the target names, or the original names when
+ * `original` is set or `keepOriginal` is used. See getPackagesNamespace.
+ */
+export declare function getInstallNamespace(context: InstallWorkflowContext, original?: boolean): string;
+/**
+ * Workflow step that registers the package namespace for repair when required.
+ *
+ * 1- set namespace
+ *
+ * 2- check if namespace already exists (only if customer namespace)
+ *
+ *
+ * 3- create namespace
+ *
+*/
 export declare const addNamespace: Step<InstallWorkflowContext>;