@nocobase/cli 2.1.0-alpha.26 → 2.1.0-alpha.28

package/dist/lib/cli-config.js

@@ -0,0 +1,176 @@
+/**
+ * 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 { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
+import { resolveDefaultConfigScope } from './cli-home.js';
+export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
+export const DEFAULT_DOCKER_NETWORK = 'nocobase';
+export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
+export const SUPPORTED_CLI_CONFIG_KEYS = [
+    'license.pkg-url',
+    'docker.network',
+    'docker.container-prefix',
+];
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveScope(options = {}) {
+    return {
+        scope: options.scope ?? resolveDefaultConfigScope(),
+    };
+}
+export function isSupportedCliConfigKey(value) {
+    return SUPPORTED_CLI_CONFIG_KEYS.includes(value);
+}
+export function assertSupportedCliConfigKey(value) {
+    if (!isSupportedCliConfigKey(value)) {
+        throw new Error(`Unsupported config key "${value}". Supported keys: ${SUPPORTED_CLI_CONFIG_KEYS.join(', ')}`);
+    }
+    return value;
+}
+function cloneSettings(config) {
+    return {
+        license: config.settings?.license ? { ...config.settings.license } : undefined,
+        docker: config.settings?.docker ? { ...config.settings.docker } : undefined,
+    };
+}
+function pruneSettings(config) {
+    const license = config.settings?.license;
+    if (license && !trimValue(license.pkgUrl)) {
+        delete config.settings?.license;
+    }
+    const docker = config.settings?.docker;
+    if (docker && !trimValue(docker.network) && !trimValue(docker.containerPrefix)) {
+        delete config.settings?.docker;
+    }
+    if (config.settings
+        && !config.settings.license
+        && !config.settings.docker) {
+        delete config.settings;
+    }
+}
+export function getExplicitCliConfigValue(config, key) {
+    switch (key) {
+        case 'license.pkg-url':
+            return trimValue(config.settings?.license?.pkgUrl);
+        case 'docker.network':
+            return trimValue(config.settings?.docker?.network);
+        case 'docker.container-prefix':
+            return trimValue(config.settings?.docker?.containerPrefix);
+    }
+}
+export function getEffectiveCliConfigValue(config, key) {
+    const explicit = getExplicitCliConfigValue(config, key);
+    if (explicit) {
+        return explicit;
+    }
+    switch (key) {
+        case 'license.pkg-url':
+            return DEFAULT_LICENSE_PKG_URL;
+        case 'docker.network':
+            return trimValue(config.name) || DEFAULT_DOCKER_NETWORK;
+        case 'docker.container-prefix':
+            return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
+    }
+}
+export function normalizeCliConfigValue(key, value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`Config key "${key}" requires a non-empty value.`);
+    }
+    if (key === 'license.pkg-url') {
+        return normalized.replace(/\/+$/, '') + '/';
+    }
+    return normalized;
+}
+export async function loadCliConfig(options = {}) {
+    return await loadExactAuthConfig(resolveScope(options));
+}
+export async function getCliConfigValue(key, options = {}) {
+    const config = await loadCliConfig(options);
+    return getEffectiveCliConfigValue(config, key);
+}
+export async function listExplicitCliConfigValues(options = {}) {
+    const config = await loadCliConfig(options);
+    const out = {};
+    for (const key of SUPPORTED_CLI_CONFIG_KEYS) {
+        const value = getExplicitCliConfigValue(config, key);
+        if (value) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+export async function setCliConfigValue(key, value, options = {}) {
+    const scope = resolveScope(options);
+    const config = await loadExactAuthConfig(scope);
+    const normalized = normalizeCliConfigValue(key, value);
+    config.settings = cloneSettings(config);
+    switch (key) {
+        case 'license.pkg-url':
+            config.settings.license = {
+                ...(config.settings.license ?? {}),
+                pkgUrl: normalized,
+            };
+            break;
+        case 'docker.network':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                network: normalized,
+            };
+            break;
+        case 'docker.container-prefix':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                containerPrefix: normalized,
+            };
+            break;
+    }
+    pruneSettings(config);
+    await saveAuthConfig(config, scope);
+    return normalized;
+}
+export async function deleteCliConfigValue(key, options = {}) {
+    const scope = resolveScope(options);
+    const config = await loadExactAuthConfig(scope);
+    const hadValue = Boolean(getExplicitCliConfigValue(config, key));
+    if (!hadValue) {
+        return false;
+    }
+    config.settings = cloneSettings(config);
+    switch (key) {
+        case 'license.pkg-url':
+            if (config.settings.license) {
+                delete config.settings.license.pkgUrl;
+            }
+            break;
+        case 'docker.network':
+            if (config.settings.docker) {
+                delete config.settings.docker.network;
+            }
+            break;
+        case 'docker.container-prefix':
+            if (config.settings.docker) {
+                delete config.settings.docker.containerPrefix;
+            }
+            break;
+    }
+    pruneSettings(config);
+    await saveAuthConfig(config, scope);
+    return true;
+}
+export async function resolveDockerNetworkName(options = {}) {
+    return await getCliConfigValue('docker.network', options);
+}
+export async function resolveDockerContainerPrefix(options = {}) {
+    return await getCliConfigValue('docker.container-prefix', options);
+}
+export async function resolveLicensePkgUrlFromConfig(options = {}) {
+    return await getCliConfigValue('license.pkg-url', options);
+}

package/dist/lib/cli-home.js

@@ -6,15 +6,12 @@
  * 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 os from 'node:os';
 import path from 'node:path';
 export const CLI_HOME_DIRNAME = '.nocobase';
-export const NB_CONFIG_SCOPE_ENV = 'NB_CONFIG_SCOPE';
 export const NB_CLI_ROOT_ENV = 'NB_CLI_ROOT';
 export function resolveDefaultConfigScope() {
-    const raw = String(process.env[NB_CONFIG_SCOPE_ENV] ?? '').trim().toLowerCase();
-    return raw === 'project' ? 'project' : 'global';
+    return 'global';
 }
 function readConfiguredPath(name) {
     const value = String(process.env[name] ?? '').trim();
@@ -24,28 +21,15 @@ function resolveGlobalCliHomeRoot() {
     return readConfiguredPath(NB_CLI_ROOT_ENV) ?? os.homedir();
 }
 export function resolveCliHomeRoot(scope = resolveDefaultConfigScope()) {
-    const cwdRoot = process.cwd();
-    if (scope === 'project') {
-        return cwdRoot;
-    }
-    if (scope === 'global') {
-        return resolveGlobalCliHomeRoot();
-    }
-    const cwdCliHome = path.join(cwdRoot, CLI_HOME_DIRNAME);
-    if (fs.existsSync(cwdCliHome)) {
-        return cwdRoot;
-    }
+    void scope;
     return resolveGlobalCliHomeRoot();
 }
 export function resolveCliHomeDir(scope = resolveDefaultConfigScope()) {
     return path.join(resolveCliHomeRoot(scope), CLI_HOME_DIRNAME);
 }
 export function resolveEnvRoot(scope = resolveDefaultConfigScope()) {
-    const envRoot = readConfiguredPath(NB_CLI_ROOT_ENV);
-    if (envRoot) {
-        return path.resolve(envRoot);
-    }
-    return resolveCliHomeRoot(scope);
+    void scope;
+    return resolveCliHomeRoot();
 }
 export function resolveEnvRelativePath(relativePath, scope = resolveDefaultConfigScope()) {
     return path.resolve(resolveEnvRoot(scope), relativePath);
@@ -58,5 +42,6 @@ export function resolveConfiguredEnvPath(value, scope = resolveDefaultConfigScop
     return path.isAbsolute(text) ? text : resolveEnvRelativePath(text, scope);
 }
 export function formatCliHomeScope(scope) {
-    return scope === 'project' ? 'project' : 'global';
+    void scope;
+    return 'global';
 }

package/dist/lib/db-connection-check.js

@@ -0,0 +1,178 @@
+/**
+ * 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 { translateCli } from "./cli-locale.js";
+import { validateTcpPort } from "./prompt-validators.js";
+const DB_CONNECTION_TIMEOUT_MS = 5_000;
+const externalDbValidationCache = new Map();
+function trimPromptValue(value) {
+    return String(value ?? '').trim();
+}
+export function readExternalDbConnectionConfig(values) {
+    const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
+    if (builtinDb) {
+        return undefined;
+    }
+    const dialect = trimPromptValue(values.dbDialect || 'postgres');
+    if (dialect !== 'postgres' && dialect !== 'kingbase' && dialect !== 'mysql' && dialect !== 'mariadb') {
+        return undefined;
+    }
+    const host = trimPromptValue(values.dbHost);
+    const portText = trimPromptValue(values.dbPort);
+    const database = trimPromptValue(values.dbDatabase);
+    const user = trimPromptValue(values.dbUser);
+    const password = String(values.dbPassword ?? '');
+    if (!host || !portText || !database || !user || !password) {
+        return undefined;
+    }
+    if (validateTcpPort(portText)) {
+        return undefined;
+    }
+    return {
+        dialect,
+        host,
+        port: Number.parseInt(portText, 10),
+        database,
+        user,
+        password,
+    };
+}
+export function formatDbCheckAddress(config) {
+    return `${config.host}:${config.port}/${config.database}`;
+}
+function buildValidationCacheKey(config) {
+    return JSON.stringify(config);
+}
+function formatDbConnectionError(config, error) {
+    const maybeError = error;
+    const code = String(maybeError?.code ?? '').trim().toUpperCase();
+    const errno = typeof maybeError?.errno === 'number' ? maybeError.errno : undefined;
+    const rawMessage = String(maybeError?.message || maybeError?.sqlMessage || error || '').trim();
+    if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'EHOSTUNREACH' || code === 'ECONNRESET') {
+        return translateCli('validators.dbConnection.unreachable', {
+            host: config.host,
+            port: config.port,
+            details: rawMessage,
+        });
+    }
+    if (code === 'ETIMEDOUT') {
+        return translateCli('validators.dbConnection.timeout', {
+            host: config.host,
+            port: config.port,
+            seconds: Math.ceil(DB_CONNECTION_TIMEOUT_MS / 1000),
+        });
+    }
+    if (code === '28P01' || code === '28000' || code === 'ER_ACCESS_DENIED_ERROR' || errno === 1045) {
+        return translateCli('validators.dbConnection.authenticationFailed', {
+            user: config.user,
+            database: config.database,
+        });
+    }
+    if (code === '3D000' || code === 'ER_BAD_DB_ERROR' || errno === 1049) {
+        return translateCli('validators.dbConnection.databaseNotFound', {
+            database: config.database,
+        });
+    }
+    return translateCli('validators.dbConnection.connectionFailed', {
+        details: rawMessage || code || String(error),
+    });
+}
+async function checkPostgresFamilyConnection(config) {
+    const { default: pg } = await import('pg');
+    const client = new pg.Client({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectionTimeoutMillis: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        await client.connect();
+        await client.query('SELECT 1');
+    }
+    finally {
+        await Promise.resolve(client.end()).catch(() => undefined);
+    }
+}
+async function checkMysqlConnection(config) {
+    const { default: mysql } = await import('mysql2/promise');
+    const connection = await mysql.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        await connection.query('SELECT 1');
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
+async function checkMariaDbConnection(config) {
+    const { default: mariadb } = await import('mariadb');
+    const connection = await mariadb.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        await connection.query('SELECT 1');
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
+async function performExternalDbConnectionCheck(config) {
+    try {
+        switch (config.dialect) {
+            case 'postgres':
+            case 'kingbase': {
+                await checkPostgresFamilyConnection(config);
+                return undefined;
+            }
+            case 'mysql': {
+                await checkMysqlConnection(config);
+                return undefined;
+            }
+            case 'mariadb': {
+                await checkMariaDbConnection(config);
+                return undefined;
+            }
+        }
+    }
+    catch (error) {
+        return formatDbConnectionError(config, error);
+    }
+}
+export async function checkExternalDbConnection(config) {
+    const cacheKey = buildValidationCacheKey(config);
+    const cached = externalDbValidationCache.get(cacheKey);
+    if (cached) {
+        return await cached;
+    }
+    const pending = performExternalDbConnectionCheck(config);
+    externalDbValidationCache.set(cacheKey, pending);
+    return await pending;
+}
+export async function validateExternalDbConfig(values) {
+    const config = readExternalDbConnectionConfig(values);
+    if (!config) {
+        return undefined;
+    }
+    return await checkExternalDbConnection(config);
+}
+export function clearExternalDbValidationCache() {
+    externalDbValidationCache.clear();
+}

package/dist/lib/env-config.js

@@ -71,6 +71,13 @@ export function buildStoredEnvConfig(input) {
     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) {

package/dist/lib/generated-command.js

@@ -1,3 +1,11 @@
+/**
+ * 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.
@@ -12,7 +20,10 @@ import { applyPostProcessor } from './post-processors.js';
 import { registerPostProcessors } from '../post-processors/index.js';
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
-    if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
+    if (parameter.isFile) {
+        hints.push('file path');
+    }
+    else if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
         hints.push('JSON');
     }
     else if (parameter.isArray) {
@@ -67,10 +78,10 @@ export function createGeneratedFlags(operation) {
             // 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' ? false : parameter.required,
+            required: parameter.in === 'body' && !parameter.isFile ? false : parameter.required,
         });
     }
-    if (operation.hasBody) {
+    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',
@@ -82,6 +93,13 @@ export function createGeneratedFlags(operation) {
             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',
@@ -132,6 +150,8 @@ export class GeneratedApiCommand extends Command {
                 parameters: ctor.operation.parameters,
                 hasBody: ctor.operation.hasBody,
                 bodyRequired: ctor.operation.bodyRequired,
+                requestContentType: ctor.operation.requestContentType,
+                responseType: ctor.operation.responseType,
             },
         });
         if (!response.ok) {

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/prompt-validators.js

@@ -173,13 +173,13 @@ export async function validateAvailableTcpPort(value) {
         return formatError;
     }
     const port = parseTcpPort(raw);
-    const available = await canListenOnTcpPort(port);
-    if (!available) {
-        return translateCli('validators.tcpPort.alreadyInUse', { port });
-    }
     const dockerPorts = await getDockerPublishedTcpPorts();
     if (dockerPorts.has(port)) {
         return translateCli('validators.tcpPort.alreadyInUseByDocker', { port });
     }
+    const available = await canListenOnTcpPort(port);
+    if (!available) {
+        return translateCli('validators.tcpPort.alreadyInUse', { port });
+    }
     return undefined;
 }