@nocobase/cli 2.1.0-beta.32 → 2.1.0-beta.34

package/dist/lib/prompt-catalog-core.js

@@ -0,0 +1,185 @@
+/**
+ * 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 { createCliTranslate, resolveCliLocale, resolveLocalizedText, } from "./cli-locale.js";
+export function selectOptionValues(options) {
+    return options.map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function resolvePromptText(text, locale, fallback = '') {
+    return resolveLocalizedText(text, { locale, fallback });
+}
+export function enabledSelectOptionValues(options) {
+    return options
+        .filter((o) => typeof o === 'string' || o.disabled !== true)
+        .map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function createPromptCatalogHooks(locale, overrides, defaults) {
+    return {
+        onCancel: overrides?.onCancel
+            ?? defaults?.onCancel
+            ?? (() => {
+                throw new Error(createCliTranslate(locale)('promptCatalog.common.cancelled'));
+            }),
+        onMissingNonInteractive: overrides?.onMissingNonInteractive
+            ?? defaults?.onMissingNonInteractive
+            ?? ((message) => {
+                throw new Error(message);
+            }),
+    };
+}
+export function hasIvKey(iv, key) {
+    return (Object.prototype.hasOwnProperty.call(iv, key) && iv[key] !== undefined && iv[key] !== null);
+}
+export function resolveTextInitial(def, valuesSoFar) {
+    const iv = def.initialValue;
+    if (typeof iv === 'function') {
+        return iv(valuesSoFar);
+    }
+    return iv;
+}
+export 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) ?? '';
+}
+export 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;
+}
+export function mergedSelect(key, def, iv, useYesInitial) {
+    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];
+}
+export 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;
+}
+export 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;
+}
+export function isBlankText(value) {
+    return value.trim() === '';
+}
+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);
+}
+export function isPromptBlockSkipped(def, values) {
+    if (def.type === 'run') {
+        return def.when !== undefined && !def.when(values);
+    }
+    return def.hidden !== undefined && def.hidden(values);
+}
+export 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;
+        }
+    }
+}
+export function resolvePromptCatalogLocale(locale) {
+    return resolveCliLocale(locale);
+}

package/dist/lib/prompt-catalog-terminal.js

@@ -0,0 +1,375 @@
+/**
+ * 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 pc from 'picocolors';
+import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { createCliTranslate } from "./cli-locale.js";
+import { confirm, select, input, password } from "./inquirer.js";
+import { createPromptCatalogHooks, hasIvKey, isBlankText, isPromptBlockSkipped, mergedBoolean, mergedInteger, mergedPassword, mergedSelect, mergedText, resolvePromptCatalogLocale, resolvePromptText, runPromptFieldValidate, selectOptionValues, tryApplyPreset, } from "./prompt-catalog-core.js";
+function adaptInquirerValidate(validate) {
+    if (!validate) {
+        return undefined;
+    }
+    return async (value) => {
+        const result = await validate(value);
+        return result === undefined ? true : result;
+    };
+}
+function inquirerSelectOptions(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 createInquirerRenderer() {
+    return {
+        intro(message) {
+            console.log(message);
+        },
+        outro(message) {
+            console.log(message);
+        },
+        error(message) {
+            console.error(pc.red(`✖ ${message}`));
+        },
+        text(options) {
+            return input({
+                message: options.message,
+                default: options.initialValue,
+                placeholder: options.placeholder,
+                validate: adaptInquirerValidate(options.validate),
+            });
+        },
+        confirm(options) {
+            return confirm({
+                message: options.message,
+                default: options.initialValue,
+            });
+        },
+        select(options) {
+            return select({
+                message: options.message,
+                choices: options.options.map((option) => ({
+                    value: option.value,
+                    name: option.label,
+                    ...(option.hint !== undefined ? { description: option.hint } : {}),
+                    ...(option.disabled !== undefined ? { disabled: option.disabled } : {}),
+                })),
+                default: options.initialValue,
+            });
+        },
+        password(options) {
+            return password({
+                message: options.message,
+                mask: options.mask ?? '•',
+                validate: adaptInquirerValidate(options.validate),
+            });
+        },
+        isCancel(error) {
+            return error instanceof Error && error.name === 'ExitPromptError';
+        },
+    };
+}
+function defaultOnCancel(locale) {
+    void locale;
+    exit(0);
+}
+function defaultOnMissingNonInteractive(message) {
+    console.error(message);
+    exit(1);
+}
+function createTerminalHooks(locale, overrides) {
+    return createPromptCatalogHooks(locale, overrides, {
+        onCancel: () => defaultOnCancel(locale),
+        onMissingNonInteractive: defaultOnMissingNonInteractive,
+    });
+}
+async function callPrompt(run, renderer, hooks) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (renderer.isCancel(error)) {
+            hooks.onCancel();
+        }
+        throw error;
+    }
+}
+export async function runPromptCatalog(catalog, options = {}) {
+    const locale = resolvePromptCatalogLocale(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 = createTerminalHooks(locale, options.hooks);
+    const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
+    const preset = options.values ?? {};
+    const out = {};
+    const renderer = createInquirerRenderer();
+    for (const [key, def] of Object.entries(catalog)) {
+        if (isPromptBlockSkipped(def, out)) {
+            continue;
+        }
+        if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
+            const errV = await runPromptFieldValidate(def, out[key], out);
+            if (errV) {
+                hooks.onMissingNonInteractive(errV);
+            }
+            continue;
+        }
+        if (def.type === 'intro') {
+            renderer.intro(resolvePromptText(def.title, locale));
+            continue;
+        }
+        if (def.type === 'outro') {
+            renderer.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);
+            const raw = await callPrompt(() => renderer.text({
+                message,
+                initialValue: merged,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: (value) => {
+                    if (def.required && isBlankText(value)) {
+                        return t('promptCatalog.common.required');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const currentValue = typeof value === 'string' ? value : String(value ?? '');
+                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    return result;
+                },
+            }), renderer, hooks);
+            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 callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
+                    const b = Boolean(raw);
+                    const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                    if (errB) {
+                        renderer.error(errB);
+                        continue;
+                    }
+                    out[key] = b;
+                    break;
+                }
+                continue;
+            }
+            const raw = await callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
+            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 callPrompt(() => renderer.select({
+                        message,
+                        options: inquirerSelectOptions(def.options, locale),
+                        initialValue: uiInitial,
+                    }), renderer, hooks);
+                    const picked = raw;
+                    const errS = await runPromptFieldValidate(def, picked, { ...out, [key]: picked });
+                    if (errS) {
+                        renderer.error(errS);
+                        continue;
+                    }
+                    out[key] = picked;
+                    break;
+                }
+                continue;
+            }
+            const raw = await callPrompt(() => renderer.select({
+                message,
+                options: inquirerSelectOptions(def.options, locale),
+                initialValue: uiInitial,
+            }), renderer, hooks);
+            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;
+            }
+            const raw = await callPrompt(() => renderer.password({
+                message,
+                mask: def.mask,
+                validate: (value) => {
+                    if (def.required && isBlankText(value)) {
+                        return t('promptCatalog.common.required');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const currentValue = typeof value === 'string' ? value : String(value ?? '');
+                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    return result;
+                },
+            }), renderer, hooks);
+            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);
+            const raw = await callPrompt(() => renderer.text({
+                message,
+                initialValue: lineDefault,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: async (value) => {
+                    const trimmed = value.trim();
+                    if (trimmed === '') {
+                        if (def.required) {
+                            return t('promptCatalog.common.required');
+                        }
+                        if (def.validate) {
+                            const z = def.initialValue ?? 0;
+                            return runPromptFieldValidate(def, z, { ...out, [key]: z });
+                        }
+                        return undefined;
+                    }
+                    if (!/^-?\\d+$/.test(trimmed)) {
+                        return t('promptCatalog.common.mustBeInteger');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const n = Number.parseInt(trimmed, 10);
+                    return runPromptFieldValidate(def, n, { ...out, [key]: n });
+                },
+            }), renderer, hooks);
+            if (typeof raw === 'string' && raw.trim() === '' && !def.required) {
+                out[key] = def.initialValue ?? 0;
+                continue;
+            }
+            out[key] = Number.parseInt(String(raw).trim(), 10);
+        }
+    }
+    return out;
+}