@nocobase/cli 2.1.0-beta.44.test.4 → 2.1.0-beta.45

package/dist/lib/generated-command.js

@@ -0,0 +1,203 @@
+/**
+ * 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 { findApiCommandCompatViolation, formatApiCommandCompatViolation } from './api-command-compat.js';
+import { ensureCrossEnvConfirmed } from './env-guard.js';
+import { applyPostProcessor } from './post-processors.js';
+import { readInstalledManagedSkillsVersion } from './skills-manager.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;
+    static runtimeVersion;
+    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 cliVersion = String(this.config.pjson.version ?? '').trim();
+        const skillsVersion = await readInstalledManagedSkillsVersion();
+        const compatViolation = findApiCommandCompatViolation({
+            packageJson: this.config.pjson,
+            commandId: ctor.operation.commandId,
+            cliVersion,
+            appVersion: ctor.runtimeVersion,
+            skillsVersion,
+        });
+        if (compatViolation) {
+            this.error(formatApiCommandCompatViolation(compatViolation));
+        }
+        const response = await executeApiRequest({
+            cliVersion,
+            skillsVersion,
+            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,243 @@
+/**
+ * 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);
+        }
+    }, [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 transformedValue = value ? config.transformer?.(value) : undefined;
+    const displayValue = status === 'done'
+        ? theme.style.answer(transformedValue ?? maskChar.repeat(value.length))
+        : transformedValue ?? (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) : ''];
+});

package/dist/lib/managed-env-file.js

@@ -0,0 +1,98 @@
+/**
+ * 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 { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+import { resolveDockerEnvFileArg } from "./docker-env-file.js";
+import { resolveConfiguredAppPath } from './env-paths.js';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function stripWrappingQuotes(value) {
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        return value
+            .slice(1, -1)
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+export function parseSimpleEnvFile(content) {
+    const values = {};
+    for (const rawLine of content.split(/\r?\n/)) {
+        const trimmed = rawLine.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const line = trimmed.startsWith('export ') ? trimmed.slice('export '.length).trim() : trimmed;
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        if (!key) {
+            continue;
+        }
+        values[key] = stripWrappingQuotes(line.slice(separatorIndex + 1).trim());
+    }
+    return values;
+}
+export function resolveManagedLocalEnvFilePath(runtime) {
+    const config = runtime.env.config ?? {};
+    const explicitEnvFile = trimValue(config.envFile);
+    if (explicitEnvFile) {
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
+    }
+    const configuredAppPath = resolveConfiguredAppPath(config);
+    if (configuredAppPath) {
+        return path.join(configuredAppPath, '.env');
+    }
+    if (path.basename(runtime.projectRoot) === 'source') {
+        return path.resolve(runtime.projectRoot, '..', '.env');
+    }
+    return path.join(runtime.projectRoot, '.env');
+}
+export async function resolveManagedRuntimeEnvFilePath(runtime) {
+    if (runtime.kind === 'local') {
+        return resolveManagedLocalEnvFilePath(runtime);
+    }
+    return await resolveDockerEnvFileArg(runtime.envName, runtime.env.config ?? {});
+}
+export async function readManagedRuntimeEnvValues(runtime) {
+    const envFilePath = await resolveManagedRuntimeEnvFilePath(runtime);
+    if (!envFilePath) {
+        return {
+            envFilePath: undefined,
+            envValues: {},
+        };
+    }
+    try {
+        return {
+            envFilePath,
+            envValues: parseSimpleEnvFile(await readFile(envFilePath, 'utf8')),
+        };
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code === 'ENOENT') {
+            return {
+                envFilePath,
+                envValues: {},
+            };
+        }
+        throw error;
+    }
+}

package/dist/lib/naming.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+export function toKebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}
+export function splitPathAction(pathTemplate) {
+    const normalizedPath = pathTemplate.replace(/^\/+/, '');
+    const separatorIndex = normalizedPath.lastIndexOf(':');
+    if (separatorIndex === -1) {
+        return {
+            resourcePath: normalizedPath,
+            action: 'call',
+        };
+    }
+    return {
+        resourcePath: normalizedPath.slice(0, separatorIndex),
+        action: normalizedPath.slice(separatorIndex + 1),
+    };
+}
+export function toLogicalResourceName(pathTemplate) {
+    const { resourcePath } = splitPathAction(pathTemplate);
+    return resourcePath
+        .split('/')
+        .filter(Boolean)
+        .filter((segment) => !segment.startsWith('{'))
+        .map((segment) => toKebabCase(segment))
+        .join('.');
+}
+export function toLogicalActionName(pathTemplate) {
+    return toKebabCase(splitPathAction(pathTemplate).action);
+}
+export function toResourceSegments(pathTemplate, options) {
+    const { resourcePath, action } = splitPathAction(pathTemplate);
+    const pathSegments = resourcePath
+        .split('/')
+        .filter(Boolean)
+        .flatMap((segment) => {
+        if (!segment.startsWith('{')) {
+            return [toKebabCase(segment)];
+        }
+        if (!options?.includeParams) {
+            return [];
+        }
+        return [`by-${toKebabCase(segment.slice(1, -1))}`];
+    });
+    return [...pathSegments, toKebabCase(action)].filter(Boolean);
+}
+export function toCommandSegments(moduleName, pathTemplate, options) {
+    const resourceSegments = toResourceSegments(pathTemplate, options);
+    const segments = [options?.omitModule ? '' : toKebabCase(moduleName), ...resourceSegments].filter(Boolean);
+    return segments.length ? segments : [toKebabCase(moduleName), 'call'];
+}
+export function toClassName(segments) {
+    return segments
+        .map((segment) => segment.replace(/(^\w|-\w)/g, (token) => token.replace('-', '').toUpperCase()))
+        .join('');
+}
+export function toOutputFile(outputRoot, segments) {
+    const folder = path.join(outputRoot, ...segments.slice(0, -1));
+    const filePath = path.join(folder, `${segments.at(-1)}.ts`);
+    return filePath;
+}
+export function toImportPath(fromFile, targetFile) {
+    const relative = path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}