@mittwald/cli 1.0.0-alpha.46 → 1.0.0-alpha.47

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

@@ -0,0 +1,23 @@
+import { Options } from "pretty-bytes";
+/**
+ * Reexport of pretty-bytes Options type, as to not expose the pretty-bytes
+ * dependency to the outside world.
+ */
+export type ByteQuantityFormattingOptions = Options;
+/**
+ * Represents a quantity of bytes. Provides methods for parsing, formatting and
+ * manipulating byte quantities.
+ */
+export default class ByteQuantity {
+    readonly bytes: number;
+    static flag: import("@oclif/core/lib/interfaces/parser.js").FlagDefinition<ByteQuantity, import("@oclif/core/lib/interfaces/parser.js").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    private constructor();
+    static fromBytes(bytes: number): ByteQuantity;
+    static fromString(input: string, requireQuantity?: boolean): ByteQuantity;
+    format(opts?: ByteQuantityFormattingOptions): string;
+    toString(): string;
+    add(other: ByteQuantity): ByteQuantity;
+}

package/dist/lib/units/ByteQuantity.js

@@ -0,0 +1,49 @@
+import prettyBytes from "pretty-bytes";
+import { Flags } from "@oclif/core";
+/**
+ * Represents a quantity of bytes. Provides methods for parsing, formatting and
+ * manipulating byte quantities.
+ */
+export default class ByteQuantity {
+    bytes;
+    static flag = Flags.custom({
+        parse: async (input) => ByteQuantity.fromString(input, true),
+    });
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    static fromBytes(bytes) {
+        return new ByteQuantity(bytes);
+    }
+    static fromString(input, requireQuantity = false) {
+        const numeric = parseInt(input.replace(/[^0-9]/g, ""), 10);
+        if ((!requireQuantity && `${numeric}` == input) ||
+            input.toLowerCase().match(/[0-9]b?$/)) {
+            return new ByteQuantity(numeric);
+        }
+        if (input.toLowerCase().match(/gi?b?$/)) {
+            return new ByteQuantity(numeric * (1 << 30));
+        }
+        if (input.toLowerCase().match(/mi?b?$/)) {
+            return new ByteQuantity(numeric * (1 << 20));
+        }
+        if (input.toLowerCase().match(/ki?b?$/)) {
+            return new ByteQuantity(numeric * (1 << 10));
+        }
+        throw new Error("unsupported byte unit; supported are 'gi(b)', 'mi(b)', 'ki(b)' or 'b'");
+    }
+    format(opts) {
+        return prettyBytes(this.bytes, { binary: true, ...opts });
+    }
+    toString() {
+        return this.format({
+            locale: false,
+            binary: true,
+            space: false,
+            maximumFractionDigits: 0,
+        });
+    }
+    add(other) {
+        return new ByteQuantity(this.bytes + other.bytes);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { FlagDefinition } from "@oclif/core/lib/interfaces/index.js";
+/**
+ * Represents a duration of time.
+ *
+ * This class represents a duration of time and offers utility methods around
+ * this.
+ */
+export default class Duration {
+    readonly milliseconds: number;
+    static relativeFlag: FlagDefinition<Duration>;
+    static absoluteFlag: FlagDefinition<Date>;
+    private constructor();
+    static fromZero(): Duration;
+    static fromMilliseconds(milliseconds: number): Duration;
+    static fromSeconds(seconds: number): Duration;
+    static fromString(input: string): Duration;
+    get seconds(): number;
+    from(referenceDate: Date): Date;
+    fromNow(): Date;
+    add(other: Duration): Duration;
+    compare(other: Duration): number;
+    toString(): string;
+}

package/dist/lib/units/Duration.js

@@ -0,0 +1,57 @@
+import parseDuration from "parse-duration";
+import { Flags } from "@oclif/core";
+/**
+ * Represents a duration of time.
+ *
+ * This class represents a duration of time and offers utility methods around
+ * this.
+ */
+export default class Duration {
+    milliseconds;
+    static relativeFlag = Flags.custom({
+        parse: async (input) => Duration.fromString(input),
+    });
+    static absoluteFlag = Flags.custom({
+        parse: async (input) => Duration.fromString(input).fromNow(),
+    });
+    constructor(milliseconds) {
+        this.milliseconds = milliseconds;
+    }
+    static fromZero() {
+        return new Duration(0);
+    }
+    static fromMilliseconds(milliseconds) {
+        return new Duration(milliseconds);
+    }
+    static fromSeconds(seconds) {
+        return new Duration(seconds * 1000);
+    }
+    static fromString(input) {
+        const parsed = parseDuration(input);
+        if (parsed === undefined) {
+            throw new Error("could not parse duration: " + input);
+        }
+        return new Duration(parsed);
+    }
+    get seconds() {
+        return this.milliseconds / 1000;
+    }
+    from(referenceDate) {
+        return new Date(referenceDate.getTime() + this.milliseconds);
+    }
+    fromNow() {
+        return this.from(new Date());
+    }
+    add(other) {
+        return new Duration(this.milliseconds + other.milliseconds);
+    }
+    compare(other) {
+        return this.milliseconds - other.milliseconds;
+    }
+    toString() {
+        if (this.milliseconds > 1000) {
+            return `${Math.round(this.seconds)}s`;
+        }
+        return `${this.milliseconds}ms`;
+    }
+}

package/dist/lib/util/fs/hasBinaryInPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a binary is in the PATH. This is useful for commands that rely on
+ * external binaries to work. These should be asserted to exist before the
+ * command does anything else.
+ *
+ * @param name The name of the binary to check for
+ * @returns True if the binary is in the PATH
+ */
+export declare function hasBinaryInPath(name: string): Promise<boolean>;

package/dist/lib/{hasbin.js → util/fs/hasBinaryInPath.js}

@@ -1,6 +1,14 @@
 import path from "path";
 import fs from "fs";
-export async function hasBinary(name) {
+/**
+ * Checks if a binary is in the PATH. This is useful for commands that rely on
+ * external binaries to work. These should be asserted to exist before the
+ * command does anything else.
+ *
+ * @param name The name of the binary to check for
+ * @returns True if the binary is in the PATH
+ */
+export async function hasBinaryInPath(name) {
     const p = process.env.PATH ?? "";
     const pathItems = p.split(path.delimiter);
     for (const item of pathItems) {

package/dist/lib/util/fs/isNotFound.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quickly checks if an error is a "file not found" error. Intended to be used
+ * in a catch block around "fs" functions.
+ *
+ * @param e The error to check
+ * @returns True if the error is a "file not found" error
+ */
+export declare function isNotFound(e: unknown): boolean;

package/dist/lib/util/fs/isNotFound.js

@@ -0,0 +1,10 @@
+/**
+ * Quickly checks if an error is a "file not found" error. Intended to be used
+ * in a catch block around "fs" functions.
+ *
+ * @param e The error to check
+ * @returns True if the error is a "file not found" error
+ */
+export function isNotFound(e) {
+    return e instanceof Error && "code" in e && e.code === "ENOENT";
+}

package/dist/lib/util/fs/pathExists.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a filesystem path exists.
+ *
+ * @param path The filesystem path (file or directory) to check
+ * @returns True if the path exists
+ */
+export declare function pathExists(path: string): Promise<boolean>;

package/dist/lib/{fsutil.js → util/fs/pathExists.js}

@@ -1,7 +1,11 @@
 import fs from "fs/promises";
-export function isNotFound(e) {
-    return e instanceof Error && "code" in e && e.code === "ENOENT";
-}
+import { isNotFound } from "./isNotFound.js";
+/**
+ * Checks if a filesystem path exists.
+ *
+ * @param path The filesystem path (file or directory) to check
+ * @returns True if the path exists
+ */
 export async function pathExists(path) {
     try {
         await fs.stat(path);

package/dist/lib/util/maybe.d.ts

@@ -0,0 +1,12 @@
+export type OptionalFn<T> = T extends (...i: infer TIn) => infer TOut ? (...i: (TIn[number] | undefined)[]) => TOut | undefined : never;
+/**
+ * Maybe is a helper function that wraps a function and makes its input
+ * optional. When the input is undefined, the function will return undefined.
+ * Otherwise, the function will be called with the input.
+ *
+ * @param fn The function to wrap.
+ * @returns A new function that takes an optional input, and returns undefined
+ *   if the input is undefined.
+ */
+export declare function maybe<TIn, TOut>(fn: (...inputs: TIn[]) => TOut): OptionalFn<(...inputs: TIn[]) => TOut>;
+export default maybe;

package/dist/lib/util/maybe.js

@@ -0,0 +1,17 @@
+/**
+ * Maybe is a helper function that wraps a function and makes its input
+ * optional. When the input is undefined, the function will return undefined.
+ * Otherwise, the function will be called with the input.
+ *
+ * @param fn The function to wrap.
+ * @returns A new function that takes an optional input, and returns undefined
+ *   if the input is undefined.
+ */
+export function maybe(fn) {
+    return (...args) => {
+        return !args.some((a) => a === undefined)
+            ? fn(...args)
+            : undefined;
+    };
+}
+export default maybe;

package/dist/lib/util/mergeObjects.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merges two objects into one.
+ *
+ * @param obj1
+ * @param obj2
+ */
+export declare function mergeObjects<T1, T2>(obj1: T1, obj2: T2): T1 & T2;

package/dist/lib/{mergeObjects.js → util/mergeObjects.js}

@@ -1,6 +1,12 @@
-export const mergeObjects = (obj1, obj2) => {
+/**
+ * Merges two objects into one.
+ *
+ * @param obj1
+ * @param obj2
+ */
+export function mergeObjects(obj1, obj2) {
     return {
         ...Object.fromEntries(Object.entries(obj1 ?? {}).filter(([, value]) => !!value)),
         ...Object.fromEntries(Object.entries(obj2 ?? {}).filter(([, value]) => !!value)),
     };
-};
+}

package/dist/lib/util/password/generatePassword.d.ts

@@ -0,0 +1,9 @@
+export declare const defaultPasswordLength = 32;
+/**
+ * Generates a random password of a given length. The password is generated from
+ * the base64 alphabet.
+ *
+ * @param length The desired amount of characters
+ * @returns The generated password
+ */
+export declare function generatePassword(length?: number): string;

package/dist/lib/util/password/generatePassword.js

@@ -0,0 +1,12 @@
+import crypto from "crypto";
+export const defaultPasswordLength = 32;
+/**
+ * Generates a random password of a given length. The password is generated from
+ * the base64 alphabet.
+ *
+ * @param length The desired amount of characters
+ * @returns The generated password
+ */
+export function generatePassword(length = defaultPasswordLength) {
+    return crypto.randomBytes(length).toString("base64").substring(0, length);
+}

package/dist/lib/util/password/generatePasswordWithSpecialChars.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a random password of a given length with a specific amount of
+ * special characters.
+ *
+ * @param length The desired amount of characters
+ * @param amountSpecialChars The desired amount of special characters
+ * @returns The generated password
+ */
+export declare function generatePasswordWithSpecialChars(length?: number, amountSpecialChars?: number): string;

package/dist/lib/{password.js → util/password/generatePasswordWithSpecialChars.js}

@@ -1,15 +1,19 @@
-import crypto from "crypto";
+import { defaultPasswordLength, generatePassword } from "./generatePassword.js";
 const passwordAllowedSpecialChars = ["%", "_", "-", "+", "&"];
-const defaultPasswordLength = 32;
 function randomInt(min, max) {
     return Math.floor(Math.random() * (max - 1) + min);
 }
 function getRandomSpecialCharacter() {
     return passwordAllowedSpecialChars[randomInt(0, passwordAllowedSpecialChars.length - 1)];
 }
-export function generatePassword(length = defaultPasswordLength) {
-    return crypto.randomBytes(length).toString("base64").substring(0, length);
-}
+/**
+ * Generates a random password of a given length with a specific amount of
+ * special characters.
+ *
+ * @param length The desired amount of characters
+ * @param amountSpecialChars The desired amount of special characters
+ * @returns The generated password
+ */
 export function generatePasswordWithSpecialChars(length = defaultPasswordLength, amountSpecialChars = Math.floor(length / 8)) {
     const passwordCharacters = generatePassword(length).split("");
     for (let i = 0; i < amountSpecialChars; i++) {

package/dist/lib/wait.d.ts

@@ -1,5 +1,8 @@
+import Duration from "./units/Duration.js";
+import { InferredFlags } from "@oclif/core/lib/interfaces/index.js";
 export declare const waitFlags: {
     wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-    "wait-timeout": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    "wait-timeout": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<Duration, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
 };
-export declare function waitUntil<T>(tester: () => Promise<T | null>, timeoutSeconds?: number): Promise<T>;
+export type WaitFlags = InferredFlags<typeof waitFlags>;
+export declare function waitUntil<T>(tester: () => Promise<T | null>, timeout?: Duration): Promise<T>;

package/dist/lib/wait.js

@@ -1,23 +1,24 @@
 import { Flags } from "@oclif/core";
+import Duration from "./units/Duration.js";
 export const waitFlags = {
     wait: Flags.boolean({
         char: "w",
-        description: "Wait for the resource to be ready.",
+        description: "wait for the resource to be ready.",
     }),
-    "wait-timeout": Flags.integer({
-        description: "The number of seconds to wait for the resource to be ready.",
-        default: 600,
+    "wait-timeout": Duration.relativeFlag({
+        description: "the duration to wait for the resource to be ready (common units like 'ms', 's', 'm' are accepted).",
+        default: Duration.fromSeconds(600),
     }),
 };
-export async function waitUntil(tester, timeoutSeconds = 600) {
-    let waited = 0;
-    while (waited < timeoutSeconds) {
+export async function waitUntil(tester, timeout = Duration.fromSeconds(600)) {
+    let waited = Duration.fromZero();
+    while (waited.compare(timeout) < 0) {
         const result = await tester();
         if (result) {
             return result;
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
-        waited++;
+        waited = waited.add(Duration.fromSeconds(1));
     }
-    throw new Error(`expected condition was not reached after ${timeoutSeconds} seconds`);
+    throw new Error(`expected condition was not reached after ${timeout.toString()}`);
 }

package/dist/rendering/formatter/GetFormatter.d.ts

@@ -0,0 +1,11 @@
+import { FlagInput } from "@oclif/core/lib/interfaces/parser.js";
+import { Printer } from "../Printer.js";
+export interface GetOptions {
+    outputFormat: string;
+}
+export declare class GetFormatter<T = unknown> {
+    static get flags(): FlagInput;
+    private defaultPrinter;
+    constructor(defaultPrinter?: Printer<T>);
+    log(output: T, opts?: GetOptions): void;
+}

package/dist/rendering/formatter/GetFormatter.js

@@ -0,0 +1,20 @@
+import { ux } from "@oclif/core";
+import { DefaultPrinter, PrinterFactory } from "../Printer.js";
+export class GetFormatter {
+    static get flags() {
+        return {
+            output: {
+                ...ux.table.flags().output,
+                options: ["json", "yaml"],
+                char: "o",
+            },
+        };
+    }
+    defaultPrinter = new DefaultPrinter();
+    constructor(defaultPrinter = new DefaultPrinter()) {
+        this.defaultPrinter = defaultPrinter;
+    }
+    log(output, opts) {
+        PrinterFactory.build(opts?.outputFormat, this.defaultPrinter).log(output);
+    }
+}

package/dist/rendering/formatter/ListDateColumnFormatter.d.ts

@@ -0,0 +1,24 @@
+import { FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+import { DateRenderer } from "../textformat/formatDate.js";
+import { table } from "@oclif/core/lib/cli-ux/styled/table.js";
+import Column = table.Column;
+type ResourceWithCreatedAt = {
+    createdAt: string;
+};
+export declare function isResourceWithCreatedAt(resource: Record<string, unknown>): resource is ResourceWithCreatedAt;
+/**
+ * ListDateColumnFormatter is a helper class to create a column for a list
+ * formatter that can handle date formatting.
+ */
+export default class ListDateColumnFormatter {
+    private readonly flags;
+    constructor(flags: FlagOutput);
+    get renderDate(): DateRenderer;
+    buildColumn<TColumnName extends string = "createdAt">({ header, fallback, column, extended, }?: {
+        header?: string;
+        fallback?: string;
+        column?: TColumnName | "createdAt";
+        extended?: boolean;
+    }): Partial<Column<Record<string, unknown>>>;
+}
+export {};

package/dist/rendering/formatter/ListDateColumnFormatter.js

@@ -0,0 +1,28 @@
+import { formatDateISO, makeDateRendererForFormat, } from "../textformat/formatDate.js";
+import { isListFormatterFlags } from "./ListFormatter.js";
+export function isResourceWithCreatedAt(resource) {
+    return "createdAt" in resource;
+}
+/**
+ * ListDateColumnFormatter is a helper class to create a column for a list
+ * formatter that can handle date formatting.
+ */
+export default class ListDateColumnFormatter {
+    flags;
+    constructor(flags) {
+        this.flags = flags;
+    }
+    get renderDate() {
+        if (isListFormatterFlags(this.flags)) {
+            return makeDateRendererForFormat(this.flags.output, !this.flags["no-relative-dates"]);
+        }
+        return formatDateISO;
+    }
+    buildColumn({ header = "Created at", fallback = "unknown", column = "createdAt", extended = false, } = {}) {
+        return {
+            header,
+            extended,
+            get: (row) => row[column] ? this.renderDate(new Date(`${row[column]}`)) : fallback,
+        };
+    }
+}

package/dist/{Formatter.d.ts → rendering/formatter/ListFormatter.d.ts}

@@ -1,23 +1,13 @@
-import { BooleanFlag, FlagInput, FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+import { BooleanFlag, FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
 import { ux } from "@oclif/core";
-import { Printer } from "./Printer.js";
-export interface GetOptions {
-    outputFormat: string;
-}
 export type ListOptions = ux.Table.table.Options;
 export type ListColumns<TItem extends Record<string, unknown>> = ux.Table.table.Columns<TItem>;
-export declare class GetFormatter<T = unknown> {
-    static get flags(): FlagInput;
-    private defaultPrinter;
-    constructor(defaultPrinter?: Printer<T>);
-    log(output: T, opts?: GetOptions): void;
-}
 type RelevantTableBaseFlags = Partial<typeof ux.table.Flags> & Pick<typeof ux.table.Flags, "output">;
 type ListFormatterFlags = RelevantTableBaseFlags & {
     "no-relative-dates": BooleanFlag<boolean>;
 };
 type ListFormatterFlagsOutput = {
-    output: string;
+    output: "txt" | "json" | "yaml" | "csv";
     "no-relative-dates": boolean;
 };
 export declare function isListFormatterFlags(flags: FlagOutput): flags is ListFormatterFlagsOutput;

package/dist/{Formatter.js → rendering/formatter/ListFormatter.js}

@@ -1,23 +1,5 @@
 import { Flags, ux } from "@oclif/core";
-import { DefaultPrinter, PrinterFactory } from "./Printer.js";
-export class GetFormatter {
-    static get flags() {
-        return {
-            output: {
-                ...ux.table.flags().output,
-                options: ["json", "yaml"],
-                char: "o",
-            },
-        };
-    }
-    defaultPrinter = new DefaultPrinter();
-    constructor(defaultPrinter = new DefaultPrinter()) {
-        this.defaultPrinter = defaultPrinter;
-    }
-    log(output, opts) {
-        PrinterFactory.build(opts?.outputFormat, this.defaultPrinter).log(output);
-    }
-}
+import { PrinterFactory } from "../Printer.js";
 export function isListFormatterFlags(flags) {
     return "output" in flags;
 }

package/dist/rendering/formatter/printHeader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints a header with a predefined style.
+ *
+ * @deprecated Use React components instead!
+ * @param heading
+ */
+export declare function printHeader(heading: string): void;

package/dist/rendering/formatter/printHeader.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+/**
+ * Prints a header with a predefined style.
+ *
+ * @deprecated Use React components instead!
+ * @param heading
+ */
+export function printHeader(heading) {
+    console.log(chalk.bold.white(heading));
+    console.log(chalk.bold.white("─".repeat(heading.length)));
+    console.log();
+}

package/dist/rendering/formatter/printKeyValues.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints a list of key-value pairs.
+ *
+ * @deprecated Use React components instead!
+ * @param tableContents
+ */
+export declare function printKeyValues(tableContents: Record<string, string>): void;

package/dist/{lib/viewhelpers/tui.js → rendering/formatter/printKeyValues.js}

@@ -1,9 +1,10 @@
 import chalk from "chalk";
-export function printHeader(heading) {
-    console.log(chalk.bold.white(heading));
-    console.log(chalk.bold.white("─".repeat(heading.length)));
-    console.log();
-}
+/**
+ * Prints a list of key-value pairs.
+ *
+ * @deprecated Use React components instead!
+ * @param tableContents
+ */
 export function printKeyValues(tableContents) {
     const keys = Object.keys(tableContents);
     const l = Math.max(...keys.map((k) => k.length));

package/dist/rendering/lib/getTerminalWidth.d.ts

@@ -1 +1,7 @@
-export declare const getTerminalWidth: () => number | undefined;
+/**
+ * Get the width of the terminal, if available.
+ *
+ * @returns The with of the terminal in characters; undefined if process is not
+ *   attached to a TTY
+ */
+export declare function getTerminalWidth(): number | undefined;

package/dist/rendering/lib/getTerminalWidth.js

@@ -1,2 +1,9 @@
-import { stdout } from "@oclif/core";
-export const getTerminalWidth = () => stdout.isTTY ? stdout.getWindowSize()[0] : undefined;
+/**
+ * Get the width of the terminal, if available.
+ *
+ * @returns The with of the terminal in characters; undefined if process is not
+ *   attached to a TTY
+ */
+export function getTerminalWidth() {
+    return process.stdout.isTTY ? process.stdout.getWindowSize()[0] : undefined;
+}

package/dist/rendering/process/components/ProcessError.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { isValidationError } from "../../../lib/handleError.js";
+import { isValidationError } from "../../../lib/error/handleError.js";
 import { ProcessValidationErrors } from "./ProcessValidationErrors.js";
 import { Box, Text } from "ink";
 export const ProcessError = ({ err }) => {

package/dist/rendering/process/process_exec.js

@@ -1,6 +1,9 @@
 import { spawn } from "child_process";
+import debug from "debug";
+const d = debug("mw:exec");
 export async function spawnInProcess(r, title, cmd, args) {
     const step = r.addStep(title);
+    d("spawning %o with args %o", cmd, args);
     const child = spawn(cmd, args, {
         shell: false,
         stdio: ["inherit", "pipe", "pipe"],

package/dist/rendering/react/ComponentPrinter.d.ts

@@ -1,5 +1,5 @@
 import { ReactElement } from "react";
-import { Printer } from "../../Printer.js";
+import { Printer } from "../Printer.js";
 export declare class ComponentPrinter<T> implements Printer<T> {
     private render;
     constructor(render: (r: T) => ReactElement);