@nocobase/cli 2.1.0-alpha.4 → 2.1.0-alpha.40

package/dist/lib/env-config.js

@@ -0,0 +1,94 @@
+/**
+ * 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.
+ */
+const STRING_ENV_CONFIG_KEYS = [
+    'source',
+    'downloadVersion',
+    'dockerRegistry',
+    'dockerPlatform',
+    'gitUrl',
+    'npmRegistry',
+    'appRootPath',
+    'storagePath',
+    'envFile',
+    'appPort',
+    'appKey',
+    'timezone',
+    'dbDialect',
+    'builtinDbImage',
+    'dbHost',
+    'dbPort',
+    'dbDatabase',
+    'dbUser',
+    'dbPassword',
+    'dbSchema',
+    'dbTablePrefix',
+    'rootUsername',
+    'rootEmail',
+    'rootPassword',
+    'rootNickname',
+];
+const BOOLEAN_ENV_CONFIG_KEYS = [
+    'builtinDb',
+    'devDependencies',
+    'build',
+    'buildDts',
+    'dbUnderscored',
+];
+function trimConfigValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveEnvKind(input) {
+    const source = trimConfigValue(input.source);
+    const appRootPath = trimConfigValue(input.appRootPath);
+    if (source === 'docker') {
+        return 'docker';
+    }
+    if (source === 'npm' || source === 'git' || source === 'local' || appRootPath) {
+        return 'local';
+    }
+    return 'http';
+}
+export function buildStoredEnvConfig(input) {
+    const envConfig = {
+        kind: resolveEnvKind(input),
+        apiBaseUrl: trimConfigValue(input.apiBaseUrl) ?? '',
+    };
+    for (const key of STRING_ENV_CONFIG_KEYS) {
+        const value = trimConfigValue(input[key]);
+        if (value) {
+            envConfig[key] = value;
+        }
+    }
+    for (const key of BOOLEAN_ENV_CONFIG_KEYS) {
+        const value = input[key];
+        if (typeof value === 'boolean') {
+            envConfig[key] = value;
+        }
+    }
+    if (input.builtinDb === false) {
+        envConfig.builtinDbImage = undefined;
+    }
+    if (input.builtinDb === true) {
+        delete envConfig.dbHost;
+        const source = trimConfigValue(input.source);
+        if (source === 'docker') {
+            delete envConfig.dbPort;
+        }
+    }
+    const authType = trimConfigValue(input.authType);
+    if (authType === 'token' || authType === 'oauth') {
+        envConfig.authType = authType;
+    }
+    const accessToken = trimConfigValue(input.accessToken);
+    if (authType === 'token' && accessToken) {
+        envConfig.accessToken = accessToken;
+    }
+    return envConfig;
+}

package/dist/lib/env-guard.js

