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

package/dist/lib/object-utils.js

@@ -0,0 +1,76 @@
+/**
+ * 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 pickKeys(object, keys) {
+    const picked = {};
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            const typedKey = key;
+            picked[typedKey] = object[typedKey];
+        }
+    }
+    return picked;
+}
+export function omitKeys(object, keys) {
+    const omittedKeys = new Set(keys);
+    const result = {};
+    for (const key of Object.keys(object)) {
+        if (!omittedKeys.has(key)) {
+            const typedKey = key;
+            result[typedKey] = object[typedKey];
+        }
+    }
+    return result;
+}
+export function upperFirst(value) {
+    if (!value) {
+        return value;
+    }
+    return value[0].toUpperCase() + value.slice(1);
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (left == null || right == null) {
+        return false;
+    }
+    if (typeof left !== typeof right) {
+        return false;
+    }
+    if (typeof left !== 'object') {
+        return false;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (!deepEqual(left[index], right[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const leftObject = left;
+    const rightObject = right;
+    const leftKeys = Object.keys(leftObject);
+    const rightKeys = Object.keys(rightObject);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(rightObject, key)) {
+            return false;
+        }
+        if (!deepEqual(leftObject[key], rightObject[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/lib/openapi.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.
+ */
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+function resolveLocalRef(document, ref) {
+    if (!ref.startsWith('#/')) {
+        return undefined;
+    }
+    return ref
+        .slice(2)
+        .split('/')
+        .reduce((current, segment) => current?.[segment], document);
+}
+function dereferenceNode(node, document, seen = new Set()) {
+    if (Array.isArray(node)) {
+        return node.map((item) => dereferenceNode(item, document, seen));
+    }
+    if (!node || typeof node !== 'object') {
+        return node;
+    }
+    const ref = node.$ref;
+    if (typeof ref === 'string') {
+        if (seen.has(ref)) {
+            return {};
+        }
+        const resolved = resolveLocalRef(document, ref);
+        if (!resolved) {
+            return node;
+        }
+        return dereferenceNode(resolved, document, new Set([...seen, ref]));
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, dereferenceNode(value, document, seen)]));
+}
+export function collectOperations(document) {
+    const operations = [];
+    for (const [pathTemplate, pathItem] of Object.entries(document.paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem?.[method];
+            if (!operation || '$ref' in operation) {
+                continue;
+            }
+            const parameters = [...(pathItem.parameters ?? []), ...(operation.parameters ?? [])]
+                .map((parameter) => dereferenceNode(parameter, document))
+                .filter((parameter) => Boolean(parameter && !('$ref' in parameter)));
+            operations.push({
+                method,
+                pathTemplate,
+                operation: {
+                    ...operation,
+                    parameters,
+                    requestBody: operation.requestBody ? dereferenceNode(operation.requestBody, document) : undefined,
+                },
+            });
+        }
+    }
+    return operations;
+}

package/dist/lib/plugin-import.js

