@nocobase/cli 2.1.0-rc.1 → 2.1.0-rc.2

package/dist/lib/env-command-config.js

@@ -0,0 +1,45 @@
+/**
+ * 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 const ENV_STRING_CONFIG_FLAG_MAP = {
+    source: 'source',
+    'download-version': 'downloadVersion',
+    'docker-registry': 'dockerRegistry',
+    'docker-platform': 'dockerPlatform',
+    'git-url': 'gitUrl',
+    'npm-registry': 'npmRegistry',
+    'app-path': 'appPath',
+    'app-root-path': 'appRootPath',
+    'storage-path': 'storagePath',
+    'app-public-path': 'appPublicPath',
+    'cdn-base-url': 'cdnBaseUrl',
+    'env-file': 'envFile',
+    'app-port': 'appPort',
+    'app-key': 'appKey',
+    timezone: 'timezone',
+    'db-dialect': 'dbDialect',
+    'builtin-db-image': 'builtinDbImage',
+    'db-host': 'dbHost',
+    'db-port': 'dbPort',
+    'db-database': 'dbDatabase',
+    'db-user': 'dbUser',
+    'db-password': 'dbPassword',
+    'db-schema': 'dbSchema',
+    'db-table-prefix': 'dbTablePrefix',
+    'root-username': 'rootUsername',
+    'root-email': 'rootEmail',
+    'root-password': 'rootPassword',
+    'root-nickname': 'rootNickname',
+};
+export const ENV_BOOLEAN_CONFIG_FLAG_MAP = {
+    'builtin-db': 'builtinDb',
+    'dev-dependencies': 'devDependencies',
+    build: 'build',
+    'build-dts': 'buildDts',
+    'db-underscored': 'dbUnderscored',
+};

package/dist/lib/env-config.js

@@ -0,0 +1,108 @@
+/**
+ * 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 { resolveAppPublicPath } from './app-public-path.js';
+const STRING_ENV_CONFIG_KEYS = [
+    'source',
+    'downloadVersion',
+    'dockerRegistry',
+    'dockerPlatform',
+    'gitUrl',
+    'npmRegistry',
+    'appPath',
+    'appRootPath',
+    'storagePath',
+    'appPublicPath',
+    'cdnBaseUrl',
+    'envFile',
+    'appPort',
+    'appKey',
+    'timezone',
+    'authUsername',
+    'dbDialect',
+    'builtinDbImage',
+    'dbHost',
+    'dbPort',
+    'dbDatabase',
+    'dbUser',
+    'dbPassword',
+    'dbSchema',
+    'dbTablePrefix',
+    'lang',
+    'rootUsername',
+    'rootEmail',
+    'rootPassword',
+    'rootNickname',
+];
+const BOOLEAN_ENV_CONFIG_KEYS = [
+    'builtinDb',
+    'devDependencies',
+    'build',
+    'buildDts',
+    'dbUnderscored',
+];
+function trimConfigValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveSetupState(value) {
+    return value === 'prepared' || value === 'installed' ? value : undefined;
+}
+function resolveEnvKind(input) {
+    const source = trimConfigValue(input.source);
+    const appPath = trimConfigValue(input.appPath);
+    const appRootPath = trimConfigValue(input.appRootPath);
+    if (source === 'docker') {
+        return 'docker';
+    }
+    if (source === 'npm' || source === 'git' || source === 'local' || appPath || 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] = key === 'appPublicPath' ? resolveAppPublicPath(value) : value;
+        }
+    }
+    const setupState = resolveSetupState(input.setupState);
+    if (setupState) {
+        envConfig.setupState = setupState;
+    }
+    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);
+    if (authType === 'basic' || authType === 'token' || authType === 'oauth') {
+        envConfig.authType = authType;
+    }
+    const accessToken = trimConfigValue(input.accessToken);
+    if ((authType === 'basic' || authType === 'token') && accessToken) {
+        envConfig.accessToken = accessToken;
+    }
+    return envConfig;
+}

package/dist/lib/env-guard.js

@@ -0,0 +1,61 @@
+/**
+ * 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 { stdin as input, stdout as output } from 'node:process';
+import { getCurrentEnvName } from './auth-store.js';
+import { translateCli } from './cli-locale.js';
+import { confirm } from "./inquirer.js";
+function normalizeEnvName(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+export function hasExplicitEnvSelection(argv) {
+    return argv.some((token, index) => (token === '--env'
+        || token === '-e'
+        || token.startsWith('--env=')
+        || (token.startsWith('-e') && token.length > 2 && index >= 0)));
+}
+function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+function formatCrossEnvPromptMessage(currentEnv, requestedEnv) {
+    return translateCli('commands.shared.crossEnv.prompt', {
+        currentEnv,
+        requestedEnv,
+    });
+}
+export function formatCrossEnvRefusalMessage(currentEnv, requestedEnv) {
+    return translateCli('commands.shared.crossEnv.refusal', {
+        currentEnv,
+        requestedEnv,
+    });
+}
+export async function ensureCrossEnvConfirmed(options) {
+    const requestedEnv = normalizeEnvName(options.requestedEnv);
+    if (!requestedEnv) {
+        return true;
+    }
+    const currentEnv = normalizeEnvName(await getCurrentEnvName());
+    const interactiveTerminal = isInteractiveTerminal();
+    const bypassInteractivePrompt = Boolean(options.yes);
+    if (!currentEnv || currentEnv === requestedEnv || bypassInteractivePrompt) {
+        return true;
+    }
+    if (!interactiveTerminal) {
+        options.command.error(formatCrossEnvRefusalMessage(currentEnv, requestedEnv));
+    }
+    try {
+        return Boolean(await confirm({
+            message: formatCrossEnvPromptMessage(currentEnv, requestedEnv),
+            default: false,
+        }));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/env-paths.js

@@ -0,0 +1,101 @@
+/**
+ * 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 { resolveConfiguredEnvPath } from './cli-home.js';
+function trimPathValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function normalizePathForComparison(value) {
+    return value.replace(/[\\/]+/g, '/').replace(/\/+$/, '');
+}
+export function areConfiguredPathsEquivalent(left, right) {
+    const leftValue = trimPathValue(left);
+    const rightValue = trimPathValue(right);
+    if (!leftValue || !rightValue) {
+        return leftValue === rightValue;
+    }
+    return normalizePathForComparison(leftValue) === normalizePathForComparison(rightValue);
+}
+function trimTrailingSeparators(value) {
+    return value.replace(/[\\/]+$/, '');
+}
+function hasTerminalPathSegment(value, segment) {
+    const normalized = normalizePathForComparison(value);
+    return normalized.endsWith(`/${segment}`) || normalized === segment;
+}
+function dirnameWithTrailingSeparator(value) {
+    const trimmed = trimTrailingSeparators(value);
+    if (!trimmed) {
+        return undefined;
+    }
+    const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    if (separatorIndex < 0) {
+        return undefined;
+    }
+    return trimmed.slice(0, separatorIndex + 1);
+}
+function inferAppPathFromLegacyConfigValue(value, leaf) {
+    if (!value || !hasTerminalPathSegment(value, leaf)) {
+        return undefined;
+    }
+    return dirnameWithTrailingSeparator(value);
+}
+export function deriveConfiguredSourcePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'source/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/source/`;
+}
+export function deriveConfiguredStoragePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'storage/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/storage/`;
+}
+export function inferConfiguredAppPathFromLegacyConfig(config) {
+    const explicitAppPath = trimPathValue(config.appPath);
+    if (explicitAppPath) {
+        return explicitAppPath;
+    }
+    const candidates = [
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.appRootPath), 'source'),
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.storagePath), 'storage'),
+    ].filter((value) => Boolean(value));
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const [first] = candidates;
+    if (!first) {
+        return undefined;
+    }
+    return candidates.every((candidate) => areConfiguredPathsEquivalent(candidate, first)) ? first : undefined;
+}
+export function resolveConfiguredAppPath(config, scope) {
+    const configuredAppPath = inferConfiguredAppPathFromLegacyConfig(config);
+    return configuredAppPath ? resolveConfiguredEnvPath(configuredAppPath, scope) : undefined;
+}
+export function resolveConfiguredSourcePath(config, scope) {
+    const legacySourcePath = trimPathValue(config.appRootPath);
+    if (legacySourcePath) {
+        return resolveConfiguredEnvPath(legacySourcePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'source') : undefined;
+}
+export function resolveConfiguredStoragePath(config, scope) {
+    const legacyStoragePath = trimPathValue(config.storagePath);
+    if (legacyStoragePath) {
+        return resolveConfiguredEnvPath(legacyStoragePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'storage') : undefined;
+}