@@ -0,0 +1,62 @@
+/**
+ * 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 { stdin as input, stdout as output } from 'node:process';
+import { getCurrentEnvName } from './auth-store.js';
+import { confirm } from "./inquirer.js";
+function normalizeEnvName(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+export function hasExplicitEnvSelection(argv) {
+    return argv.some((token, index) => (token === '--env'
+        || token === '-e'
+        || token.startsWith('--env=')
+        || (token.startsWith('-e') && token.length > 2 && index >= 0)));
+}
+function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+function formatCrossEnvPromptMessage(currentEnv, requestedEnv) {
+    return `Current env is "${currentEnv}", but this command targets "${requestedEnv}" via --env. Continue without switching the current env?`;
+}
+export function formatCrossEnvRefusalMessage(currentEnv, requestedEnv) {
+    return [
+        `Refusing to run against env "${requestedEnv}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current agent session.`,
+        '',
+        'For safety, the agent will not switch envs automatically and will not add --yes on your behalf.',
+        '',
+        'To continue:',
+        `- run \`nb env use ${requestedEnv}\` yourself and then re-run the command, or`,
+        `- re-run the same command with \`--env ${requestedEnv} --yes\` to confirm this one-off cross-env operation.`,
+    ].join('\n');
+}
+export async function ensureCrossEnvConfirmed(options) {
+    const requestedEnv = normalizeEnvName(options.requestedEnv);
+    if (!requestedEnv) {
+        return true;
+    }
+    const currentEnv = normalizeEnvName(await getCurrentEnvName());
+    const interactiveTerminal = isInteractiveTerminal();
+    const bypassInteractivePrompt = interactiveTerminal && Boolean(options.yes);
+    if (!currentEnv || currentEnv === requestedEnv || bypassInteractivePrompt) {
+        return true;
+    }
+    if (!interactiveTerminal) {
+        options.command.error(formatCrossEnvRefusalMessage(currentEnv, requestedEnv));
+    }
+    try {
+        return Boolean(await confirm({
+            message: formatCrossEnvPromptMessage(currentEnv, requestedEnv),
+            default: false,
+        }));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/generated-command.js

@@ -0,0 +1,186 @@
+/**
+ * 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.
+ */
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { executeApiRequest } from './api-client.js';
+import { ensureCrossEnvConfirmed } from './env-guard.js';
+import { applyPostProcessor } from './post-processors.js';
+import { registerPostProcessors } from '../post-processors/index.js';
+function buildParameterFlag(parameter, options) {
+    const hints = [parameter.in];
+    if (parameter.isFile) {
+        hints.push('file path');
+    }
+    else if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
+        hints.push('JSON');
+    }
+    else if (parameter.isArray) {
+        hints.push('repeatable');
+    }
+    else if (parameter.type) {
+        hints.push(parameter.type);
+    }
+    const description = [
+        `${parameter.description ?? ''}${parameter.description ? ' ' : ''}[${hints.join(', ')}]`.trim(),
+        parameter.jsonShape ? `Shape: ${parameter.jsonShape}` : undefined,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const required = options?.required ?? parameter.required;
+    const helpGroup = parameter.in === 'body'
+        ? 'Body Field'
+        : parameter.in === 'path'
+            ? 'Path Parameter'
+            : parameter.in === 'query'
+                ? 'Query Parameter'
+                : parameter.in === 'header'
+                    ? 'Header Parameter'
+                    : parameter.in === 'cookie'
+                        ? 'Cookie Parameter'
+                        : undefined;
+    if (parameter.type === 'boolean') {
+        return Flags.boolean({
+            description,
+            allowNo: true,
+            ...(helpGroup ? { helpGroup } : {}),
+            ...(required ? { required: true } : {}),
+        });
+    }
+    if (parameter.isArray && !parameter.jsonEncoded) {
+        return Flags.string({
+            description,
+            multiple: true,
+            ...(helpGroup ? { helpGroup } : {}),
+            ...(required ? { required: true } : {}),
+        });
+    }
+    return Flags.string({
+        description,
+        ...(helpGroup ? { helpGroup } : {}),
+        ...(required ? { required: true } : {}),
+    });
+}
+export function createGeneratedFlags(operation) {
+    const flags = {};
+    for (const parameter of operation.parameters) {
+        flags[parameter.flagName] = buildParameterFlag(parameter, {
+            // Body flags are an alternative authoring path to --body/--body-file.
+            // Enforce required body semantics later in parseBody(), after we know
+            // which input mode the user chose.
+            required: parameter.in === 'body' && !parameter.isFile ? false : parameter.required,
+        });
+    }
+    if (operation.hasBody && operation.requestContentType !== 'multipart/form-data') {
+        flags.body = Flags.string({
+            description: 'Full JSON request body string. Do not combine with body field flags.',
+            helpGroup: 'Raw JSON Body',
+            exclusive: ['body-file'],
+        });
+        flags['body-file'] = Flags.string({
+            description: 'Path to a JSON file containing the full request body. Do not combine with body field flags.',
+            helpGroup: 'Raw JSON Body',
+            exclusive: ['body'],
+        });
+    }
+    if (operation.responseType === 'binary') {
+        flags.output = Flags.string({
+            description: 'Path where the downloaded response should be written.',
+            helpGroup: 'Output',
+            required: true,
+        });
+    }
+    flags['api-base-url'] = Flags.string({
+        description: 'NocoBase API base URL, for example http://localhost:13000/api',
+        helpGroup: 'Global',
+    });
+    flags.verbose = Flags.boolean({
+        description: 'Show detailed progress output',
+        default: false,
+        helpGroup: 'Global',
+    });
+    flags.yes = Flags.boolean({
+        char: 'y',
+        description: 'Confirm using --env when it targets a different env than the current env',
+        default: false,
+        helpGroup: 'Global',
+    });
+    flags.env = Flags.string({
+        char: 'e',
+        description: 'Environment name',
+        helpGroup: 'Global',
+    });
+    flags.role = Flags.string({
+        description: 'Role override, sent as X-Role',
+        helpGroup: 'Global',
+    });
+    flags.token = Flags.string({
+        char: 't',
+        description: 'API key override',
+        helpGroup: 'Global',
+    });
+    flags['json-output'] = Flags.boolean({
+        char: 'j',
+        description: 'Print raw JSON response',
+        default: true,
+        allowNo: true,
+        helpGroup: 'Global',
+    });
+    return flags;
+}
+export class GeneratedApiCommand extends Command {
+    static operation;
+    async run() {
+        registerPostProcessors();
+        const ctor = this.constructor;
+        const { flags } = await this.parse(ctor);
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv: flags.env,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const response = await executeApiRequest({
+            envName: flags.env,
+            baseUrl: flags['api-base-url'],
+            role: flags.role,
+            token: flags.token,
+            flags,
+            operation: {
+                method: ctor.operation.method,
+                pathTemplate: ctor.operation.pathTemplate,
+                parameters: ctor.operation.parameters,
+                hasBody: ctor.operation.hasBody,
+                bodyRequired: ctor.operation.bodyRequired,
+                requestContentType: ctor.operation.requestContentType,
+                responseType: ctor.operation.responseType,
+            },
+        });
+        if (!response.ok) {
+            this.error(`Request failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`);
+        }
+        const processedData = await applyPostProcessor(response.data, {
+            flags,
+            operation: ctor.operation,
+        });
+        if (flags['json-output']) {
+            this.log(JSON.stringify(processedData, null, 2));
+            return;
+        }
+        this.log(`HTTP ${response.status}`);
+    }
+}

