@nocobase/cli 2.1.0-beta.9 → 2.2.0-beta.1

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}`;
+}

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);
+}