@nocobase/cli 2.3.0-alpha.1 → 3.0.0-alpha.2

package/dist/lib/portal-deploy.js

@@ -0,0 +1,298 @@
+/**
+ * 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 { chmod, mkdtemp, readdir, rm, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as tar from 'tar';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, titleFromPortalSlug, validatePortalSlug, } from './portal-create.js';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { updatePortalEnvFiles } from './portal-env-files.js';
+import { mergePortalConfigIntoOptions, readPortalConfig } from './portal-config.js';
+import { run } from './run-npm.js';
+const portalDeployText = (key, values, fallback) => translateCli(`commands.portalDeploy.${key}`, values, { fallback });
+const DEPLOY_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:deploy',
+    requestContentType: 'multipart/form-data',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'file',
+            flagName: 'file',
+            in: 'body',
+            required: true,
+            isFile: true,
+        },
+        {
+            name: 'app',
+            flagName: 'app',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'portal',
+            flagName: 'portal',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'basePath',
+            flagName: 'basePath',
+            in: 'body',
+            required: true,
+        },
+    ],
+};
+const FIRST_OR_CREATE_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:firstOrCreate',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'filterKeys[]',
+            flagName: 'filterKeys',
+            in: 'query',
+            required: true,
+            isArray: true,
+        },
+    ],
+};
+const DEFAULT_PORTAL_UI_LAYOUT_UID = 'admin-layout-model';
+const PORTAL_PUBLIC_DIR_MODE = 0o755;
+const PORTAL_PUBLIC_FILE_MODE = 0o644;
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readDistPathFromUploadResponse(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return undefined;
+    }
+    const directDistPath = data.distPath;
+    if (typeof directDistPath === 'string' && directDistPath.trim()) {
+        return directDistPath;
+    }
+    return readDistPathFromUploadResponse(data.data);
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function chmodPortalDistTree(targetDir) {
+    await chmod(targetDir, PORTAL_PUBLIC_DIR_MODE);
+    const entries = await readdir(targetDir, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await chmodPortalDistTree(entryPath);
+            return;
+        }
+        if (entry.isFile()) {
+            await chmod(entryPath, PORTAL_PUBLIC_FILE_MODE);
+        }
+    }));
+}
+async function ensurePortalDistPublicReadable(params) {
+    await chmod(path.join(params.storagePath, 'portals'), PORTAL_PUBLIC_DIR_MODE);
+    await chmod(path.join(params.storagePath, 'portals', params.app), PORTAL_PUBLIC_DIR_MODE);
+    await chmod(params.portalDir, PORTAL_PUBLIC_DIR_MODE);
+    await chmodPortalDistTree(params.distDir);
+}
+async function assertFileExists(filePath, message) {
+    try {
+        const fileStat = await stat(filePath);
+        if (fileStat.isFile()) {
+            return;
+        }
+    }
+    catch {
+        // Throw the normalized message below.
+    }
+    throw new Error(message);
+}
+async function packPortalDist(distDir) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-dist-'));
+    const archivePath = path.join(tempDir, 'dist.tar.gz');
+    const entries = await readdir(distDir);
+    await tar.create({
+        cwd: distDir,
+        file: archivePath,
+        gzip: true,
+    }, entries);
+    return {
+        archivePath,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}
+async function uploadPortalDist(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            file: params.archivePath,
+            app: params.app,
+            portal: params.portal,
+            basePath: params.portalBase,
+        },
+        operation: DEPLOY_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalDeployText('errors.uploadFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal dist upload failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+    return {
+        distPath: readDistPathFromUploadResponse(response.data),
+    };
+}
+async function syncMultiPortalRecord(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const body = {
+        uid: params.portal,
+        title: titleFromPortalSlug(params.portal),
+        portalType: 'ai',
+        portalName: params.portal,
+        routePath: `/${params.portal}`,
+        authCheck: true,
+        enabled: true,
+        uiLayoutUid: DEFAULT_PORTAL_UI_LAYOUT_UID,
+        skipCreatePortalDirectory: true,
+    };
+    if (params.config) {
+        body.options = mergePortalConfigIntoOptions(params.config);
+    }
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            filterKeys: ['portalName'],
+            body: JSON.stringify(body),
+        },
+        operation: FIRST_OR_CREATE_PORTAL_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalDeployText('errors.recordSyncFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal record sync failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+}
+export async function deployPortalWorkspace(options) {
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const distDir = path.join(portalDir, 'dist');
+    if (!(await pathExists(portalDir))) {
+        throw new Error(portalDeployText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
+    }
+    await assertFileExists(path.join(portalDir, 'package.json'), portalDeployText('errors.packageJsonMissing', { portalDir }, `Portal is invalid: package.json is missing in ${portalDir}.`));
+    const portalConfig = await readPortalConfig(portalDir);
+    await updatePortalEnvFiles({
+        portalDir,
+        apiBaseUrl,
+        portalBase,
+    });
+    const runCommand = options.runCommand ?? run;
+    await runCommand('pnpm', ['install'], {
+        cwd: portalDir,
+        env: buildPortalCommandEnv(),
+        envMode: 'replace',
+        errorName: 'pnpm install',
+    });
+    await runCommand('pnpm', ['build'], {
+        cwd: portalDir,
+        env: buildPortalCommandEnv({
+            NOCOBASE_API_URL: apiBaseUrl,
+            NOCOBASE_PORTAL_BASE: portalBase,
+        }),
+        envMode: 'replace',
+        errorName: 'pnpm build',
+    });
+    await runCommand('pnpm', ['build:html'], {
+        cwd: portalDir,
+        env: buildPortalCommandEnv({
+            NOCOBASE_API_URL: apiBaseUrl,
+            NOCOBASE_PORTAL_BASE: portalBase,
+        }),
+        envMode: 'replace',
+        errorName: 'pnpm build:html',
+    });
+    await assertFileExists(path.join(distDir, 'index.html'), portalDeployText('errors.distMissing', { distDir }, `Portal build did not produce ${path.join(distDir, 'index.html')}.`));
+    await ensurePortalDistPublicReadable({
+        storagePath,
+        app,
+        portalDir,
+        distDir,
+    });
+    if (options.env.kind === 'local' || options.env.kind === 'docker') {
+        await syncMultiPortalRecord({
+            portal,
+            config: portalConfig,
+            envName: options.envName,
+            cliVersion: options.cliVersion,
+            apiRequest: options.apiRequest,
+        });
+        return {
+            app,
+            portal,
+            portalDir,
+            portalBase,
+            distDir,
+            mode: options.env.kind,
+            uploaded: false,
+            recordSynced: true,
+        };
+    }
+    if (options.env.kind !== 'http') {
+        throw new Error(portalDeployText('errors.unsupportedEnvKind', { kind: options.env.kind }, `Cannot deploy a portal for ${options.env.kind} envs in the first version.`));
+    }
+    const archive = await packPortalDist(distDir);
+    let uploadResult;
+    try {
+        uploadResult = await uploadPortalDist({
+            archivePath: archive.archivePath,
+            app,
+            portal,
+            portalBase,
+            envName: options.envName,
+            cliVersion: options.cliVersion,
+            apiRequest: options.apiRequest,
+        });
+    }
+    finally {
+        await archive.cleanup();
+    }
+    await syncMultiPortalRecord({
+        portal,
+        config: portalConfig,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    return {
+        app,
+        portal,
+        portalDir,
+        portalBase,
+        distDir,
+        serverDistPath: uploadResult.distPath,
+        mode: 'http',
+        uploaded: true,
+        recordSynced: true,
+    };
+}

package/dist/lib/portal-destroy.js

@@ -0,0 +1,100 @@
+/**
+ * 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 { rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+const portalDestroyText = (key, values, fallback) => translateCli(`commands.portalDestroy.${key}`, values, { fallback });
+const DESTROY_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:destroy',
+    parameters: [
+        {
+            name: 'filterByTk',
+            flagName: 'filterByTk',
+            in: 'query',
+            required: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertPortalDirIsInsideParent(parentDir, portalDir) {
+    const relative = path.relative(parentDir, portalDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(portalDestroyText('errors.outsideParent', { parentDir, portalDir }, `Refusing to delete a portal outside ${parentDir}: ${portalDir}`));
+    }
+}
+async function destroyMultiPortalRecord(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            filterByTk: params.portal,
+        },
+        operation: DESTROY_PORTAL_OPERATION,
+    });
+    if (response.ok) {
+        return true;
+    }
+    if (params.force && response.status === 404) {
+        return false;
+    }
+    throw new Error(portalDestroyText('errors.recordDestroyFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal record destroy failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+}
+export async function destroyPortalWorkspace(options) {
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
+    const portalParentDir = path.join(storagePath, 'portals', app);
+    const portalDir = path.join(portalParentDir, portal);
+    const mode = options.env.kind;
+    if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
+        throw new Error(portalDestroyText('errors.unsupportedEnvKind', { kind: mode }, `Cannot destroy a portal for ${mode} envs in the first version.`));
+    }
+    const destroyMode = mode;
+    assertPortalDirIsInsideParent(portalParentDir, portalDir);
+    const workspaceExists = await pathExists(portalDir);
+    if (!workspaceExists && !options.force) {
+        throw new Error(portalDestroyText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nPass --force to ignore missing local files.`));
+    }
+    const recordDeleted = await destroyMultiPortalRecord({
+        portal,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        force: options.force,
+        apiRequest: options.apiRequest,
+    });
+    if (workspaceExists) {
+        await rm(portalDir, { recursive: true, force: true });
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        portalBase,
+        mode: destroyMode,
+        recordDeleted,
+        workspaceDeleted: workspaceExists,
+    };
+}

package/dist/lib/portal-dev.js

@@ -0,0 +1,79 @@
+/**
+ * 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 { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { updatePortalEnvFiles } from './portal-env-files.js';
+import { run } from './run-npm.js';
+const portalDevText = (key, values, fallback) => translateCli(`commands.portalDev.${key}`, values, { fallback });
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function assertFileExists(filePath, message) {
+    try {
+        const fileStat = await stat(filePath);
+        if (fileStat.isFile()) {
+            return;
+        }
+    }
+    catch {
+        // Throw the normalized message below.
+    }
+    throw new Error(message);
+}
+export async function devPortalWorkspace(options) {
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    if (options.env.kind === 'ssh') {
+        throw new Error(portalDevText('errors.sshUnsupported', undefined, 'Cannot start a portal in dev mode for ssh envs in the first version.'));
+    }
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    if (!(await pathExists(portalDir))) {
+        throw new Error(portalDevText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
+    }
+    await assertFileExists(path.join(portalDir, 'package.json'), portalDevText('errors.packageJsonMissing', { portalDir }, `Portal is invalid: package.json is missing in ${portalDir}.`));
+    await updatePortalEnvFiles({
+        portalDir,
+        apiBaseUrl,
+        portalBase,
+    });
+    const result = {
+        app,
+        portal,
+        portalDir,
+        portalBase,
+        mode: options.env.kind,
+    };
+    options.onStart?.(result);
+    const runCommand = options.runCommand ?? run;
+    await runCommand('pnpm', ['dev'], {
+        cwd: portalDir,
+        env: buildPortalCommandEnv({
+            NOCOBASE_API_URL: apiBaseUrl,
+            NOCOBASE_PORTAL_BASE: portalBase,
+        }),
+        envMode: 'replace',
+        errorName: 'pnpm dev',
+    });
+    return result;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * 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 { resolvePortalEnvApiUrl } from './portal-create.js';
+function upsertEnvContent(content, values) {
+    const nextValues = { ...values };
+    const lines = content ? content.replace(/\r\n/g, '\n').split('\n') : [];
+    const result = [];
+    for (const line of lines) {
+        if (!line && result.length === lines.length - 1) {
+            continue;
+        }
+        const match = line.match(/^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+        const key = match?.[2];
+        if (key && Object.prototype.hasOwnProperty.call(nextValues, key)) {
+            result.push(`${key}=${nextValues[key]}`);
+            delete nextValues[key];
+            continue;
+        }
+        result.push(line);
+    }
+    for (const [key, value] of Object.entries(nextValues)) {
+        result.push(`${key}=${value}`);
+    }
+    return `${result.join('\n').replace(/\n*$/, '')}\n`;
+}
+export async function upsertPortalEnvFile(filePath, values) {
+    let content = '';
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch {
+        content = '';
+    }
+    await writeFile(filePath, upsertEnvContent(content, values), 'utf-8');
+}
+export async function updatePortalEnvFiles(params) {
+    await upsertPortalEnvFile(path.join(params.portalDir, '.env'), {
+        NOCOBASE_API_URL: resolvePortalEnvApiUrl(params.apiBaseUrl),
+        NOCOBASE_PORTAL_BASE: params.portalBase,
+    });
+    await upsertPortalEnvFile(path.join(params.portalDir, '.env.local'), {
+        NOCOBASE_API_URL: params.apiBaseUrl,
+        NOCOBASE_PORTAL_BASE: params.portalBase,
+    });
+}

package/dist/lib/portal-info.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.
+ */
+import { translateCli } from './cli-locale.js';
+import { toPortalOutputItem } from './portal-list.js';
+const portalInfoText = (key, values, fallback) => translateCli(`commands.portalInfo.${key}`, values, { fallback });
+function formatBoolean(value) {
+    if (value === null) {
+        return '';
+    }
+    return value ? 'yes' : 'no';
+}
+export function findPortalListItem(items, portal) {
+    return items.find((item) => item.portalName === portal || item.uid === portal);
+}
+export function formatPortalInfo(item) {
+    const outputItem = toPortalOutputItem(item);
+    return [
+        `${portalInfoText('fields.name', undefined, 'Name')}: ${outputItem.name}`,
+        `${portalInfoText('fields.url', undefined, 'URL')}: ${outputItem.url}`,
+        `${portalInfoText('fields.portalType', undefined, 'Portal type')}: ${outputItem.portalType}`,
+        `${portalInfoText('fields.path', undefined, 'Local path')}: ${outputItem.localPath}`,
+        `${portalInfoText('fields.enabled', undefined, 'Enabled')}: ${formatBoolean(outputItem.enabled)}`,
+        `${portalInfoText('fields.localSynced', undefined, 'Local synced')}: ${formatBoolean(outputItem.localSynced)}`,
+    ].join('\n');
+}