@@ -0,0 +1,279 @@
+/**
+ * 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 fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip } from 'node:zlib';
+import * as tar from 'tar';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
+import { resolvePluginStoragePath } from './plugin-storage.js';
+import { run } from './run-npm.js';
+const NPM_PACK_TIMEOUT_MS = 30_000;
+const NPM_AUTH_ERROR_PATTERNS = [
+    'e401',
+    'e403',
+    'unauthorized',
+    'authorization',
+    'forbidden',
+    'need auth',
+    'requires authentication',
+    'unable to authenticate',
+    'authentication token',
+];
+const NPM_NOT_FOUND_ERROR_PATTERNS = [
+    'e404',
+    'etarget',
+    'not found',
+    'not in this registry',
+    'no matching version found',
+    'no match found',
+];
+const NPM_NETWORK_ERROR_PATTERNS = [
+    'enotfound',
+    'eai_again',
+    'etimedout',
+    'esockettimedout',
+    'econnreset',
+    'econnrefused',
+    'enetunreach',
+    'ehostunreach',
+    'fetch failed',
+    'getaddrinfo',
+    'timed out',
+];
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+async function pathExists(target) {
+    try {
+        await fsp.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isHttpArchiveSource(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function responseBodyToNodeReadable(body) {
+    return Readable.fromWeb(body);
+}
+function looksLikeLocalArchivePath(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith('./') ||
+        value.startsWith('../') ||
+        value.endsWith('.tgz') ||
+        value.endsWith('.tar.gz'));
+}
+function resolvePluginOutputDir(storagePluginsPath, packageName) {
+    const outputDir = path.resolve(storagePluginsPath, packageName);
+    const relative = path.relative(storagePluginsPath, outputDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Imported archive package name "${packageName}" resolves outside plugin storage.`);
+    }
+    return outputDir;
+}
+function normalizeNpmRegistry(value) {
+    const text = trimValue(value);
+    return text ? text.replace(/\/+$/, '') : undefined;
+}
+function formatNpmPackFailureMessage(source, registry, details) {
+    const normalizedDetails = details.toLowerCase();
+    const lines = [
+        `Failed to import npm package "${source}" with \`npm pack\`.`,
+        details,
+    ];
+    const loginCommand = registry ? `npm login --registry=${registry}` : 'npm login';
+    if (NPM_AUTH_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(`Hint: If this is a private registry, run \`${loginCommand}\` first and retry.`);
+        return lines.join('\n');
+    }
+    if (NPM_NOT_FOUND_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(registry
+            ? `Hint: Check that "${source}" exists in ${registry} and that the package name or tag is correct.`
+            : `Hint: Check that "${source}" exists and that the package name or tag is correct.`);
+        return lines.join('\n');
+    }
+    if (NPM_NETWORK_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(registry
+            ? `Hint: Check that the npm registry ${registry} is reachable from this machine.`
+            : 'Hint: Check that the npm registry is reachable from this machine.');
+        return lines.join('\n');
+    }
+    if (registry) {
+        lines.push(`Hint: If this is a private registry, make sure \`${loginCommand}\` has completed successfully.`);
+    }
+    return lines.join('\n');
+}
+async function resolvePackedPluginTarball(packRoot, sourceLabel) {
+    const entries = await fsp.readdir(packRoot, { withFileTypes: true });
+    const tarballs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+        .map((entry) => path.join(packRoot, entry.name))
+        .sort();
+    if (tarballs.length === 1) {
+        return tarballs[0];
+    }
+    if (tarballs.length === 0) {
+        throw new Error(`npm pack did not produce a local tarball for ${sourceLabel}.`);
+    }
+    throw new Error(`npm pack produced multiple tarballs for ${sourceLabel}.`);
+}
+async function packNpmPluginSource(source, npmRegistry, runFn = run) {
+    const packRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-plugin-pack-'));
+    const args = ['pack', '--silent'];
+    const registry = normalizeNpmRegistry(npmRegistry);
+    if (registry) {
+        args.push(`--registry=${registry}`);
+    }
+    args.push(source);
+    let stdout = '';
+    let stderr = '';
+    try {
+        await runFn('npm', args, {
+            cwd: packRoot,
+            stdio: 'pipe',
+            errorName: 'npm pack',
+            timeoutMs: NPM_PACK_TIMEOUT_MS,
+            onStdout: (chunk) => {
+                stdout += chunk;
+            },
+            onStderr: (chunk) => {
+                stderr += chunk;
+            },
+        });
+        const tarballPath = await resolvePackedPluginTarball(packRoot, source);
+        return {
+            stream: fs.createReadStream(tarballPath),
+            source,
+            sourceType: 'npm',
+            cleanup: async () => {
+                await fsp.rm(packRoot, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        await fsp.rm(packRoot, { recursive: true, force: true });
+        const originalMessage = error instanceof Error ? error.message : String(error);
+        const details = trimValue(stderr) || trimValue(stdout) || trimValue(originalMessage) || 'npm pack failed.';
+        throw new Error(formatNpmPackFailureMessage(source, registry, details));
+    }
+}
+async function openPluginSource(source, npmRegistry, runFn = run) {
+    if (isHttpArchiveSource(source)) {
+        const response = await fetchWithPreservedAuthRedirect(source);
+        if (!response.ok) {
+            const statusText = trimValue(response.statusText);
+            throw new Error(`Failed to download plugin archive from ${source}: ${response.status}${statusText ? ` ${statusText}` : ''}.`);
+        }
+        if (!response.body) {
+            throw new Error(`Downloaded plugin archive from ${source} does not include a response body.`);
+        }
+        return {
+            stream: responseBodyToNodeReadable(response.body),
+            source,
+            sourceType: 'url',
+            cleanup: async () => undefined,
+        };
+    }
+    const resolvedPath = path.resolve(process.cwd(), source);
+    if (await pathExists(resolvedPath)) {
+        return {
+            stream: fs.createReadStream(resolvedPath),
+            source: resolvedPath,
+            sourceType: 'file',
+            cleanup: async () => undefined,
+        };
+    }
+    if (looksLikeLocalArchivePath(source)) {
+        throw new Error(`Plugin archive file does not exist: ${resolvedPath}`);
+    }
+    return await packNpmPluginSource(source, npmRegistry, runFn);
+}
+async function readPluginMetadata(extractRoot, sourceLabel) {
+    const packageJsonPath = path.join(extractRoot, 'package.json');
+    let content;
+    try {
+        content = await fsp.readFile(packageJsonPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Imported archive from ${sourceLabel} does not contain a package.json at the package root.`);
+    }
+    let metadata;
+    try {
+        metadata = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Imported archive from ${sourceLabel} contains an invalid package.json.`);
+    }
+    const packageName = trimValue(metadata.name);
+    if (!packageName) {
+        throw new Error(`Imported archive from ${sourceLabel} is missing "package.json.name".`);
+    }
+    return {
+        packageName,
+        packageVersion: trimValue(metadata.version),
+    };
+}
+export async function importPluginSource(source, options = {}) {
+    const normalizedSource = trimValue(source);
+    if (!normalizedSource) {
+        throw new Error('Pass a plugin archive path, URL, or npm package spec.');
+    }
+    const storagePluginsPath = resolvePluginStoragePath(options.storagePath);
+    await fsp.mkdir(storagePluginsPath, { recursive: true });
+    const archive = await openPluginSource(normalizedSource, options.npmRegistry, options.runFn);
+    const stageDir = await fsp.mkdtemp(path.join(storagePluginsPath, '.nb-plugin-import-'));
+    let stageMoved = false;
+    try {
+        try {
+            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir, strip: 1 }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to extract plugin archive from ${archive.source}: ${message}`);
+        }
+        const { packageName, packageVersion } = await readPluginMetadata(stageDir, archive.source);
+        const outputDir = resolvePluginOutputDir(storagePluginsPath, packageName);
+        const action = (await pathExists(outputDir)) ? 'updated' : 'installed';
+        await fsp.mkdir(path.dirname(outputDir), { recursive: true });
+        await fsp.rm(outputDir, { recursive: true, force: true });
+        await fsp.rename(stageDir, outputDir);
+        stageMoved = true;
+        return {
+            action,
+            packageName,
+            packageVersion,
+            outputDir,
+            source: archive.source,
+            sourceType: archive.sourceType,
+            storagePluginsPath,
+        };
+    }
+    finally {
+        if (!stageMoved) {
+            await fsp.rm(stageDir, { recursive: true, force: true });
+        }
+        await archive.cleanup();
+    }
+}
+export async function importPluginArchive(source, storagePath) {
+    return await importPluginSource(source, { storagePath });
+}

package/dist/lib/plugin-storage.js

@@ -0,0 +1,64 @@
+/**
+ * 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 path from 'node:path';
+import { access, lstat, readlink, rm } from 'node:fs/promises';
+async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolvePluginStoragePath(storagePath) {
+    const root = String(storagePath ?? process.env.STORAGE_PATH ?? '').trim();
+    if (root) {
+        return path.join(path.isAbsolute(root) ? root : path.resolve(process.cwd(), root), 'plugins');
+    }
+    const configured = String(process.env.PLUGIN_STORAGE_PATH ?? '').trim();
+    if (configured) {
+        return path.isAbsolute(configured) ? configured : path.resolve(process.cwd(), configured);
+    }
+    return path.resolve(process.cwd(), 'storage', 'plugins');
+}
+export async function removeStoragePluginSymlink(pluginName, storagePath, nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? '').trim()) {
+    if (!nodeModulesPath) {
+        return false;
+    }
+    const storagePluginsPath = resolvePluginStoragePath(storagePath);
+    const targetPath = path.resolve(storagePluginsPath, pluginName);
+    const linkPath = path.resolve(nodeModulesPath, pluginName);
+    if (!(await pathExists(linkPath))) {
+        return false;
+    }
+    let statResult;
+    try {
+        statResult = await lstat(linkPath);
+    }
+    catch {
+        return false;
+    }
+    if (!statResult.isSymbolicLink()) {
+        return false;
+    }
+    let resolvedLinkTarget = '';
+    try {
+        const linkTarget = await readlink(linkPath);
+        resolvedLinkTarget = path.resolve(path.dirname(linkPath), linkTarget);
+    }
+    catch {
+        return false;
+    }
+    if (resolvedLinkTarget !== targetPath) {
+        return false;
+    }
+    await rm(linkPath, { recursive: true, force: true });
+    return true;
+}

package/dist/lib/post-processors.js

@@ -0,0 +1,23 @@
+function buildKey(resource, action) {
+    return `${resource}:${action}`;
+}
+class PostProcessorRegistry {
+    processors = new Map();
+    register(resource, action, processor) {
+        this.processors.set(buildKey(resource, action), processor);
+    }
+    resolve(resource, action) {
+        if (!resource || !action) {
+            return undefined;
+        }
+        return this.processors.get(buildKey(resource, action));
+    }
+}
+export const postProcessorRegistry = new PostProcessorRegistry();
+export async function applyPostProcessor(result, context) {
+    const processor = postProcessorRegistry.resolve(context.operation.logicalResourceName, context.operation.actionName);
+    if (!processor) {
+        return result;
+    }
+    return processor(result, context);
+}

package/dist/lib/prompt-catalog-core.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.
+ */
+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, valuesSoFar = {}) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key] ?? '');
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    const initialValue = def.initialValue;
+    return typeof initialValue === 'function' ? initialValue(valuesSoFar) : 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);
+}