@nocobase/cli 2.1.31 → 2.2.0-alpha.10

package/dist/lib/cli-config.js

@@ -34,6 +34,7 @@ export const SUPPORTED_CLI_CONFIG_KEYS = [
     'locale',
     'default-ui-host',
     'default-api-host',
+    'default-portal-template',
     'update.policy',
     'license.pkg-url',
     'docker.network',
@@ -120,7 +121,10 @@ function pruneSettings(config) {
         delete config.settings.locale;
     }
     const init = config.settings?.init;
-    if (init && !trimValue(init.defaultUiHost) && !trimValue(init.defaultApiHost)) {
+    if (init &&
+        !trimValue(init.defaultUiHost) &&
+        !trimValue(init.defaultApiHost) &&
+        !trimValue(init.defaultPortalTemplate)) {
         delete config.settings?.init;
     }
     const update = config.settings?.update;
@@ -181,6 +185,8 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.init?.defaultUiHost);
         case 'default-api-host':
             return trimValue(config.settings?.init?.defaultApiHost);
+        case 'default-portal-template':
+            return trimValue(config.settings?.init?.defaultPortalTemplate);
         case 'update.policy':
             return normalizeCliUpdatePolicy(config.settings?.update?.policy);
         case 'license.pkg-url':
@@ -233,6 +239,8 @@ export function getEffectiveCliConfigValue(config, key) {
             return '127.0.0.1';
         case 'default-api-host':
             return '127.0.0.1';
+        case 'default-portal-template':
+            return explicit ?? '';
         case 'update.policy':
             return explicit ?? DEFAULT_UPDATE_POLICY;
         case 'license.pkg-url':
@@ -377,6 +385,12 @@ export async function setCliConfigValue(key, value, options = {}) {
                 defaultApiHost: normalized,
             };
             break;
+        case 'default-portal-template':
+            config.settings.init = {
+                ...(config.settings.init ?? {}),
+                defaultPortalTemplate: normalized,
+            };
+            break;
         case 'update.policy':
             config.settings.update = {
                 ...(config.settings.update ?? {}),
@@ -512,6 +526,11 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.init.defaultApiHost;
             }
             break;
+        case 'default-portal-template':
+            if (config.settings.init) {
+                delete config.settings.init.defaultPortalTemplate;
+            }
+            break;
         case 'update.policy':
             if (config.settings.update) {
                 delete config.settings.update.policy;

package/dist/lib/env-config.js

@@ -36,6 +36,9 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbSchema',
     'dbTablePrefix',
     'lang',
+    'portalType',
+    'portalName',
+    'portalTemplate',
     'rootUsername',
     'rootEmail',
     'rootPassword',

package/dist/lib/env-proxy.js

@@ -23,6 +23,7 @@ const DEFAULT_MODERN_CLIENT_PREFIX = 'v';
 const DEFAULT_API_CLIENT_STORAGE_PREFIX = 'NOCOBASE_';
 const DEFAULT_API_CLIENT_STORAGE_TYPE = 'localStorage';
 const DEFAULT_ESM_CDN_BASE_URL = 'https://esm.sh';
+const PORTAL_CLIENT_PREFIX = 'x';
 const LOCAL_APP_PACKAGE_JSON_PATH = 'node_modules/@nocobase/app/package.json';
 const MANAGED_PROXY_BLOCK_BEGIN = '# BEGIN NocoBase proxy';
 const MANAGED_PROXY_BLOCK_END = '# END NocoBase proxy';
@@ -489,6 +490,7 @@ function buildNginxManagedConfigBlock(context) {
     const v2PublicPathNoTrailingSlash = trimTrailingSlash(context.v2PublicPath);
     const apiBasePathNoTrailingSlash = trimTrailingSlash(context.apiBasePath);
     const appPublicPathNoTrailingSlash = trimTrailingSlash(context.appPublicPath);
+    const fileAccessPath = `${context.appPublicPath}files/`;
     const isRootMounted = context.appPublicPath === '/';
     const appPublicPathRedirectBlock = isRootMounted
         ? ''
@@ -526,6 +528,22 @@ function buildNginxManagedConfigBlock(context) {
         `        include ${context.snippetsDir}/proxy-location.conf;`,
         '    }',
         '',
+        `    location ^~ ${fileAccessPath} {`,
+        `        proxy_pass ${context.backendUrl};`,
+        `        include ${context.snippetsDir}/proxy-location.conf;`,
+        '    }',
+        ...(!isRootMounted
+            ? [
+                '',
+                '    location ^~ /files/ {',
+                `        proxy_pass ${context.backendUrl};`,
+                `        include ${context.snippetsDir}/proxy-location.conf;`,
+                '    }',
+            ]
+            : []),
+        '',
+        buildNginxPortalLocationBlock(context),
+        '',
         `    location = ${apiBasePathNoTrailingSlash} {`,
         `        return 308 ${context.apiBasePath}$is_args$args;`,
         '    }',
@@ -551,7 +569,7 @@ function buildNginxManagedConfigBlock(context) {
         `        include ${context.snippetsDir}/spa-location.conf;`,
         '    }',
         '',
-        `    location ^~ ${context.appPublicPath} {`,
+        `    location ${context.appPublicPath} {`,
         `        alias ${context.publicDir}/;`,
         `        try_files $uri /index-v1.html =404;`,
         `        include ${context.snippetsDir}/spa-location.conf;`,
@@ -560,6 +578,65 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
+function buildNginxPortalRootPublicPath(appPublicPath) {
+    return appPublicPath === DEFAULT_APP_PUBLIC_PATH
+        ? `/${PORTAL_CLIENT_PREFIX}/`
+        : `${trimTrailingSlash(appPublicPath)}/${PORTAL_CLIENT_PREFIX}/`;
+}
+function buildNginxPortalLocationBlock(context) {
+    const portalBasePath = trimTrailingSlash(buildNginxPortalRootPublicPath(context.appPublicPath));
+    const portalBasePathPattern = escapeRegExp(portalBasePath);
+    return [
+        `    location ^~ ${portalBasePath}/apps/ {`,
+        '        absolute_redirect off;',
+        '',
+        `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)$) {`,
+        `            return 308 ${portalBasePath}/apps/$subapp/$portal/$is_args$args;`,
+        '        }',
+        '',
+        `        if ($uri !~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
+        '            return 404;',
+        '        }',
+        '',
+        `        root ${context.storageDir};`,
+        '',
+        '        if ($portal_path = "") {',
+        '            rewrite ^ /portals/$subapp/$portal/dist/index.html break;',
+        '        }',
+        '',
+        '        try_files',
+        '            /portals/$subapp/$portal/dist/$portal_path',
+        '            /portals/$subapp/$portal/dist/$portal_path/',
+        '            /portals/$subapp/$portal/dist/index.html',
+        '            =404;',
+        '    }',
+        '',
+        `    location ^~ ${portalBasePath}/ {`,
+        '        absolute_redirect off;',
+        '',
+        `        if ($uri ~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)$) {`,
+        `            return 308 ${portalBasePath}/$portal/$is_args$args;`,
+        '        }',
+        '',
+        `        if ($uri !~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
+        '            return 404;',
+        '        }',
+        '',
+        `        root ${context.storageDir};`,
+        '',
+        '        if ($portal_path = "") {',
+        '            rewrite ^ /portals/main/$portal/dist/index.html break;',
+        '        }',
+        '',
+        '        try_files',
+        '            /portals/main/$portal/dist/$portal_path',
+        '            /portals/main/$portal/dist/$portal_path/',
+        '            /portals/main/$portal/dist/index.html',
+        '            =404;',
+        '    }',
+        '',
+    ].join('\n');
+}
 function buildNginxRuntimeConfig(context, variant) {
     return {
         __webpack_public_path__: context.cdnBaseUrl,
@@ -593,6 +670,7 @@ async function buildEnvProxyNginxRenderContext(source, options) {
     const mappedPublicDir = await mapProxyPathFromCliRoot(publicDir, options);
     const mappedSnippetsDir = await mapProxyPathFromCliRoot(snippetsDir, options);
     const mappedDistRootDir = await mapProxyPathFromCliRoot(distRootDir, options);
+    const mappedStorageDir = await mapProxyPathFromCliRoot(source.storagePath, options);
     const mappedUploadsDir = await mapProxyPathFromCliRoot(uploadsDir, options);
     const v2PublicPath = `${source.settings.appPublicPath.replace(/\/$/, '')}/${source.settings.modernClientPrefix}/`;
     return {
@@ -617,6 +695,7 @@ async function buildEnvProxyNginxRenderContext(source, options) {
         modernClientPrefix: source.settings.modernClientPrefix,
         proxyHost,
         snippetsDir: mappedSnippetsDir,
+        storageDir: mappedStorageDir,
         uploadsDir: mappedUploadsDir,
         v2PublicPath,
         wsPath: source.settings.wsPath,
@@ -1098,6 +1177,7 @@ function buildCaddyContextCommentLines(siteAddress, context, publicDir) {
 }
 function renderCaddyAppTemplate(siteAddress, context, publicDir) {
     const uploadsPath = `${context.appPublicPath}storage/uploads/`;
+    const fileAccessPathMatcher = toCaddyPathMatcher(`${context.appPublicPath}files/`);
     const distPathMatcher = toCaddyPathMatcher(context.distPath);
     const uploadsPathMatcher = toCaddyPathMatcher(uploadsPath);
     const apiPathMatcher = toCaddyPathMatcher(context.apiBasePath);
@@ -1168,7 +1248,19 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
         '    }',
         '',
-        '    # Keep API and WS routes above the SPA fallbacks.',
+        '    # Keep file, API and WS routes above the SPA fallbacks.',
+        `    handle ${fileAccessPathMatcher} {`,
+        `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+        '    }',
+        ...(context.appPublicPath === DEFAULT_APP_PUBLIC_PATH
+            ? []
+            : [
+                '',
+                '    handle /files/* {',
+                `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+                '    }',
+            ]),
+        '',
         `    handle ${apiPathMatcher} {`,
         `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
         '    }',

package/dist/lib/managed-init-env.js

@@ -15,7 +15,7 @@ export function resolveManagedSetupState(value) {
 export function isPreparedSetupState(value) {
     return resolveManagedSetupState(value) === 'prepared';
 }
-export function buildInitAppEnvVarsFromConfig(config) {
+export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     const out = {};
     const put = (key, value) => {
         const text = trimValue(value);
@@ -28,5 +28,10 @@ export function buildInitAppEnvVarsFromConfig(config) {
     put('INIT_ROOT_EMAIL', config?.rootEmail);
     put('INIT_ROOT_PASSWORD', config?.rootPassword);
     put('INIT_ROOT_NICKNAME', config?.rootNickname);
+    if (options.includePortal !== false) {
+        put('INIT_PORTAL_TYPE', config?.portalType);
+        put('INIT_PORTAL_NAME', config?.portalName);
+        put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
+    }
     return out;
 }

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

@@ -0,0 +1,31 @@
+/**
+ * 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 PORTAL_COMMAND_BASE_ENV_KEYS = [
+    'PATH',
+    'Path',
+    'PATHEXT',
+    'SystemRoot',
+    'WINDIR',
+    'ComSpec',
+    'HOME',
+    'USERPROFILE',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+];
+export function buildPortalCommandEnv(env = {}) {
+    const out = {};
+    for (const key of PORTAL_COMMAND_BASE_ENV_KEYS) {
+        const value = process.env[key];
+        if (value) {
+            out[key] = value;
+        }
+    }
+    return { ...out, ...env };
+}

package/dist/lib/portal-config.js

@@ -0,0 +1,133 @@
+/**
+ * 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 { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+export const DEFAULT_PORTAL_GIT_PATH = '.';
+const portalConfigText = (key, values, fallback) => translateCli(`commands.portalConfig.${key}`, values, { fallback });
+const UPDATE_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:update',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'filterByTk',
+            flagName: 'filterByTk',
+            in: 'query',
+            required: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function validatePortalSourceStorage(value) {
+    const sourceStorage = trimValue(value) || 'nocobase';
+    if (sourceStorage === 'nocobase' || sourceStorage === 'git') {
+        return sourceStorage;
+    }
+    throw new Error(portalConfigText('errors.invalidSourceStorage', { value: sourceStorage }, `Invalid source storage "${sourceStorage}". Use "nocobase" or "git".`));
+}
+function isFullGitRemoteUrl(value) {
+    return /^(?:https?:\/\/|ssh:\/\/|file:\/\/|git@[^:]+:).+/.test(value);
+}
+function validateGitPath(value) {
+    const gitPath = trimValue(value);
+    if (!gitPath || path.isAbsolute(gitPath) || gitPath.split(/[\\/]+/).includes('..')) {
+        throw new Error(portalConfigText('errors.invalidGitPath', { value }, '--git-path must be a relative path inside the Git repository.'));
+    }
+    return gitPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+}
+export function buildPortalConfig(options) {
+    const sourceStorage = validatePortalSourceStorage(options.sourceStorage ?? options.existingConfig?.sourceStorage);
+    const hasGitOption = Boolean(trimValue(options.gitRepo) || trimValue(options.gitBranch) || trimValue(options.gitPath));
+    if (sourceStorage === 'nocobase') {
+        if (hasGitOption) {
+            throw new Error(portalConfigText('errors.gitOptionsForNocobaseStorage', undefined, '--git-repo, --git-branch, and --git-path can only be used with --source-storage git.'));
+        }
+        return { sourceStorage };
+    }
+    const repo = trimValue(options.gitRepo) || options.existingConfig?.git?.repo || '';
+    if (!repo) {
+        throw new Error(portalConfigText('errors.gitRepoRequired', undefined, '--git-repo is required when --source-storage is git.'));
+    }
+    if (!isFullGitRemoteUrl(repo)) {
+        throw new Error(portalConfigText('errors.gitRepoInvalid', undefined, '--git-repo must be a full Git remote URL.'));
+    }
+    return {
+        sourceStorage,
+        git: {
+            repo,
+            branch: trimValue(options.gitBranch) || options.existingConfig?.git?.branch || 'main',
+            path: validateGitPath(trimValue(options.gitPath) || options.existingConfig?.git?.path || DEFAULT_PORTAL_GIT_PATH),
+        },
+    };
+}
+export function buildPortalConfigFromOptions(options, portal) {
+    const sourceOptions = readObject(options);
+    const git = readObject(sourceOptions.git);
+    return buildPortalConfig({
+        portal,
+        sourceStorage: trimValue(sourceOptions.sourceStorage) || 'nocobase',
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export function mergePortalConfigIntoOptions(config, currentOptions) {
+    const nextOptions = {
+        ...(currentOptions ?? {}),
+        sourceStorage: config.sourceStorage,
+    };
+    if (config.sourceStorage === 'git') {
+        nextOptions.git = config.git;
+    }
+    else {
+        delete nextOptions.git;
+    }
+    return nextOptions;
+}
+export async function readPortalConfig(portalDir) {
+    const configPath = path.join(portalDir, 'portal.config.json');
+    const data = JSON.parse(await readFile(configPath, 'utf-8'));
+    const config = readObject(data);
+    const git = readObject(config.git);
+    return buildPortalConfig({
+        portal: path.basename(portalDir),
+        sourceStorage: trimValue(config.sourceStorage),
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export async function writePortalConfig(portalDir, config) {
+    await writeFile(path.join(portalDir, 'portal.config.json'), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+}
+export async function syncPortalConfigToRemote(options) {
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: options.cliVersion ?? '',
+        envName: options.envName,
+        flags: {
+            filterByTk: options.portal,
+            body: JSON.stringify({
+                options: mergePortalConfigIntoOptions(options.config, options.currentOptions),
+            }),
+        },
+        operation: UPDATE_PORTAL_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalConfigText('errors.updateFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal config update failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+}

package/dist/lib/portal-configure.js

@@ -0,0 +1,117 @@
+/**
+ * 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 { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { translateCli } from './cli-locale.js';
+import { resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalConfig, buildPortalConfigFromOptions, readPortalConfig, syncPortalConfigToRemote, writePortalConfig, } from './portal-config.js';
+import { findPortalListItem } from './portal-info.js';
+import { listPortalWorkspaces } from './portal-list.js';
+const portalConfigureText = (key, values, fallback) => translateCli(`commands.portalConfigure.${key}`, values, { fallback });
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasConfigurationChange(options) {
+    return Boolean(options.sourceStorage !== undefined ||
+        trimValue(options.gitRepo) ||
+        trimValue(options.gitBranch) ||
+        trimValue(options.gitPath));
+}
+async function readExistingConfig(portalDir) {
+    try {
+        return await readPortalConfig(portalDir);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function buildConfigFromRemoteOptions(params) {
+    if (params.options && Object.keys(params.options).length > 0) {
+        return buildPortalConfigFromOptions(params.options, params.portal);
+    }
+    if (!params.sourceStorage && !params.gitRepo && !params.gitBranch && !params.gitPath) {
+        return undefined;
+    }
+    return buildPortalConfig({
+        portal: params.portal,
+        sourceStorage: params.sourceStorage,
+        gitRepo: params.gitRepo,
+        gitBranch: params.gitBranch,
+        gitPath: params.gitPath,
+    });
+}
+export async function configurePortalWorkspace(options) {
+    if (!hasConfigurationChange(options)) {
+        throw new Error(portalConfigureText('errors.noChanges', undefined, 'No portal configuration changes were provided. Pass --source-storage or a --git-* flag.'));
+    }
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    if (!(await pathExists(portalDir))) {
+        throw new Error(portalConfigureText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` or \`nb portal pull ${portal}\` first.`));
+    }
+    const list = await listPortalWorkspaces({
+        env: options.env,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const remoteItem = findPortalListItem(list.items, portal);
+    const existingConfig = (await readExistingConfig(portalDir)) ??
+        buildConfigFromRemoteOptions({
+            portal,
+            options: remoteItem?.options,
+            sourceStorage: remoteItem?.sourceStorage,
+            gitRepo: remoteItem?.gitRepo,
+            gitBranch: remoteItem?.gitBranch,
+            gitPath: remoteItem?.gitPath,
+        });
+    const config = buildPortalConfig({
+        portal,
+        sourceStorage: options.sourceStorage,
+        gitRepo: options.gitRepo,
+        gitBranch: options.gitBranch,
+        gitPath: options.gitPath,
+        existingConfig,
+    });
+    await mkdir(portalDir, { recursive: true });
+    await writePortalConfig(portalDir, config);
+    if (remoteItem) {
+        await syncPortalConfigToRemote({
+            portal,
+            config,
+            currentOptions: remoteItem.options,
+            envName: options.envName,
+            cliVersion: options.cliVersion,
+            apiRequest: options.apiRequest,
+        });
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        config,
+        remoteSynced: Boolean(remoteItem),
+    };
+}