@nocobase/cli 2.1.0-alpha.3 → 2.1.0-alpha.30

package/dist/lib/env-config.js

@@ -0,0 +1,87 @@
+/**
+ * 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',
+    'appPort',
+    'appKey',
+    'timezone',
+    'dbDialect',
+    'builtinDbImage',
+    'dbHost',
+    'dbPort',
+    'dbDatabase',
+    'dbUser',
+    'dbPassword',
+    'rootUsername',
+    'rootEmail',
+    'rootPassword',
+    'rootNickname',
+];
+const BOOLEAN_ENV_CONFIG_KEYS = [
+    'builtinDb',
+    'devDependencies',
+    'build',
+    'buildDts',
+];
+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);
+    const accessToken = trimConfigValue(input.accessToken);
+    if (authType === 'token' && accessToken) {
+        envConfig.accessToken = accessToken;
+    }
+    return envConfig;
+}

package/dist/lib/generated-command.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { 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.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 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/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/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-storage.js

@@ -0,0 +1,127 @@
+/**
+ * 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, mkdir, readdir, readlink, realpath, rm, stat, symlink } 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');
+}
+async function getStoragePluginNames(target) {
+    const plugins = [];
+    const items = await readdir(target);
+    for (const item of items) {
+        const itemPath = path.resolve(target, item);
+        if (item.startsWith('@')) {
+            const statResult = await stat(itemPath);
+            if (!statResult.isDirectory()) {
+                continue;
+            }
+            const children = await getStoragePluginNames(itemPath);
+            plugins.push(...children.map((child) => `${item}/${child}`));
+            continue;
+        }
+        if (await pathExists(path.resolve(itemPath, 'package.json'))) {
+            plugins.push(item);
+        }
+    }
+    return plugins;
+}
+async function ensureOrgDirectory(nodeModulesPath, pluginName) {
+    if (!pluginName.startsWith('@')) {
+        return;
+    }
+    const [orgName] = pluginName.split('/');
+    await mkdir(path.resolve(nodeModulesPath, orgName), { recursive: true });
+}
+async function isSymlinkValid(linkPath, targetPath) {
+    try {
+        if (await pathExists(linkPath)) {
+            const realPath = await realpath(linkPath);
+            return realPath === targetPath;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+async function createStoragePluginSymlink(storagePluginsPath, nodeModulesPath, pluginName) {
+    const targetPath = path.resolve(storagePluginsPath, pluginName);
+    if (!(await pathExists(targetPath))) {
+        return;
+    }
+    await ensureOrgDirectory(nodeModulesPath, pluginName);
+    const linkPath = path.resolve(nodeModulesPath, pluginName);
+    if (await isSymlinkValid(linkPath, targetPath)) {
+        return;
+    }
+    await rm(linkPath, { recursive: true, force: true });
+    await symlink(targetPath, linkPath, 'dir');
+}
+export async function createStoragePluginsSymlink(storagePath, nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? '').trim()) {
+    if (!nodeModulesPath) {
+        return;
+    }
+    const storagePluginsPath = resolvePluginStoragePath(storagePath);
+    if (!(await pathExists(storagePluginsPath))) {
+        return;
+    }
+    const pluginNames = await getStoragePluginNames(storagePluginsPath);
+    await Promise.all(pluginNames.map(async (pluginName) => await createStoragePluginSymlink(storagePluginsPath, nodeModulesPath, pluginName)));
+}
+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);
+}