package/dist/lib/http-request.js

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+function normalizeLocationUrl(location, currentUrl) {
+    try {
+        return new URL(location, currentUrl).toString();
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+function shouldPreserveAuthorizationRedirect(fromUrl, toUrl) {
+    try {
+        const from = new URL(fromUrl);
+        const to = new URL(toUrl);
+        return (from.hostname === to.hostname &&
+            from.port === to.port &&
+            from.pathname === to.pathname &&
+            from.search === to.search &&
+            from.protocol === 'http:' &&
+            to.protocol === 'https:');
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export async function fetchWithPreservedAuthRedirect(url, init = {}) {
+    const response = await fetch(url, {
+        ...init,
+        redirect: 'manual',
+    });
+    const location = response.headers.get('location');
+    if (!location || ![301, 302, 307, 308].includes(response.status)) {
+        return response;
+    }
+    const nextUrl = normalizeLocationUrl(location, url);
+    if (!nextUrl || !shouldPreserveAuthorizationRedirect(url, nextUrl)) {
+        return response;
+    }
+    return fetch(nextUrl, {
+        ...init,
+        redirect: 'manual',
+    });
+}

package/dist/lib/inquirer-theme.js

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export function buildPlainMessageTheme(extra) {
+    return {
+        ...extra,
+        style: {
+            ...extra?.style,
+            message: (text) => text,
+        },
+    };
+}

package/dist/lib/inquirer.js

@@ -0,0 +1,244 @@
+/**
+ * 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 { cursorTo } from '@inquirer/ansi';
+import pc from 'picocolors';
+import { createPrompt, isBackspaceKey, isEnterKey, makeTheme, useEffect, useKeypress, usePrefix, useState, } from '@inquirer/core';
+let confirmModulePromise;
+let selectModulePromise;
+function loadConfirmModule() {
+    confirmModulePromise ??= import('@inquirer/confirm');
+    return confirmModulePromise;
+}
+function loadSelectModule() {
+    selectModulePromise ??= import('@inquirer/select');
+    return selectModulePromise;
+}
+export function buildPlainMessageTheme(extra) {
+    return {
+        ...extra,
+        style: {
+            ...extra?.style,
+            message: (text) => text,
+        },
+    };
+}
+function buildSelectAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function buildConfirmAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+function stringWidth(value) {
+    let width = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null)
+            continue;
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f))
+            continue;
+        width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+function stripAnsi(value) {
+    return value.replace(new RegExp(String.raw `\\u001B\\[[0-9;]*m`, 'g'), '');
+}
+function lastLineWidth(value) {
+    const lines = stripAnsi(value).split('\n');
+    return stringWidth(lines[lines.length - 1] ?? '');
+}
+function resolveRequiredError(required) {
+    if (typeof required === 'string') {
+        return required;
+    }
+    return '此项为必填';
+}
+function hasUsableDefault(value) {
+    return value != null && value !== '';
+}
+function buildIdleHint(config) {
+    const placeholder = config.placeholder?.trim();
+    if (placeholder) {
+        return placeholder;
+    }
+    return '';
+}
+function buildInputLine(value) {
+    return `${pc.cyan('❯')} ${value}`;
+}
+function buildErrorLine(error) {
+    return pc.red(`✖ ${error}`);
+}
+export const input = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [defaultValue, setDefaultValue] = useState(config.default ?? '');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useEffect((rl) => {
+        if (config.default) {
+            rl.write(config.default);
+            setValue(config.default);
+        }
+    }, []);
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (isBackspaceKey(key) && !value) {
+            setDefaultValue('');
+            return;
+        }
+        if (isBackspaceKey(key)) {
+            setValue(rl.line.slice(0, -1));
+            setError(undefined);
+            return;
+        }
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value || defaultValue;
+        setStatus('loading');
+        if (!answer && config.required) {
+            rl.write(value);
+            setError(resolveRequiredError(config.required));
+            setStatus('idle');
+            return;
+        }
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const isTyping = value.length > 0;
+    const hasDefault = hasUsableDefault(defaultValue);
+    const idleHint = buildIdleHint(config);
+    const showIdleHint = !isTyping && status === 'idle' && idleHint !== '';
+    const showDefaultValue = !isTyping && status === 'idle' && hasDefault;
+    const displayValue = status === 'done'
+        ? theme.style.answer(value)
+        : isTyping
+            ? value
+            : showDefaultValue
+                ? defaultValue
+                : showIdleHint
+                    ? pc.dim(idleHint)
+                    : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    const promptWithCursorFix = showIdleHint
+        ? prompt + cursorTo(lastLineWidth(buildInputLine('')))
+        : showDefaultValue
+            ? prompt + cursorTo(lastLineWidth(buildInputLine(defaultValue)))
+            : prompt;
+    return [promptWithCursorFix, error ? buildErrorLine(error) : ''];
+});
+export async function confirm(options) {
+    const module = await loadConfirmModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildConfirmAnswer,
+            },
+            ...options.theme,
+        }),
+        transformer: options.transformer ?? ((value) => (value ? 'Yes' : 'No')),
+    });
+}
+export async function select(options) {
+    const module = await loadSelectModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildSelectAnswer,
+            },
+            ...options.theme,
+        }),
+    });
+}
+function resolveMaskChar(mask) {
+    if (typeof mask === 'string') {
+        return mask;
+    }
+    if (mask === false) {
+        return '';
+    }
+    return '•';
+}
+export const password = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value;
+        setStatus('loading');
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const maskChar = resolveMaskChar(config.mask);
+    const displayValue = status === 'done'
+        ? theme.style.answer(maskChar.repeat(value.length))
+        : maskChar
+            ? maskChar.repeat(value.length)
+            : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    return [prompt, error ? buildErrorLine(error) : ''];
+});