@nocobase/cli 2.2.0-beta.16 → 2.2.0-beta.18

package/dist/commands/api/resource/create.js

@@ -1,10 +1,19 @@
+/**
+ * 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 { Command } from '@oclif/core';
 import { buildCreateArgs, createFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceCreate extends Command {
-    static summary = 'Create a record in a resource';
-    static description = 'Create a record in a generic resource. Pass record content through --values as a JSON object.';
+    static summary = 'Create one or more records in a resource';
+    static description = 'Create records in a generic resource. Pass record content through --values as a JSON object, or as a JSON array of objects to create multiple records in a single request.';
     static examples = [
         `<%= config.bin %> <%= command.id %> --resource users --values '{"nickname":"Ada"}'`,
+        `<%= config.bin %> <%= command.id %> --resource users --values '[{"nickname":"Ada"},{"nickname":"Grace"}]'`,
         `<%= config.bin %> <%= command.id %> --resource posts.comments --source-id 1 --values '{"content":"Hello"}'`,
     ];
     static flags = createFlags;

package/dist/lib/browser.js

@@ -0,0 +1,29 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+export async function openUrlInDefaultBrowser(url) {
+    const [command, args, options] = process.platform === 'darwin'
+        ? ['open', [url], { detached: true, stdio: 'ignore' }]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore', windowsHide: true }]
+            : ['xdg-open', [url], { detached: true, stdio: 'ignore' }];
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(command, args, options);
+            child.once('error', () => resolve(false));
+            child.once('spawn', () => {
+                child.unref();
+                resolve(true);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/lib/generated-command.js

@@ -15,12 +15,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from './auth-store.js';
 import { executeApiRequest } from './api-client.js';
+import { resolveAppUrlFromApiBaseUrl } from '../commands/env/shared.js';
 import { findApiCommandCompatViolation, formatApiCommandCompatViolation } from './api-command-compat.js';
+import { openUrlInDefaultBrowser } from './browser.js';
 import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { applyPostProcessor } from './post-processors.js';
 import { readInstalledManagedSkillsVersion } from './skills-manager.js';
 import { registerPostProcessors } from '../post-processors/index.js';
+const UI_OPERATION_QUERY_KEY = '_operation_';
+const UI_OPERATION_VERSION = 1;
+function encodeUIOperation(operation) {
+    return Buffer.from(JSON.stringify(operation), 'utf8').toString('base64url');
+}
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
     if (parameter.isFile) {
@@ -104,6 +112,13 @@ export function createGeneratedFlags(operation) {
             required: true,
         });
     }
+    if (operation.ui) {
+        flags.ui = Flags.boolean({
+            description: 'Open the corresponding page in the NocoBase UI',
+            default: false,
+            helpGroup: 'Global',
+        });
+    }
     flags['api-base-url'] = Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
         helpGroup: 'Global',
@@ -142,6 +157,68 @@ export function createGeneratedFlags(operation) {
     });
     return flags;
 }
+function hasFlagValue(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, operation) {
+    const rawBodyFlags = ['body', 'body-file'].filter((flagName) => hasFlagValue(flags[flagName])).map((flagName) => `--${flagName}`);
+    const uiParameterNames = new Set(operation.ui?.parameters ?? []);
+    const bodyFieldFlags = operation.parameters
+        .filter((parameter) => parameter.in === 'body' && !uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => `--${parameter.flagName}`);
+    return [...rawBodyFlags, ...bodyFieldFlags];
+}
+async function resolveUiAppUrl(flags) {
+    const apiBaseUrl = typeof flags['api-base-url'] === 'string' ? flags['api-base-url'] : undefined;
+    if (apiBaseUrl) {
+        return resolveAppUrlFromApiBaseUrl(apiBaseUrl);
+    }
+    const requestedEnv = typeof flags.env === 'string' ? flags.env : undefined;
+    const envName = requestedEnv ?? (await getCurrentEnvName());
+    const env = await getEnv(envName);
+    if (!env?.baseUrl) {
+        throw new Error(env
+            ? `Env "${envName}" is missing a base URL. Use --api-base-url or update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\` first.`
+            : `Env "${envName}" is not configured. Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`);
+    }
+    return resolveAppUrlFromApiBaseUrl(env.baseUrl);
+}
+function buildUiOperationUrl(appUrl, path, encodedOperation) {
+    const url = new URL(appUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/${path}`;
+    url.searchParams.set(UI_OPERATION_QUERY_KEY, encodedOperation);
+    return url.toString();
+}
+async function openUiOperation(command, operation, flags) {
+    const { operationId, ui } = operation;
+    if (!ui || !operationId) {
+        command.error('This API operation does not support --ui.');
+    }
+    const bodyFlags = listProvidedBodyFlags(flags, operation);
+    if (bodyFlags.length) {
+        command.error('--ui cannot be combined with API request body flags. Remove --ui to submit through the API, or remove the body flags to open the UI.');
+    }
+    const uiParameterNames = new Set(ui.parameters ?? []);
+    const params = Object.fromEntries(operation.parameters
+        .filter((parameter) => uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => [parameter.name, flags[parameter.flagName]]));
+    const uiOperation = {
+        v: UI_OPERATION_VERSION,
+        operationId,
+        ...(Object.keys(params).length ? { params } : {}),
+    };
+    const encodedOperation = encodeUIOperation(uiOperation);
+    const appUrl = await resolveUiAppUrl(flags);
+    const targetUrl = buildUiOperationUrl(appUrl, ui.path, encodedOperation);
+    const opened = await openUrlInDefaultBrowser(targetUrl);
+    command.log(targetUrl);
+    if (!opened) {
+        command.warn('Could not open the default browser. Copy the URL above to continue.');
+    }
+}
 export class GeneratedApiCommand extends Command {
     static operation;
     static runtimeVersion;
@@ -169,6 +246,10 @@ export class GeneratedApiCommand extends Command {
         if (compatViolation) {
             this.error(formatApiCommandCompatViolation(compatViolation));
         }
+        if (flags.ui) {
+            await openUiOperation(this, ctor.operation, flags);
+            return;
+        }
         const response = await executeApiRequest({
             cliVersion,
             skillsVersion,

package/dist/lib/plugin-import.js

@@ -207,6 +207,29 @@ async function openPluginSource(source, npmRegistry, runFn = run) {
     }
     return await packNpmPluginSource(source, npmRegistry, runFn);
 }
+/**
+ * Locate the directory holding the plugin's `package.json` inside a freshly extracted archive.
+ *
+ * Archives reach us in two shapes: npm-style tarballs (`npm pack`, registry downloads) wrap everything in a single
+ * top-level directory — conventionally `package/` — while NocoBase's own `yarn build <plugin> --tar` writes entries at
+ * the archive root. Extracting with a fixed `strip: 1` would silently discard the root-level files of the latter, so we
+ * extract verbatim and pick the package root here instead. When neither shape matches, return the extract root and let
+ * `readPluginMetadata` report the missing `package.json`.
+ */
+async function resolveArchivePackageRoot(extractRoot) {
+    if (await pathExists(path.join(extractRoot, 'package.json'))) {
+        return extractRoot;
+    }
+    const entries = await fsp.readdir(extractRoot, { withFileTypes: true });
+    const directories = entries.filter((entry) => entry.isDirectory());
+    if (directories.length === 1) {
+        const nestedRoot = path.join(extractRoot, directories[0].name);
+        if (await pathExists(path.join(nestedRoot, 'package.json'))) {
+            return nestedRoot;
+        }
+    }
+    return extractRoot;
+}
 async function readPluginMetadata(extractRoot, sourceLabel) {
     const packageJsonPath = path.join(extractRoot, 'package.json');
     let content;
@@ -241,22 +264,21 @@ export async function importPluginSource(source, options = {}) {
     await fsp.mkdir(storagePluginsPath, { recursive: true });
     const archive = await openPluginSource(normalizedSource, options.npmRegistry, options.runFn);
     const stageDir = await fsp.mkdtemp(path.join(storagePluginsPath, '.nb-plugin-import-'));
-    let stageMoved = false;
     try {
         try {
-            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir, strip: 1 }));
+            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir }));
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to extract plugin archive from ${archive.source}: ${message}`);
         }
-        const { packageName, packageVersion } = await readPluginMetadata(stageDir, archive.source);
+        const packageRoot = await resolveArchivePackageRoot(stageDir);
+        const { packageName, packageVersion } = await readPluginMetadata(packageRoot, archive.source);
         const outputDir = resolvePluginOutputDir(storagePluginsPath, packageName);
         const action = (await pathExists(outputDir)) ? 'updated' : 'installed';
         await fsp.mkdir(path.dirname(outputDir), { recursive: true });
         await fsp.rm(outputDir, { recursive: true, force: true });
-        await fsp.rename(stageDir, outputDir);
-        stageMoved = true;
+        await fsp.rename(packageRoot, outputDir);
         return {
             action,
             packageName,
@@ -268,9 +290,9 @@ export async function importPluginSource(source, options = {}) {
         };
     }
     finally {
-        if (!stageMoved) {
-            await fsp.rm(stageDir, { recursive: true, force: true });
-        }
+        // Always removes the staging directory: it is either untouched (failure), or an empty wrapper left behind after the
+        // nested package root was renamed out of it.
+        await fsp.rm(stageDir, { recursive: true, force: true });
         await archive.cleanup();
     }
 }

package/dist/lib/resource-command.js

@@ -41,6 +41,22 @@ function parseObjectFlag(value, flagName) {
     }
     return parsed;
 }
+function parseValuesFlag(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = parseJson(value, flagName);
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`--${flagName} must be a JSON object, or a JSON array of objects to create multiple records`);
+    }
+    if (Array.isArray(parsed)) {
+        const invalidIndex = parsed.findIndex((item) => !item || Array.isArray(item) || typeof item !== 'object');
+        if (invalidIndex !== -1) {
+            throw new Error(`--${flagName} array items must all be JSON objects, but item ${invalidIndex} is not`);
+        }
+    }
+    return parsed;
+}
 function parseJsonArrayFlag(value, flagName) {
     if (value === undefined) {
         return undefined;
@@ -187,7 +203,7 @@ export const createFlags = {
     ...resourceBaseFlags,
     ...resourceAssociationFlags,
     values: Flags.string({
-        description: 'Record values used by create as a JSON object.',
+        description: 'Record values used by create as a JSON object, or a JSON array of objects to create multiple records in one request.',
         required: true,
     }),
     whitelist: Flags.string({
@@ -298,7 +314,7 @@ export function buildGetArgs(flags) {
 export function buildCreateArgs(flags) {
     return {
         ...pickSharedArgs(flags),
-        values: parseObjectFlag(flags.values, 'values'),
+        values: parseValuesFlag(flags.values, 'values'),
         whitelist: parseStringArrayFlags(flags.whitelist, 'whitelist'),
         blacklist: parseStringArrayFlags(flags.blacklist, 'blacklist'),
     };

package/dist/lib/resource-request.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.
+ */
 import { executeRawApiRequest } from './api-client.js';
 function buildActionUrl(resource, action, sourceId) {
     if (typeof sourceId === 'undefined' || sourceId === null || !resource.includes('.')) {

package/dist/lib/runtime-generator.js

@@ -18,7 +18,31 @@ import { createHash } from 'node:crypto';
 import { loadBuildConfig } from './build-config.js';
 import { toKebabCase, toLogicalActionName, toLogicalResourceName, toResourceSegments } from './naming.js';
 import { collectOperations } from './openapi.js';
-const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file', 'yes']);
+const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file', 'ui', 'yes']);
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string' && Boolean(item));
+function getGeneratedUIOperation(operation, parameters) {
+    if (!operation.operationId) {
+        return undefined;
+    }
+    const extension = operation['x-nocobase-cli-ui'];
+    if (!isRecord(extension) || typeof extension.path !== 'string') {
+        return undefined;
+    }
+    const path = extension.path.trim();
+    if (!path || path.startsWith('/') || /[?#]/.test(path) || /^[a-z][a-z\d+.-]*:/i.test(path)) {
+        return undefined;
+    }
+    const mappedParameters = extension.parameters === undefined ? [] : extension.parameters;
+    if (!isStringArray(mappedParameters) || new Set(mappedParameters).size !== mappedParameters.length) {
+        return undefined;
+    }
+    const allowedParameters = new Set(parameters.map((parameter) => parameter.name));
+    if (!mappedParameters.every((parameter) => allowedParameters.has(parameter))) {
+        return undefined;
+    }
+    return { path, parameters: mappedParameters };
+}
 function matchesPattern(value, pattern) {
     if (!value) {
         return false;
@@ -425,6 +449,7 @@ export async function generateRuntime(document, configFile, baseUrl) {
         const parameters = (operation.parameters ?? []).filter(isSupportedParameter).map((parameter) => toGeneratedParameter(parameter, usedFlagNames));
         const bodyParameters = extractBodyParameters(operation.requestBody, usedFlagNames);
         const allParameters = [...parameters, ...bodyParameters];
+        const ui = getGeneratedUIOperation(operation, allParameters);
         const hasBody = Boolean(operation.requestBody && !('$ref' in operation.requestBody));
         const requestContentType = getRequestContentType(operation.requestBody);
         const responseType = getResponseType(operation);
@@ -456,6 +481,8 @@ export async function generateRuntime(document, configFile, baseUrl) {
             resourceDisplayName,
             resourceDescription,
             commandId: segments.join(' '),
+            operationId: operation.operationId,
+            ui,
             method,
             pathTemplate,
             tags: operation.tags,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.2.0-beta.16",
+  "version": "2.2.0-beta.18",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -144,5 +144,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "49d9bd2e21122eab9435f128375828b8c5bb4c07"
+  "gitHead": "b74c962f7d35aa12012d908d16bd74fe6ac20a3d"
 }