@nocobase/cli 2.1.0-alpha.16 → 2.1.0-alpha.17

package/dist/lib/ui.js

@@ -0,0 +1,169 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import ora from 'ora';
+import pc from 'picocolors';
+let activeSpinner;
+let verboseMode = false;
+function stringWidth(value) {
+    return Array.from(value).length;
+}
+function pad(value, width) {
+    const padding = Math.max(0, width - stringWidth(value));
+    return `${value}${' '.repeat(padding)}`;
+}
+export function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+export function setVerboseMode(value) {
+    verboseMode = value;
+}
+export function isVerboseMode() {
+    return verboseMode;
+}
+export async function promptText(message, options) {
+    if (!isInteractiveTerminal()) {
+        return options?.defaultValue ?? '';
+    }
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? ` (${options.defaultValue})` : '';
+        const hint = options?.secret ? ' [input visible]' : '';
+        const prompt = `${message}${suffix}${hint}: `;
+        const answer = await rl.question(prompt);
+        return answer.trim() || options?.defaultValue || '';
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function confirmAction(message, options) {
+    if (!isInteractiveTerminal()) {
+        return Boolean(options?.defaultValue);
+    }
+    stopTask();
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? pc.dim('[Y/n]') : pc.dim('[y/N]');
+        const prompt = `${pc.yellow('?')} ${pc.bold(message)} ${suffix} `;
+        const answer = await rl.question(prompt);
+        const normalized = answer.trim().toLowerCase();
+        if (!normalized) {
+            return Boolean(options?.defaultValue);
+        }
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export function printSection(title) {
+    console.log(pc.bold(title));
+}
+export function printInfo(message) {
+    if (activeSpinner) {
+        if (!isInteractiveTerminal()) {
+            activeSpinner = undefined;
+            console.log(pc.cyan(message));
+            return;
+        }
+        activeSpinner.info(pc.cyan(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.cyan(message));
+}
+export function printVerbose(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printInfo(message);
+}
+export function printSuccess(message) {
+    if (activeSpinner) {
+        if (!isInteractiveTerminal()) {
+            activeSpinner = undefined;
+            console.log(pc.green(message));
+            return;
+        }
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+export function printWarning(message) {
+    if (activeSpinner) {
+        if (!isInteractiveTerminal()) {
+            activeSpinner = undefined;
+            console.log(pc.yellow(message));
+            return;
+        }
+        activeSpinner.warn(pc.yellow(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.yellow(message));
+}
+export function printVerboseWarning(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printWarning(message);
+}
+export function startTask(message) {
+    if (activeSpinner) {
+        activeSpinner.stop();
+    }
+    activeSpinner = ora({
+        text: pc.cyan(message),
+        isSilent: !isInteractiveTerminal(),
+    }).start();
+    if (!isInteractiveTerminal()) {
+        console.log(pc.cyan(message));
+    }
+}
+export function updateTask(message) {
+    if (!activeSpinner) {
+        startTask(message);
+        return;
+    }
+    activeSpinner.text = pc.cyan(message);
+}
+export function succeedTask(message) {
+    if (activeSpinner) {
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+export function failTask(message) {
+    if (activeSpinner) {
+        activeSpinner.fail(pc.red(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.error(pc.red(message));
+}
+export function stopTask() {
+    if (activeSpinner) {
+        activeSpinner.stop();
+        activeSpinner = undefined;
+    }
+}
+export function renderTable(headers, rows) {
+    const widths = headers.map((header, index) => {
+        return rows.reduce((max, row) => Math.max(max, stringWidth(row[index] ?? '')), stringWidth(header));
+    });
+    const renderRow = (row) => row.map((cell, index) => pad(cell ?? '', widths[index])).join('  ').trimEnd();
+    const divider = widths.map((width) => '-'.repeat(width)).join('  ');
+    return [renderRow(headers), divider, ...rows.map(renderRow)].join('\n');
+}

package/dist/post-processors/data-modeling.js

@@ -0,0 +1,66 @@
+/**
+ * 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 { postProcessorRegistry } from '../lib/post-processors.js';
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value?.data)) {
+        return value.data;
+    }
+    return [];
+}
+function pickCollectionSummary(item) {
+    return {
+        key: item?.key,
+        name: item?.name,
+        title: item?.title,
+        description: item?.description,
+    };
+}
+function pickFieldSummary(item) {
+    return {
+        key: item?.key,
+        name: item?.name,
+        type: item?.type,
+        title: item?.uiSchema?.title,
+        description: item?.description,
+        collectionName: item?.collectionName,
+    };
+}
+function simplifyCollectionsListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickCollectionSummary(item)),
+        meta: result?.meta,
+        nextActions: [
+            'Use collections:get with filterByTk=<collectionName> to inspect one collection in detail.',
+            'Use collections:apply with --verify when you need normalized verification in the same response.',
+        ],
+    };
+}
+function simplifyFieldsListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickFieldSummary(item)),
+        meta: result?.meta,
+    };
+}
+export function registerDataModelingPostProcessors() {
+    postProcessorRegistry.register('collections', 'list', simplifyCollectionsListResult);
+    postProcessorRegistry.register('collections', 'apply', (result) => ({
+        data: pickCollectionSummary(result?.data || {}),
+        verify: result?.verify,
+    }));
+    postProcessorRegistry.register('collections', 'verify', (result) => result);
+    postProcessorRegistry.register('fields', 'apply', (result) => ({
+        data: pickFieldSummary(result?.data || {}),
+    }));
+    postProcessorRegistry.register('collections.fields', 'list', simplifyFieldsListResult);
+}

package/dist/post-processors/data-source-manager.js

@@ -0,0 +1,114 @@
+/**
+ * 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 { postProcessorRegistry } from '../lib/post-processors.js';
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value?.data)) {
+        return value.data;
+    }
+    return [];
+}
+function parseAssociatedIndex(value) {
+    if (typeof value !== 'string') {
+        return {};
+    }
+    const separatorIndex = value.indexOf('.');
+    if (separatorIndex === -1) {
+        return {};
+    }
+    return {
+        dataSourceKey: value.slice(0, separatorIndex),
+        collectionName: value.slice(separatorIndex + 1),
+    };
+}
+function pickCollectionSummary(item) {
+    return {
+        name: item?.name,
+        title: item?.title ?? item?.options?.title ?? item?.displayName,
+        description: item?.description ?? item?.options?.description,
+        dataSourceKey: item?.dataSourceKey,
+    };
+}
+function pickFieldSummary(item) {
+    return {
+        name: item?.name,
+        type: item?.type,
+        title: item?.uiSchema?.title,
+        description: item?.description,
+        dataSourceKey: item?.dataSourceKey,
+        collectionName: item?.collectionName,
+    };
+}
+function pickRemoteFieldSummary(item, defaults) {
+    return {
+        name: item?.name,
+        type: item?.type,
+        title: item?.uiSchema?.title,
+        description: item?.description,
+        dataSourceKey: item?.dataSourceKey,
+        collectionName: item?.collectionName,
+        ...defaults,
+    };
+}
+function pickDataSourceSummary(item) {
+    const summary = {
+        displayName: item?.displayName,
+        key: item?.key,
+        type: item?.type,
+        status: item?.status,
+    };
+    if (Array.isArray(item?.collections)) {
+        summary.collections = item.collections.map((collection) => {
+            const nextCollection = pickCollectionSummary({
+                ...collection,
+                dataSourceKey: collection?.dataSourceKey ?? item?.key,
+            });
+            if (Array.isArray(collection?.fields)) {
+                nextCollection.fields = collection.fields.map((field) => pickRemoteFieldSummary(field, {
+                    dataSourceKey: collection?.dataSourceKey ?? item?.key,
+                    collectionName: collection?.name,
+                }));
+            }
+            return nextCollection;
+        });
+    }
+    return summary;
+}
+export function simplifyDataSourceListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickDataSourceSummary(item)),
+        meta: result?.meta,
+    };
+}
+export function simplifyDataSourceCollectionsListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickCollectionSummary(item)),
+        meta: result?.meta,
+    };
+}
+export function simplifyDataSourceFieldsListResult(result, options) {
+    const items = toArray(result);
+    const defaults = parseAssociatedIndex(options?.flags?.['associated-index']);
+    return {
+        data: items.map((item) => item?.dataSourceKey || item?.collectionName ? pickFieldSummary(item) : pickRemoteFieldSummary(item, defaults)),
+        meta: result?.meta,
+    };
+}
+export function registerDataSourceManagerPostProcessors() {
+    postProcessorRegistry.register('data-sources', 'list', simplifyDataSourceListResult);
+    postProcessorRegistry.register('data-sources', 'list-enabled', simplifyDataSourceListResult);
+    postProcessorRegistry.register('data-sources.collections', 'list', simplifyDataSourceCollectionsListResult);
+    postProcessorRegistry.register('data-sources-collections.fields', 'list', (result, context) => simplifyDataSourceFieldsListResult(result, {
+        flags: context.flags,
+    }));
+}

package/dist/post-processors/index.js

@@ -0,0 +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 { registerDataModelingPostProcessors } from './data-modeling.js';
+import { registerDataSourceManagerPostProcessors } from './data-source-manager.js';
+let initialized = false;
+export function registerPostProcessors() {
+    if (initialized) {
+        return;
+    }
+    registerDataModelingPostProcessors();
+    registerDataSourceManagerPostProcessors();
+    initialized = true;
+}

package/nocobase-ctl.config.json

@@ -0,0 +1,327 @@
+{
+  "moduleGroups": [
+    {
+      "match": [
+        "workflow*",
+        "@nocobase/plugin-workflow*"
+      ],
+      "module": "workflow"
+    },
+    {
+      "match": [
+        "@nocobase/plugin-data-source-main",
+        "@nocobase/plugin-data-source-manager"
+      ],
+      "module": "data-modeling"
+    }
+  ],
+  "modules": {
+    "core": {
+      "name": "core",
+      "description": "NocoBase core resource APIs.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "app",
+          "pm"
+        ],
+        "excludes": [],
+        "overrides": {
+          "app": {
+            "name": "app",
+            "description": "Application management commands.",
+            "topLevel": true
+          },
+          "pm": {
+            "name": "pm",
+            "description": "Plugin manager commands.",
+            "topLevel": true
+          }
+        }
+      }
+    },
+    "acl": {
+      "name": "acl",
+      "description": "Based on roles, resources, and actions, access control can precisely manage interface configuration permissions, data operation permissions, menu access permissions, and plugin permissions.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "availableActions",
+          "dataSources",
+          "roles",
+          "rolesResourcesScopes"
+        ],
+        "excludes": [],
+        "overrides": {
+          "availableActions": {
+            "name": "available-actions",
+            "description": "List and inspect configurable ACL actions.",
+            "topLevel": false
+          },
+          "dataSources": {
+            "name": "data-sources",
+            "description": "Manage ACL strategies for data sources.",
+            "topLevel": false
+          },
+          "roles": {
+            "name": "roles",
+            "description": "Manage roles and role-level ACL settings.",
+            "topLevel": false
+          },
+          "rolesResourcesScopes": {
+            "name": "roles-resources-scopes",
+            "description": "Manage role resource scopes and permissions.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "api-keys": {
+      "name": "api-keys",
+      "description": "Allow users to access the HTTP API with API keys.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "apiKeys"
+        ],
+        "excludes": [],
+        "overrides": {
+          "apiKeys": {
+            "name": "api-keys",
+            "description": "Manage API keys.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "auth": {
+      "name": "authenticators",
+      "description": "User authentication management, including password auth, SMS auth, SSO protocols, and extensible providers.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "authenticators"
+        ],
+        "excludes": [],
+        "overrides": {
+          "auth": {
+            "name": "auth",
+            "description": "Authenticate users and manage auth sessions.",
+            "topLevel": false
+          },
+          "authenticators": {
+            "name": "authenticators",
+            "description": "Manage authentication providers and authenticators.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "client": {
+      "name": "client",
+      "description": "Provide the web client interface for the NocoBase server.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "desktopRoutes",
+          "roles"
+        ],
+        "excludes": [],
+        "overrides": {
+          "desktopRoutes": {
+            "name": "desktop-routes",
+            "description": "Manage desktop route permissions and visibility.",
+            "topLevel": true
+          },
+          "roles": {
+            "name": "roles",
+            "description": "Manage client permissions scoped by role.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "data-modeling": {
+      "name": "data-modeling",
+      "description": "Manage data sources, collections, and database modeling resources.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "collections",
+          "fields",
+          "dbViews"
+        ],
+        "excludes": [],
+        "overrides": {
+          "collections": {
+            "name": "collections",
+            "description": "Manage collections and collection metadata.",
+            "topLevel": false,
+            "operations": {
+              "includes": [
+                "apply",
+                "collections:list",
+                "collections:get",
+                "collections:destroy",
+                "collections/{collectionName}/fields:list"
+              ]
+            }
+          },
+          "fields": {
+            "name": "fields",
+            "description": "Manage fields with the compact high-level modeling interface.",
+            "topLevel": false,
+            "operations": {
+              "includes": [
+                "apply"
+              ]
+            }
+          },
+          "dbViews": {
+            "name": "db-views",
+            "description": "Inspect and query database views.",
+            "topLevel": false,
+            "operations": {
+              "includes": [
+                "dbViews:list",
+                "dbViews:get"
+              ]
+            }
+          }
+        }
+      }
+    },
+    "file-manager": {
+      "name": "file-manager",
+      "description": "Provide file storage services, file collections, and attachment fields.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "storages"
+        ],
+        "excludes": [],
+        "overrides": {
+          "storages": {
+            "name": "storages",
+            "description": "Manage storage backends and file storage settings.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "flow-engine": {
+      "name": "flow-engine",
+      "description": "Manage flow surface composition, configuration, layout, and mutation APIs.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "flowSurfaces"
+        ],
+        "excludes": [],
+        "overrides": {
+          "flowSurfaces": {
+            "name": "flow-surfaces",
+            "description": "Compose and mutate page, tab, block, field, and action surfaces.",
+            "topLevel": true
+          }
+        }
+      }
+    },
+    "map": {
+      "name": "map",
+      "description": "Map blocks with support for AMap, Google Maps, and extensible providers.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "map-configuration"
+        ],
+        "excludes": [],
+        "overrides": {
+          "map-configuration": {
+            "name": "map-configuration",
+            "description": "Manage map provider configuration.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "system-settings": {
+      "name": "system-settings",
+      "description": "Adjust system title, logo, language, and other global settings.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "systemSettings"
+        ],
+        "excludes": [],
+        "overrides": {
+          "systemSettings": {
+            "name": "system-settings",
+            "description": "Manage global system settings.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "theme-editor": {
+      "name": "theme-editor",
+      "description": "Customize UI colors and dimensions, save themes, and switch between them.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "themeConfig"
+        ],
+        "excludes": [],
+        "overrides": {
+          "themeConfig": {
+            "name": "theme-config",
+            "description": "Manage theme configuration.",
+            "topLevel": false
+          }
+        }
+      }
+    },
+    "workflow": {
+      "name": "workflow",
+      "description": "A powerful BPM tool that provides the foundation for business automation and extensible triggers and nodes.",
+      "include": true,
+      "resources": {
+        "includes": [
+          "executions",
+          "flow_nodes",
+          "jobs",
+          "userWorkflowTasks",
+          "workflows"
+        ],
+        "excludes": [],
+        "overrides": {
+          "executions": {
+            "name": "executions",
+            "description": "Manage workflow execution records.",
+            "topLevel": false
+          },
+          "flow_nodes": {
+            "name": "flow-nodes",
+            "description": "Manage workflow nodes.",
+            "topLevel": false
+          },
+          "jobs": {
+            "name": "jobs",
+            "description": "Manage workflow jobs.",
+            "topLevel": false
+          },
+          "userWorkflowTasks": {
+            "name": "user-workflow-tasks",
+            "description": "Query current user workflow tasks.",
+            "topLevel": false
+          },
+          "workflows": {
+            "name": "workflows",
+            "description": "Manage workflows and workflow revisions.",
+            "topLevel": false
+          }
+        }
+      }
+    }
+  }
+}