@nocobase/cli 2.1.0-beta.2 → 2.1.0-beta.21

package/dist/lib/prompt-catalog.js

@@ -0,0 +1,581 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import * as p from '@clack/prompts';
+import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { createCliTranslate, resolveCliLocale, resolveLocalizedText, } from "./cli-locale.js";
+export function selectOptionValues(options) {
+    return options.map((o) => (typeof o === 'string' ? o : o.value));
+}
+function resolvePromptText(text, locale, fallback = '') {
+    return resolveLocalizedText(text, { locale, fallback });
+}
+function clackSelectOptions(options, locale) {
+    return options.map((o) => typeof o === 'string'
+        ? { value: o, label: o }
+        : {
+            value: o.value,
+            label: resolvePromptText(o.label, locale, o.value),
+            ...(o.hint !== undefined ? { hint: resolvePromptText(o.hint, locale) } : {}),
+            ...(o.disabled !== undefined ? { disabled: o.disabled } : {}),
+        });
+}
+function enabledSelectOptionValues(options) {
+    return options
+        .filter((o) => typeof o === 'string' || o.disabled !== true)
+        .map((o) => (typeof o === 'string' ? o : o.value));
+}
+function defaultOnCancel(locale) {
+    p.cancel(createCliTranslate(locale)('promptCatalog.common.cancelled'));
+    exit(0);
+}
+function defaultOnMissingNonInteractive(message) {
+    console.error(message);
+    exit(1);
+}
+function hasIvKey(iv, key) {
+    return (Object.prototype.hasOwnProperty.call(iv, key) && iv[key] !== undefined && iv[key] !== null);
+}
+function resolveTextInitial(def, valuesSoFar) {
+    const iv = def.initialValue;
+    if (typeof iv === 'function') {
+        return iv(valuesSoFar);
+    }
+    return iv;
+}
+/** `useYesInitial`: when true (resolve under `yes`), use block `yesInitialValue` before catalog `initialValue`. */
+function mergedText(key, def, iv, useYesInitial, valuesSoFar = {}) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return resolveTextInitial(def, valuesSoFar) ?? '';
+}
+function mergedBoolean(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return Boolean(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue ?? true;
+}
+function mergedSelect(key, def, iv, useYesInitial) {
+    const valueList = selectOptionValues(def.options);
+    const enabledValueList = enabledSelectOptionValues(def.options);
+    if (hasIvKey(iv, key)) {
+        const s = String(iv[key]);
+        if (enabledValueList.includes(s)) {
+            return s;
+        }
+        return undefined;
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined && enabledValueList.includes(def.yesInitialValue)) {
+        return def.yesInitialValue;
+    }
+    const d = def.initialValue;
+    if (d !== undefined && enabledValueList.includes(d)) {
+        return d;
+    }
+    return enabledValueList[0];
+}
+function mergedInteger(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        const v = iv[key];
+        return typeof v === 'number' ? v : Number.parseInt(String(v), 10);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+function mergedPassword(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key] ?? '');
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+function isBlankText(value) {
+    return value.trim() === '';
+}
+/**
+ * Runs a block’s optional **`validate`**, if present. Used by {@link runPromptCatalog} and the
+ * local web form submit path.
+ */
+export async function runPromptFieldValidate(def, value, values) {
+    if (def.type === 'intro' || def.type === 'outro' || def.type === 'run') {
+        return undefined;
+    }
+    if (!('validate' in def) || def.validate === undefined) {
+        return undefined;
+    }
+    const r = await def.validate(value, values);
+    if (r == null || r === '') {
+        return undefined;
+    }
+    return String(r);
+}
+/** When true, the block is skipped: no UI / no `out` (except `values` preset). Used by the web-UI builder and `runPromptCatalog`. */
+export function isPromptBlockSkipped(def, values) {
+    if (def.type === 'run') {
+        return def.when !== undefined && !def.when(values);
+    }
+    return def.hidden !== undefined && def.hidden(values);
+}
+/**
+ * If **`preset`** defines **`key`**, validate and set **`out[key]`**, return **`true`** (caller should `continue`).
+ * No-op for non-input block types.
+ */
+function tryApplyPreset(key, def, preset, out, hooks, locale) {
+    const t = createCliTranslate(locale);
+    if (!hasIvKey(preset, key)) {
+        return false;
+    }
+    const raw = preset[key];
+    switch (def.type) {
+        case 'intro':
+        case 'outro':
+        case 'run':
+            return false;
+        case 'text': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'boolean': {
+            out[key] = Boolean(raw);
+            return true;
+        }
+        case 'select': {
+            const valueList = selectOptionValues(def.options);
+            const s = String(raw ?? '');
+            if (!valueList.includes(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidSelect', { key, value: s, options: valueList.join(', ') }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'password': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'integer': {
+            if (typeof raw === 'number' && Number.isFinite(raw)) {
+                out[key] = raw;
+                return true;
+            }
+            const s = String(raw ?? '').trim();
+            if (s === '') {
+                if (def.required) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+                }
+                out[key] = def.initialValue ?? 0;
+                return true;
+            }
+            if (!/^-?\d+$/.test(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidInteger', { key }));
+            }
+            out[key] = Number.parseInt(s, 10);
+            return true;
+        }
+    }
+}
+/**
+ * Run a declarative catalog with @clack/prompts. No oclif / argv dependency.
+ *
+ * **Interactive** when stdin and stdout are both TTYs **and** `yes` is not set; otherwise values are taken from defaults only (no prompts). Use **`yes: true`** for a TTY session that should still accept defaults without prompting (same as CI / piped stdin).
+ *
+ * **`intro` / `outro`** steps call Clack `intro` / `outro` and do not write to the result object.
+ *
+ * Defaults are **`initialValues[key] ?? catalog block initialValue`** (per type).
+ * With **`yes: true`**, resolve uses **`{ ...initialValues, ...yesInitialValues }`** then optional per-block **`yesInitialValue`**, then **`initialValue`**.
+ * **`values`:** preset result keys — matching steps are skipped (no UI); **`initialValues`** still prefill when a step is shown.
+ * **Interactive:** prompts when the key is not set in **`values`**; prefill from **`initialValues`** + catalog **`initialValue`** (not `yes*` fields).
+ * **Non-interactive or `yes`:** uses **`values`** first, else merged defaults (no prompts).
+ * **`text`** and **`integer`** blocks may set **`placeholder`** (Clack hint when the line is empty; interactive only).
+ * Any block may set **`hidden: (values) => boolean`** using **`PromptCatalogValues`** so far; when true, the step is skipped (no **`out`** key, no **`intro`/`outro`** line), unless **`values`** preset sets this key first (no UI; **`out[key]`** still written).
+ * **`type: 'run'`** runs **`run(values, command?)`** (sync or async) with no UI and no **`out`** entry; optional **`when`** runs only when it returns true. Pass **`command`** (e.g. oclif `this`) in options when handlers need it.
+ * Blocks may set **`required`** (text / password / integer / select): empty or missing values then fail validation or `onMissingNonInteractive`.
+ * Input blocks may set **`validate(value, values)`** (sync or async): return a string to fail; used after required/type checks, and by the local web form on submit. When **`validate`** is set, interactive TTY steps re-ask on failure (`log.error` + retry) except for simple fields without a custom `validate` (fast path).
+ */
+export async function runPromptCatalog(catalog, options = {}) {
+    const locale = resolveCliLocale(options.locale);
+    const t = createCliTranslate(locale);
+    const promptIv = options.initialValues ?? {};
+    const yesIv = options.yesInitialValues ?? {};
+    const resolveIv = options.yes ? { ...promptIv, ...yesIv } : promptIv;
+    const useYesInitial = Boolean(options.yes);
+    const hooks = {
+        onCancel: options.hooks?.onCancel ?? (() => defaultOnCancel(locale)),
+        onMissingNonInteractive: options.hooks?.onMissingNonInteractive ?? defaultOnMissingNonInteractive,
+    };
+    const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
+    const preset = options.values ?? {};
+    const out = {};
+    for (const [key, def] of Object.entries(catalog)) {
+        // Apply `values` presets before `hidden` / `when` so CLI/env fixes still win without UI.
+        if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
+            const errV = await runPromptFieldValidate(def, out[key], out);
+            if (errV) {
+                hooks.onMissingNonInteractive(errV);
+            }
+            continue;
+        }
+        if (isPromptBlockSkipped(def, out)) {
+            continue;
+        }
+        if (def.type === 'intro') {
+            p.intro(resolvePromptText(def.title, locale));
+            continue;
+        }
+        if (def.type === 'outro') {
+            p.outro(resolvePromptText(def.message, locale));
+            continue;
+        }
+        if (def.type === 'run') {
+            await def.run(out, options.command);
+            continue;
+        }
+        if (def.type === 'text') {
+            const message = resolvePromptText(def.message, locale, key);
+            const placeholder = def.placeholder !== undefined
+                ? resolvePromptText(def.placeholder, locale)
+                : undefined;
+            if (!interactive) {
+                const merged = mergedText(key, def, resolveIv, useYesInitial, out);
+                if (def.required && isBlankText(merged)) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.textRequired', { key }));
+                }
+                out[key] = merged;
+                const errT = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errT) {
+                    hooks.onMissingNonInteractive(errT);
+                }
+                continue;
+            }
+            const merged = mergedText(key, def, promptIv, false, out);
+            if (def.validate) {
+                let last = merged;
+                for (;;) {
+                    const raw = await p.text({
+                        message,
+                        initialValue: last,
+                        ...(placeholder !== undefined ? { placeholder } : {}),
+                    });
+                    if (p.isCancel(raw)) {
+                        hooks.onCancel();
+                    }
+                    const s = typeof raw === 'string' ? raw : last;
+                    if (def.required && isBlankText(s)) {
+                        p.log.error(t('promptCatalog.common.required'));
+                        last = s;
+                        continue;
+                    }
+                    const errT = await runPromptFieldValidate(def, s, { ...out, [key]: s });
+                    if (errT) {
+                        p.log.error(errT);
+                        last = s;
+                        continue;
+                    }
+                    out[key] = s;
+                    break;
+                }
+                continue;
+            }
+            const raw = await p.text({
+                message,
+                initialValue: merged,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
+            });
+            if (p.isCancel(raw)) {
+                hooks.onCancel();
+            }
+            out[key] = typeof raw === 'string' ? raw : merged;
+            continue;
+        }
+        if (def.type === 'boolean') {
+            const message = resolvePromptText(def.message, locale, key);
+            if (!interactive) {
+                const b = mergedBoolean(key, def, resolveIv, useYesInitial);
+                out[key] = b;
+                const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                if (errB) {
+                    hooks.onMissingNonInteractive(errB);
+                }
+                continue;
+            }
+            const merged = mergedBoolean(key, def, promptIv, false);
+            if (def.validate) {
+                for (;;) {
+                    const raw = await p.confirm({
+                        message,
+                        initialValue: merged,
+                    });
+                    if (p.isCancel(raw)) {
+                        hooks.onCancel();
+                    }
+                    const b = Boolean(raw);
+                    const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                    if (errB) {
+                        p.log.error(errB);
+                        continue;
+                    }
+                    out[key] = b;
+                    break;
+                }
+                continue;
+            }
+            const raw = await p.confirm({
+                message,
+                initialValue: merged,
+            });
+            if (p.isCancel(raw)) {
+                hooks.onCancel();
+            }
+            out[key] = Boolean(raw);
+            continue;
+        }
+        if (def.type === 'select') {
+            const message = resolvePromptText(def.message, locale, key);
+            const valueList = selectOptionValues(def.options);
+            if (def.required && def.options.length === 0) {
+                hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.selectRequiredNoOptions', { key }));
+            }
+            if (!interactive) {
+                const merged = mergedSelect(key, def, resolveIv, useYesInitial);
+                if (merged === undefined || !valueList.includes(merged)) {
+                    const bad = hasIvKey(resolveIv, key) && !valueList.includes(String(resolveIv[key]))
+                        ? String(resolveIv[key])
+                        : hasIvKey(promptIv, key) && !valueList.includes(String(promptIv[key]))
+                            ? String(promptIv[key])
+                            : undefined;
+                    hooks.onMissingNonInteractive(bad !== undefined
+                        ? t('promptCatalog.nonInteractive.selectInvalidValue', { key, value: bad, options: valueList.join(', ') })
+                        : t('promptCatalog.nonInteractive.selectMissingDefault', { key }));
+                }
+                out[key] = merged;
+                const errS = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errS) {
+                    hooks.onMissingNonInteractive(errS);
+                }
+                continue;
+            }
+            const merged = mergedSelect(key, def, promptIv, false);
+            const uiInitial = merged ??
+                (def.initialValue && valueList.includes(def.initialValue) ? def.initialValue : undefined) ??
+                valueList[0];
+            if (uiInitial === undefined || !valueList.includes(uiInitial)) {
+                const hint = def.required
+                    ? t('promptCatalog.nonInteractive.selectRequiredInteractive', { key })
+                    : t('promptCatalog.nonInteractive.selectMissingInteractiveDefault', { key });
+                hooks.onMissingNonInteractive(hint);
+            }
+            if (def.validate) {
+                for (;;) {
+                    const raw = await p.select({
+                        message,
+                        options: clackSelectOptions(def.options, locale),
+                        initialValue: uiInitial,
+                    });
+                    if (p.isCancel(raw)) {
+                        hooks.onCancel();
+                    }
+                    const picked = raw;
+                    const errS = await runPromptFieldValidate(def, picked, { ...out, [key]: picked });
+                    if (errS) {
+                        p.log.error(errS);
+                        continue;
+                    }
+                    out[key] = picked;
+                    break;
+                }
+                continue;
+            }
+            const raw = await p.select({
+                message,
+                options: clackSelectOptions(def.options, locale),
+                initialValue: uiInitial,
+            });
+            if (p.isCancel(raw)) {
+                hooks.onCancel();
+            }
+            out[key] = raw;
+            continue;
+        }
+        if (def.type === 'password') {
+            const message = resolvePromptText(def.message, locale, key);
+            if (!interactive) {
+                const merged = mergedPassword(key, def, resolveIv, useYesInitial);
+                if (merged === undefined) {
+                    if (def.required) {
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequired', { key }));
+                    }
+                    out[key] = '';
+                    const errPE = await runPromptFieldValidate(def, '', { ...out, [key]: '' });
+                    if (errPE) {
+                        hooks.onMissingNonInteractive(errPE);
+                    }
+                    continue;
+                }
+                if (def.required && isBlankText(merged)) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequiredNonEmpty', { key }));
+                }
+                out[key] = merged;
+                const errP = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errP) {
+                    hooks.onMissingNonInteractive(errP);
+                }
+                continue;
+            }
+            if (def.validate) {
+                for (;;) {
+                    const raw = await p.password({
+                        message,
+                        validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
+                    });
+                    if (p.isCancel(raw)) {
+                        hooks.onCancel();
+                    }
+                    const s = typeof raw === 'string' ? raw : '';
+                    if (def.required && isBlankText(s)) {
+                        p.log.error(t('promptCatalog.common.required'));
+                        continue;
+                    }
+                    const errP = await runPromptFieldValidate(def, s, { ...out, [key]: s });
+                    if (errP) {
+                        p.log.error(errP);
+                        continue;
+                    }
+                    out[key] = s;
+                    break;
+                }
+                continue;
+            }
+            const raw = await p.password({
+                message,
+                validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
+            });
+            if (p.isCancel(raw)) {
+                hooks.onCancel();
+            }
+            out[key] = typeof raw === 'string' ? raw : '';
+            continue;
+        }
+        if (def.type === 'integer') {
+            const message = resolvePromptText(def.message, locale, key);
+            const placeholder = def.placeholder !== undefined
+                ? resolvePromptText(def.placeholder, locale)
+                : undefined;
+            if (!interactive) {
+                const merged = mergedInteger(key, def, resolveIv, useYesInitial);
+                if (merged === undefined) {
+                    if (def.required) {
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.integerRequired', { key }));
+                    }
+                    const z = def.initialValue ?? 0;
+                    out[key] = z;
+                    const errI = await runPromptFieldValidate(def, z, { ...out, [key]: z });
+                    if (errI) {
+                        hooks.onMissingNonInteractive(errI);
+                    }
+                    continue;
+                }
+                out[key] = merged;
+                const errI2 = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errI2) {
+                    hooks.onMissingNonInteractive(errI2);
+                }
+                continue;
+            }
+            const merged = mergedInteger(key, def, promptIv, false);
+            const lineDefault = merged !== undefined ? String(merged) : String(def.initialValue ?? 0);
+            if (def.validate) {
+                let last = lineDefault;
+                for (;;) {
+                    const raw = await p.text({
+                        message,
+                        initialValue: last,
+                        ...(placeholder !== undefined ? { placeholder } : {}),
+                        validate: (value) => {
+                            const trimmed = value.trim();
+                            if (trimmed === '') {
+                                return def.required ? t('promptCatalog.common.required') : undefined;
+                            }
+                            if (!/^-?\d+$/.test(trimmed)) {
+                                return t('promptCatalog.common.mustBeInteger');
+                            }
+                            return undefined;
+                        },
+                    });
+                    if (p.isCancel(raw)) {
+                        hooks.onCancel();
+                    }
+                    if (typeof raw === 'string' && raw.trim() === '' && !def.required) {
+                        const z = def.initialValue ?? 0;
+                        out[key] = z;
+                        const errI = await runPromptFieldValidate(def, z, { ...out, [key]: z });
+                        if (errI) {
+                            p.log.error(errI);
+                            last = raw;
+                            continue;
+                        }
+                        break;
+                    }
+                    const n = Number.parseInt(String(raw).trim(), 10);
+                    const errI = await runPromptFieldValidate(def, n, { ...out, [key]: n });
+                    if (errI) {
+                        p.log.error(errI);
+                        last = typeof raw === 'string' ? raw : last;
+                        continue;
+                    }
+                    out[key] = n;
+                    break;
+                }
+                continue;
+            }
+            const raw = await p.text({
+                message,
+                initialValue: lineDefault,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: (value) => {
+                    const trimmed = value.trim();
+                    if (trimmed === '') {
+                        return def.required ? t('promptCatalog.common.required') : undefined;
+                    }
+                    if (!/^-?\d+$/.test(trimmed)) {
+                        return t('promptCatalog.common.mustBeInteger');
+                    }
+                    return undefined;
+                },
+            });
+            if (p.isCancel(raw)) {
+                hooks.onCancel();
+            }
+            if (typeof raw === 'string' && raw.trim() === '' && !def.required) {
+                out[key] = def.initialValue ?? 0;
+                continue;
+            }
+            out[key] = Number.parseInt(String(raw).trim(), 10);
+            continue;
+        }
+    }
+    return out;
+}