@mittwald/cli 1.11.2 → 1.13.1-beta.6

package/dist/lib/resources/stack/template-loader.test.js

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, it, jest, } from "@jest/globals";
+import { validateTemplateName, templateNameToRepoName, buildGitHubRawUrl, fetchTemplateFile, loadStackFromTemplate, TemplateFileNotFoundError, GitHubRateLimitError, TemplateNetworkError, } from "./template-loader.js";
+import axios from "axios";
+describe("validateTemplateName", () => {
+    it("should accept valid template names", () => {
+        expect(() => validateTemplateName("mittwald/n8n")).not.toThrow();
+        expect(() => validateTemplateName("owner/name")).not.toThrow();
+        expect(() => validateTemplateName("my-org/my-app")).not.toThrow();
+        expect(() => validateTemplateName("org_name/app_name")).not.toThrow();
+    });
+    it("should reject invalid template names", () => {
+        expect(() => validateTemplateName("")).toThrow(/Invalid template name/);
+        expect(() => validateTemplateName("noSlash")).toThrow(/Invalid template name/);
+        expect(() => validateTemplateName("too/many/slashes")).toThrow(/Invalid template name/);
+        expect(() => validateTemplateName("/missingOwner")).toThrow(/Invalid template name/);
+        expect(() => validateTemplateName("missingName/")).toThrow(/Invalid template name/);
+    });
+});
+describe("templateNameToRepoName", () => {
+    it("should convert template name to repository name", () => {
+        expect(templateNameToRepoName("mittwald/n8n")).toBe("mittwald/stack-template-n8n");
+        expect(templateNameToRepoName("owner/app")).toBe("owner/stack-template-app");
+    });
+});
+describe("buildGitHubRawUrl", () => {
+    it("should build correct GitHub raw URL", () => {
+        expect(buildGitHubRawUrl("mittwald/n8n", "docker-compose.yml")).toBe("https://raw.githubusercontent.com/mittwald/stack-template-n8n/main/docker-compose.yml");
+        expect(buildGitHubRawUrl("owner/app", ".env")).toBe("https://raw.githubusercontent.com/owner/stack-template-app/main/.env");
+    });
+});
+describe("fetchTemplateFile", () => {
+    let axiosGetSpy;
+    let axiosIsAxiosErrorSpy;
+    beforeEach(() => {
+        axiosGetSpy = jest.spyOn(axios, "get");
+        axiosIsAxiosErrorSpy = jest.spyOn(axios, "isAxiosError");
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it("should fetch file successfully", async () => {
+        const mockData = "file content";
+        axiosGetSpy.mockResolvedValue({ data: mockData });
+        const result = await fetchTemplateFile("https://raw.githubusercontent.com/mittwald/stack-template-n8n/main/docker-compose.yml");
+        expect(result).toBe(mockData);
+        expect(axiosGetSpy).toHaveBeenCalledWith("https://raw.githubusercontent.com/mittwald/stack-template-n8n/main/docker-compose.yml", { responseType: "text", timeout: 10000 });
+    });
+    it("should handle 404 errors", async () => {
+        axiosGetSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        await expect(fetchTemplateFile("https://example.com/missing.yml")).rejects.toThrow(TemplateFileNotFoundError);
+    });
+    it("should handle 403 rate limit errors", async () => {
+        axiosGetSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 403 },
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        await expect(fetchTemplateFile("https://example.com/file.yml")).rejects.toThrow(GitHubRateLimitError);
+    });
+    it("should handle timeout errors", async () => {
+        axiosGetSpy.mockRejectedValue({
+            isAxiosError: true,
+            code: "ETIMEDOUT",
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        await expect(fetchTemplateFile("https://example.com/file.yml")).rejects.toThrow(TemplateNetworkError);
+    });
+    it("should handle network errors", async () => {
+        axiosGetSpy.mockRejectedValue({
+            isAxiosError: true,
+            code: "ECONNREFUSED",
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        await expect(fetchTemplateFile("https://example.com/file.yml")).rejects.toThrow(TemplateNetworkError);
+    });
+});
+describe("loadStackFromTemplate", () => {
+    let axiosGetSpy;
+    let axiosIsAxiosErrorSpy;
+    beforeEach(() => {
+        axiosGetSpy = jest.spyOn(axios, "get");
+        axiosIsAxiosErrorSpy = jest.spyOn(axios, "isAxiosError");
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it("should load both docker-compose.yml and .env", async () => {
+        const composeContent = "version: '3'\nservices:\n  app:\n    image: nginx";
+        const envContent = "FOO=bar\nBAZ=qux";
+        axiosGetSpy
+            .mockResolvedValueOnce({ data: composeContent })
+            .mockResolvedValueOnce({ data: envContent });
+        const result = await loadStackFromTemplate("mittwald/n8n");
+        expect(result.composeYaml).toBe(composeContent);
+        expect(result.envContent).toBe(envContent);
+    });
+    it("should handle missing .env file gracefully", async () => {
+        const composeContent = "version: '3'\nservices:\n  app:\n    image: nginx";
+        axiosGetSpy.mockResolvedValueOnce({ data: composeContent });
+        axiosGetSpy.mockRejectedValueOnce({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        const result = await loadStackFromTemplate("mittwald/n8n");
+        expect(result.composeYaml).toBe(composeContent);
+        expect(result.envContent).toBeNull();
+    });
+    it("should throw error if docker-compose.yml is missing", async () => {
+        axiosGetSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        axiosIsAxiosErrorSpy.mockReturnValue(true);
+        await expect(loadStackFromTemplate("mittwald/n8n")).rejects.toThrow(/Template 'mittwald\/n8n' not found/);
+    });
+    it("should validate template name before fetching", async () => {
+        await expect(loadStackFromTemplate("invalid")).rejects.toThrow(/Invalid template name/);
+        expect(axiosGetSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/lib/units/PortMapping.d.ts

@@ -4,6 +4,8 @@ export default class PortMapping {
     readonly remotePort: number;
     constructor(localPort: number, remotePort: number);
     private static validatePort;
+    private static isValidPortString;
+    private static parseAndValidatePort;
     static arg: import("@oclif/core/interfaces").ArgDefinition<PortMapping, Record<string, unknown>>;
     /** @param str Port and protocol; example: `8080/tcp` */
     static fromPortAndProtocol(str: string): PortMapping;

package/dist/lib/units/PortMapping.js

@@ -10,6 +10,19 @@ export default class PortMapping {
     static validatePort(port) {
         return !isNaN(port) && port > 0 && port <= 65535;
     }
+    static isValidPortString(str) {
+        return /^\d+$/.test(str);
+    }
+    static parseAndValidatePort(str) {
+        if (!PortMapping.isValidPortString(str)) {
+            throw new Error("Invalid port number. Ports must be between 1 and 65535.");
+        }
+        const portNum = parseInt(str);
+        if (!PortMapping.validatePort(portNum)) {
+            throw new Error("Invalid port number. Ports must be between 1 and 65535.");
+        }
+        return portNum;
+    }
     static arg = Args.custom({
         parse: async (input) => PortMapping.fromString(input),
     });
@@ -26,13 +39,15 @@ export default class PortMapping {
         return new PortMapping(portNum, portNum);
     }
     static fromString(str) {
-        const [localPort, remotePort] = str.split(":");
-        const localPortNum = parseInt(localPort);
-        const remotePortNum = parseInt(remotePort);
-        if (!PortMapping.validatePort(localPortNum) ||
-            !PortMapping.validatePort(remotePortNum)) {
-            throw new Error("Invalid port number. Ports must be between 1 and 65535.");
+        const parts = str.split(":");
+        // If only one part, use it for both local and remote port
+        if (parts.length === 1) {
+            const portNum = PortMapping.parseAndValidatePort(parts[0]);
+            return new PortMapping(portNum, portNum);
         }
+        const [localPort, remotePort] = parts;
+        const localPortNum = PortMapping.parseAndValidatePort(localPort);
+        const remotePortNum = PortMapping.parseAndValidatePort(remotePort);
         return new PortMapping(localPortNum, remotePortNum);
     }
 }

package/dist/lib/units/PortMapping.test.js

@@ -7,6 +7,12 @@ describe("PortMapping", () => {
         expect(result.localPort).toBe(8080);
         expect(result.remotePort).toBe(9090);
     });
+    // Test: Successfully parse single integer as identical local and remote port
+    it("should correctly parse single integer to identical ports", () => {
+        const result = PortMapping.fromString("8080");
+        expect(result.localPort).toBe(8080);
+        expect(result.remotePort).toBe(8080);
+    });
     // Test: Throws an error for invalid local port
     it("should throw an error for invalid local port", () => {
         expect(() => PortMapping.fromString("100000:8080")).toThrow("Invalid port number. Ports must be between 1 and 65535.");
@@ -19,6 +25,10 @@ describe("PortMapping", () => {
     it("should throw an error for invalid string format", () => {
         expect(() => PortMapping.fromString("8080-9090")).toThrow("Invalid port number. Ports must be between 1 and 65535.");
     });
+    // Test: Throws an error for invalid single port
+    it("should throw an error for invalid single port", () => {
+        expect(() => PortMapping.fromString("100000")).toThrow("Invalid port number. Ports must be between 1 and 65535.");
+    });
     // Test: Successfully assign local and remote ports via constructor
     it("should correctly initialize PortMapping with valid ports", () => {
         const portMapping = new PortMapping(3000, 4000);

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.11.2",
+  "version": "1.13.1-beta.6",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
+  "repository": {
+    "url": "https://github.com/mittwald/cli"
+  },
   "author": {
     "name": "Mittwald CM Service GmbH & Co. KG",
     "email": "opensource@mittwald.de"
@@ -16,12 +19,13 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=20.7.0"
   },
   "scripts": {
     "clean": "(rimraf --glob dist tsconfig.*.tsbuildinfo) | true",
     "compile": "tsc --build tsconfig.json",
-    "format": "prettier --write $@ '**/*.{ts,tsx,yaml,yml,json,md,mdx}'",
+    "format": "yarn format:prettier --write",
+    "format:prettier": "prettier $@ '**/*.{ts,tsx,yaml,yml,json,md,mdx}'",
     "generate:readme": "oclif readme --multi --output-dir=docs < /dev/null",
     "license-check": "yarn pnpify license-checker-rseidelsohn ",
     "lint": "eslint . --cache",
@@ -31,7 +35,7 @@
     "package:windows": "oclif pack win --targets=win32-x64,win32-x86",
     "post:generate": "yarn run -T compile && yarn run -T compile:cjs",
     "test": "yarn test:format && yarn test:licenses && yarn test:unit",
-    "test:format": "yarn lint && yarn format --check",
+    "test:format": "yarn lint && yarn format:prettier --check",
     "test:licenses": "yarn license-check --summary --unknown --failOn 'UNLICENSED;UNKNOWN'",
     "test:readme": "yarn generate:readme && git diff --exit-code README.md docs/*.md",
     "test:unit": "NODE_NO_WARNINGS=1 yarn node --experimental-vm-modules $(yarn bin jest) ./src"
@@ -61,7 +65,7 @@
     "js-yaml": "^4.1.0",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "open": "^10.0.3",
+    "open": "^11.0.0",
     "parse-duration": "^2.0.1",
     "pretty-bytes": "^7.0.0",
     "react": "^19.1.1",
@@ -70,14 +74,14 @@
     "shell-escape": "^0.2.0",
     "slice-ansi": "^7.1.0",
     "string-width": "^8.0.0",
-    "tempfile": "^5.0.0",
+    "tempfile": "^6.0.1",
     "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.4",
     "@oclif/test": "^4.0.4",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^24.0.10",
+    "@types/node": "^25.0.3",
     "@types/react": "^19",
     "@types/semver": "^7.5.0",
     "@types/shell-escape": "^0.2.3",
@@ -88,7 +92,7 @@
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-json": "^4.0.1",
     "eslint-plugin-prettier": "^5.5.1",
-    "globals": "^16.0.0",
+    "globals": "^17.0.0",
     "jest": "^30.0.4",
     "license-checker-rseidelsohn": "^4.2.6",
     "nock": "^14.0.0",
@@ -288,4 +292,4 @@
     }
   },
   "packageManager": "yarn@3.6.1"
-}
+}

package/dist/commands/cronjob/execution/abort.d.ts

@@ -1,18 +0,0 @@
-import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
-import { ReactNode } from "react";
-type Result = {
-    executionId: string;
-};
-export declare class Abort extends ExecRenderBaseCommand<typeof Abort, Result> {
-    static summary: string;
-    static flags: {
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    static args: {
-        "cronjob-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        "execution-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    protected exec(): Promise<Result>;
-    protected render({ executionId }: Result): ReactNode;
-}
-export {};

package/dist/commands/cronjob/execution/abort.js

@@ -1,41 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
-import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
-import { Args } from "@oclif/core";
-import { Success } from "../../../rendering/react/components/Success.js";
-import { Value } from "../../../rendering/react/components/Value.js";
-import assertSuccess from "../../../lib/apiutil/assert_success.js";
-export class Abort extends ExecRenderBaseCommand {
-    static summary = "Abort a running cron job execution.";
-    static flags = {
-        ...processFlags,
-    };
-    static args = {
-        "cronjob-id": Args.string({
-            description: "ID of the cronjob the execution belongs to",
-            required: true,
-        }),
-        "execution-id": Args.string({
-            required: true,
-            description: "ID of the cron job execution to abort",
-        }),
-    };
-    async exec() {
-        const p = makeProcessRenderer(this.flags, "Aborting a cron job execution");
-        const { "cronjob-id": cronjobId, "execution-id": executionId } = this.args;
-        await p.runStep("aborting cron job execution", async () => {
-            const r = await this.apiClient.cronjob.abortExecution({
-                cronjobId,
-                executionId,
-            });
-            assertSuccess(r);
-        });
-        p.complete(_jsxs(Success, { children: ["Execution ", _jsx(Value, { children: executionId }), " was successfully aborted."] }));
-        return { executionId };
-    }
-    render({ executionId }) {
-        if (this.flags.quiet) {
-            return executionId;
-        }
-    }
-}