@nocobase/cli 2.1.0-beta.32 → 2.1.0-beta.34

package/dist/lib/bootstrap.js

@@ -6,12 +6,13 @@
  * 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 { confirm } from "./inquirer.js";
 import { getCurrentEnvName, getEnv, setEnvRuntime, updateEnvConnection } from './auth-store.js';
 import { resolveAccessToken } from './env-auth.js';
 import { fetchWithPreservedAuthRedirect } from './http-request.js';
 import { generateRuntime } from './runtime-generator.js';
 import { hasRuntimeSync, saveRuntime } from './runtime-store.js';
-import { confirmAction, printInfo, printVerbose, printWarningBlock, setVerboseMode, stopTask, updateTask } from './ui.js';
+import { printInfo, printVerbose, printWarningBlock, setVerboseMode, stopTask, updateTask } from './ui.js';
 const APP_RETRY_INTERVAL = 2000;
 const APP_RETRY_TIMEOUT = 120000;
 function readFlag(argv, name) {
@@ -186,7 +187,15 @@ async function waitForSwaggerSchema(baseUrl, token, role) {
     return await requestJson(swaggerUrl, { token, role });
 }
 async function confirmEnableApiDoc() {
-    return confirmAction('Enable the API documentation plugin now?', { defaultValue: false });
+    try {
+        return await confirm({
+            message: 'Enable the API documentation plugin now?',
+            default: false,
+        });
+    }
+    catch {
+        return false;
+    }
 }
 async function fetchSwaggerSchema(baseUrl, token, role, context = {}, options = {}) {
     let response = options.retryAppAvailability === false

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

@@ -100,7 +100,7 @@ async function checkPostgresFamilyConnection(config) {
         await Promise.resolve(client.end()).catch(() => undefined);
     }
 }
-async function checkMysqlConnection(config) {
+async function checkMysqlFamilyConnection(config) {
     const { default: mysql } = await import('mysql2/promise');
     const connection = await mysql.createConnection({
         host: config.host,
@@ -117,23 +117,6 @@ async function checkMysqlConnection(config) {
         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) {
@@ -142,12 +125,9 @@ async function performExternalDbConnectionCheck(config) {
                 await checkPostgresFamilyConnection(config);
                 return undefined;
             }
-            case 'mysql': {
-                await checkMysqlConnection(config);
-                return undefined;
-            }
+            case 'mysql':
             case 'mariadb': {
-                await checkMariaDbConnection(config);
+                await checkMysqlFamilyConnection(config);
                 return undefined;
             }
         }

package/dist/lib/docker-env-file.js

@@ -0,0 +1,52 @@
+/**
+ * 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 { access } from 'node:fs/promises';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+export function defaultDockerEnvFilePath(envName) {
+    return `${envName}/.env`;
+}
+export function resolveConfiguredDockerEnvFilePath(envName, config) {
+    return trimValue(config?.envFile) || defaultDockerEnvFilePath(envName);
+}
+export function hasExplicitDockerEnvFile(config) {
+    return Boolean(trimValue(config?.envFile));
+}
+export function resolveDockerEnvFilePath(envName, config) {
+    return resolveConfiguredEnvPath(resolveConfiguredDockerEnvFilePath(envName, config));
+}
+export async function dockerEnvFileExists(envName, config) {
+    const filePath = resolveDockerEnvFilePath(envName, config);
+    if (!filePath) {
+        return false;
+    }
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export async function resolveDockerEnvFileArg(envName, config) {
+    const filePath = resolveDockerEnvFilePath(envName, config);
+    if (!filePath) {
+        return undefined;
+    }
+    if (await dockerEnvFileExists(envName, config)) {
+        return filePath;
+    }
+    if (hasExplicitDockerEnvFile(config)) {
+        throw new Error(`The configured envFile for "${envName}" does not exist: ${resolveConfiguredDockerEnvFilePath(envName, config)}`);
+    }
+    return undefined;
+}

package/dist/lib/env-auth.js

@@ -14,7 +14,7 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { getCurrentEnvName, getEnv, setEnvOauthSession, } from './auth-store.js';
-import { printInfo, printVerbose, printWarning, printWarningBlock, updateTask } from './ui.js';
+import { printInfo, printVerbose, printWarning, printWarningBlock, stopTask, updateTask } from './ui.js';
 const ACCESS_TOKEN_REFRESH_WINDOW_MS = 60_000;
 const LOOPBACK_HOST = '127.0.0.1';
 const OAUTH_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
@@ -823,10 +823,11 @@ export async function authenticateEnvWithOauth(options) {
         const browser = await maybeOpenBrowser(authorizationUrl.toString());
         cleanupBrowserOpenTarget = browser.cleanup;
         if (!browser.opened) {
-            printWarningBlock('We could not open your browser automatically. Open this URL to continue signing in:');
+            printWarningBlock('We could not open your browser automatically. Open the URL below to continue signing in:');
         }
         else {
-            printInfo('Your browser should open shortly. Finish signing in there to continue.');
+            stopTask();
+            printInfo('Open this URL to sign in.');
         }
         printInfo(authorizationUrl.toString());
         const code = await new Promise((resolve, reject) => {

package/dist/lib/env-config.js

@@ -15,6 +15,7 @@ const STRING_ENV_CONFIG_KEYS = [
     'npmRegistry',
     'appRootPath',
     'storagePath',
+    'envFile',
     'appPort',
     'appKey',
     'timezone',

package/dist/lib/env-guard.js

@@ -6,9 +6,9 @@
  * 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 * as p from '@clack/prompts';
 import { stdin as input, stdout as output } from 'node:process';
 import { getCurrentEnvName } from './auth-store.js';
+import { confirm } from "./inquirer.js";
 function normalizeEnvName(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
@@ -50,12 +50,13 @@ export async function ensureCrossEnvConfirmed(options) {
     if (!interactiveTerminal) {
         options.command.error(formatCrossEnvRefusalMessage(currentEnv, requestedEnv));
     }
-    const answer = await p.confirm({
-        message: formatCrossEnvPromptMessage(currentEnv, requestedEnv),
-        initialValue: false,
-    });
-    if (p.isCancel(answer)) {
+    try {
+        return Boolean(await confirm({
+            message: formatCrossEnvPromptMessage(currentEnv, requestedEnv),
+            default: false,
+        }));
+    }
+    catch {
         return false;
     }
-    return Boolean(answer);
 }

package/dist/lib/generated-command.js

@@ -152,7 +152,6 @@ export class GeneratedApiCommand extends Command {
             yes: flags.yes,
         });
         if (!confirmed) {
-            this.log('Canceled.');
             return;
         }
         const response = await executeApiRequest({

package/dist/lib/inquirer-theme.js

@@ -0,0 +1,17 @@
+/**
+ * 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 buildPlainMessageTheme(extra) {
+    return {
+        ...extra,
+        style: {
+            ...extra?.style,
+            message: (text) => text,
+        },
+    };
+}

package/dist/lib/inquirer.js

@@ -0,0 +1,244 @@
+/**
+ * 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 { cursorTo } from '@inquirer/ansi';
+import pc from 'picocolors';
+import { createPrompt, isBackspaceKey, isEnterKey, makeTheme, useEffect, useKeypress, usePrefix, useState, } from '@inquirer/core';
+let confirmModulePromise;
+let selectModulePromise;
+function loadConfirmModule() {
+    confirmModulePromise ??= import('@inquirer/confirm');
+    return confirmModulePromise;
+}
+function loadSelectModule() {
+    selectModulePromise ??= import('@inquirer/select');
+    return selectModulePromise;
+}
+export function buildPlainMessageTheme(extra) {
+    return {
+        ...extra,
+        style: {
+            ...extra?.style,
+            message: (text) => text,
+        },
+    };
+}
+function buildSelectAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function buildConfirmAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+function stringWidth(value) {
+    let width = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null)
+            continue;
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f))
+            continue;
+        width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+function stripAnsi(value) {
+    return value.replace(new RegExp(String.raw `\\u001B\\[[0-9;]*m`, 'g'), '');
+}
+function lastLineWidth(value) {
+    const lines = stripAnsi(value).split('\n');
+    return stringWidth(lines[lines.length - 1] ?? '');
+}
+function resolveRequiredError(required) {
+    if (typeof required === 'string') {
+        return required;
+    }
+    return '此项为必填';
+}
+function hasUsableDefault(value) {
+    return value != null && value !== '';
+}
+function buildIdleHint(config) {
+    const placeholder = config.placeholder?.trim();
+    if (placeholder) {
+        return placeholder;
+    }
+    return '';
+}
+function buildInputLine(value) {
+    return `${pc.cyan('❯')} ${value}`;
+}
+function buildErrorLine(error) {
+    return pc.red(`✖ ${error}`);
+}
+export const input = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [defaultValue, setDefaultValue] = useState(config.default ?? '');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useEffect((rl) => {
+        if (config.default) {
+            rl.write(config.default);
+            setValue(config.default);
+        }
+    }, []);
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (isBackspaceKey(key) && !value) {
+            setDefaultValue('');
+            return;
+        }
+        if (isBackspaceKey(key)) {
+            setValue(rl.line.slice(0, -1));
+            setError(undefined);
+            return;
+        }
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value || defaultValue;
+        setStatus('loading');
+        if (!answer && config.required) {
+            rl.write(value);
+            setError(resolveRequiredError(config.required));
+            setStatus('idle');
+            return;
+        }
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const isTyping = value.length > 0;
+    const hasDefault = hasUsableDefault(defaultValue);
+    const idleHint = buildIdleHint(config);
+    const showIdleHint = !isTyping && status === 'idle' && idleHint !== '';
+    const showDefaultValue = !isTyping && status === 'idle' && hasDefault;
+    const displayValue = status === 'done'
+        ? theme.style.answer(value)
+        : isTyping
+            ? value
+            : showDefaultValue
+                ? defaultValue
+                : showIdleHint
+                    ? pc.dim(idleHint)
+                    : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    const promptWithCursorFix = showIdleHint
+        ? prompt + cursorTo(lastLineWidth(buildInputLine('')))
+        : showDefaultValue
+            ? prompt + cursorTo(lastLineWidth(buildInputLine(defaultValue)))
+            : prompt;
+    return [promptWithCursorFix, error ? buildErrorLine(error) : ''];
+});
+export async function confirm(options) {
+    const module = await loadConfirmModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildConfirmAnswer,
+            },
+            ...options.theme,
+        }),
+        transformer: options.transformer ?? ((value) => (value ? 'Yes' : 'No')),
+    });
+}
+export async function select(options) {
+    const module = await loadSelectModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildSelectAnswer,
+            },
+            ...options.theme,
+        }),
+    });
+}
+function resolveMaskChar(mask) {
+    if (typeof mask === 'string') {
+        return mask;
+    }
+    if (mask === false) {
+        return '';
+    }
+    return '•';
+}
+export const password = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value;
+        setStatus('loading');
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const maskChar = resolveMaskChar(config.mask);
+    const displayValue = status === 'done'
+        ? theme.style.answer(maskChar.repeat(value.length))
+        : maskChar
+            ? maskChar.repeat(value.length)
+            : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    return [prompt, error ? buildErrorLine(error) : ''];
+});

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