openyida 2026.5.27-beta.1 → 2026.5.27

package/README.md

@@ -312,9 +312,12 @@ For overseas apps, pass `--locale en_US` or `--locale ja_JP` on creation command
 | `openyida create-form update <appType> <formUuid> <changes.json> [--locale zh_CN\|en_US\|ja_JP] [--open\|--no-open]` | Update a form page |
 | `openyida create-form patch <appType> <formUuid> <patch.json> [--open\|--no-open]` | Apply controlled schema patches for designer-only form settings |
 | `openyida create-form rule <appType> <formUuid> <rules.json> [--open\|--no-open]` | Configure field show/hide linkage and onChange auto-assignment rules |
+| `openyida create-form validation <appType> <formUuid> <validations.json> [--open\|--no-open]` | Configure form validations using Yida-visible field `props.validation` rules and `customValidate` JSExpression functions for regex, bank card, cross-field, conditional, or async checks |
+| `openyida add-validation <appType> <formUuid> --field <labelOrId> --type <phone\|regex\|idCard\|email\|...> [--message <text>]` | Add one smart validation rule without writing a JSON file |
 | `openyida create-form bind-datasource <appType> <formUuid> <fieldLabelOrId> <datasource.json> [--open\|--no-open]` | Bind URL/search data sources to SelectField/MultiSelectField-style option fields |
 | `openyida create-form add-option <appType> <formUuid> <fieldLabel> <option1> [option2] ...` | Append options to a SelectField/RadioField/CheckboxField/MultiSelectField |
 | `openyida list-forms <appType> [--keyword <text>]` | List forms in an application |
+| `openyida aggregate-table <list\|create-empty\|inspect\|preview\|save\|publish\|status> <appType> ...` | Manage Yida aggregate tables (`virtualView`) |
 | `openyida get-schema <appType> <formUuid\|--all> [--field <labelOrFieldId>]` | Fetch one form schema, batch export all, or pick a single field's full props |
 | `openyida create-page <appType> "<name>" [--mode dashboard] [--locale zh_CN\|en_US\|ja_JP] [--open\|--no-open]` | Create a custom display page; dashboard mode hides top/workbench chrome |
 | `openyida generate-page <template> [--spec file]` | Generate custom page source from templates (`product-homepage`, `todo-mvc`) |
@@ -324,13 +327,15 @@ For overseas apps, pass `--locale en_US` or `--locale ja_JP` on creation command
 | `openyida publish <sourceFile> <appType> <formUuid> [--compat] [--health-check] [--force] [--open\|--no-open]` | Compile and publish a custom display page; by default the target must be `formType=display` |
 | `openyida update-form-config <appType> <formUuid> <isRenderNav> <title> [--locale zh_CN\|en_US\|ja_JP]` | Update page/form display configuration |
 
+Form field definitions can include `alias` or `componentAlias` to populate Yida designer component aliases, stored as `pages[0].componentAlias.items`. Yida runtime resolves these aliases in page JS, so `this.$('phone')` can be used instead of `this.$('textField_xxx')`; OpenYida form rules, validations, and `openyida data ... --resolve-aliases` JSON inputs also accept aliases as field references. For server-side DingTalk OpenAPI calls, use `GET /v2.0/yida/forms/component/alias/{appType}/{formUuid}` to read the `{ fieldId, alias }` mapping, then translate aliases before sending form data/search JSON. That endpoint requires `systemToken`, `userId`, an access token, and the Yida form data read permission; grant that permission in DingTalk developer console API permissions and publish the DingTalk app. Yida app code and app secret are available under app settings > deployment/maintenance.
+
 `openyida publish` preserves existing custom page data sources by default. Before saving the new compiled JSX Schema, it reads the current page Schema and merges the Page-level `dataSource` with the built-in `urlParams` and `timestamp` sources, so manually configured data sources are not deleted during republish.
 
 ### Data, Permissions, and Sharing
 
 | Command | Description |
 |---------|-------------|
-| `openyida data <action> <resource> [args]` | Unified data management for forms, processes, tasks, and subforms; form queries support `--all` and `--form-uuid` subform hydration |
+| `openyida data <action> <resource> [args]` | Unified data management for forms, processes, tasks, and subforms; form queries support `--all`, `--form-uuid` subform hydration, and `--resolve-aliases` for component alias JSON keys |
 | `openyida data check <appType> <formUuid> <rules.json>` | Detect anomalous process-form records |
 | `openyida task-center <type> [options]` | Query todo, created, processed, CC, or proxy-submitted tasks |
 | `openyida agent-center <sub-command>` | Manage Yida process delegation and departure delegation |
@@ -351,6 +356,7 @@ For overseas apps, pass `--locale en_US` or `--locale ja_JP` on creation command
 |---------|-------------|
 | `openyida create-process <appType> ...` | Create a process form and configure workflow |
 | `openyida configure-process <appType> ...` | Configure and publish process rules |
+| `openyida ai-form-setting <get\|fields\|models\|enable\|disable\|save> <appType> ...` | Manage process-form AI approval prompts from `/settings/aiFormSetting` |
 | `openyida process preview <appType> <processInstanceId> [--output <path>]` | Generate a visual process preview |
 | `openyida create-report <appType> "<name>" <charts.json> [--open\|--no-open]` | Create a Yida report |
 | `openyida append-chart <appType> <reportId> <charts.json> [--open\|--no-open]` | Append a chart to an existing report |

package/bin/yida.js

@@ -642,12 +642,24 @@ async function main() {
       break;
     }
 
+    case 'add-validation': {
+      process.argv = [process.argv[0], process.argv[1], 'validation', ...args];
+      require('../lib/app/create-form');
+      break;
+    }
+
     case 'list-forms': {
       const { run } = require('../lib/app/list-forms');
       await run(args);
       break;
     }
 
+    case 'aggregate-table': {
+      const { run } = require('../lib/aggregate-table/aggregate-table');
+      await run(args);
+      break;
+    }
+
     case 'get-schema': {
       const { run } = require('../lib/app/get-schema');
       await run(args);
@@ -881,6 +893,14 @@ async function main() {
       break;
     }
 
+    case 'ai-form-setting':
+    case 'ai-approve':
+    case 'aiFormSetting': {
+      const { run: runAIFormSetting } = require('../lib/process/ai-form-setting');
+      await runAIFormSetting(args);
+      break;
+    }
+
     case 'process': {
       const subCommand = args[0];
       const subArgs = args.slice(1);

package/lib/aggregate-table/aggregate-table.js

@@ -0,0 +1,594 @@
+'use strict';
+
+const fs = require('fs');
+const querystring = require('querystring');
+
+const {
+  loadCookieData,
+  triggerLogin,
+  resolveBaseUrl,
+  httpGet,
+  httpPost,
+  requestWithAutoLogin,
+} = require('../core/utils');
+const { t } = require('../core/i18n');
+const { buildYidaTitleI18n, normalizeYidaLocale, resolveContentLocale } = require('../core/yida-i18n');
+const { parseOpenOption, withBrowserHandoff } = require('../core/browser-handoff');
+const { fetchFormPageList, resolveLocalizedText } = require('../app/form-navigation');
+
+const FORM_TYPE_VIRTUAL_VIEW = 'virtualView';
+const DESIGN_KEYS = [
+  'relationForms',
+  'relationships',
+  'aggregatedFields',
+  'auxFields',
+  'formulaFields',
+  'validators',
+];
+
+function hasHelpFlag(args) {
+  return (args || []).includes('--help') || (args || []).includes('-h');
+}
+
+function printUsage() {
+  process.stderr.write([
+    t('aggregate_table.usage'),
+    '',
+    t('aggregate_table.commands_title'),
+    `  ${t('aggregate_table.cmd_list')}`,
+    `  ${t('aggregate_table.cmd_create_empty')}`,
+    `  ${t('aggregate_table.cmd_inspect')}`,
+    `  ${t('aggregate_table.cmd_preview')}`,
+    `  ${t('aggregate_table.cmd_save')}`,
+    `  ${t('aggregate_table.cmd_publish')}`,
+    `  ${t('aggregate_table.cmd_status')}`,
+    '',
+    t('aggregate_table.examples_title'),
+    `  ${t('aggregate_table.example_list')}`,
+    `  ${t('aggregate_table.example_create_empty')}`,
+    `  ${t('aggregate_table.example_inspect')}`,
+    '',
+  ].join('\n'));
+}
+
+function parseFlags(args) {
+  const openOption = parseOpenOption(args || []);
+  const positional = [];
+  const flags = {
+    json: false,
+    keyword: '',
+    locale: null,
+  };
+
+  for (let index = 0; index < openOption.args.length; index++) {
+    const arg = openOption.args[index];
+    if (arg === '--json') {
+      flags.json = true;
+      continue;
+    }
+    if (arg === '--keyword' && openOption.args[index + 1]) {
+      flags.keyword = openOption.args[++index];
+      continue;
+    }
+    if ((arg === '--locale' || arg === '--content-locale' || arg === '--lang') && openOption.args[index + 1]) {
+      const locale = openOption.args[++index];
+      if (!normalizeYidaLocale(locale)) {
+        throw new Error(t('aggregate_table.unsupported_locale', locale));
+      }
+      flags.locale = locale;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  flags.openMode = openOption.mode;
+  return { positional, flags };
+}
+
+function unwrapContent(result) {
+  if (result && Object.prototype.hasOwnProperty.call(result, 'content')) {
+    return result.content;
+  }
+  return result;
+}
+
+function assertSuccess(result, action) {
+  if (!result || result.success === false || result.__needLogin || result.__csrfExpired) {
+    const message = result
+      ? result.errorMsg || result.error || result.message || t('common.unknown_error')
+      : t('common.request_failed');
+    throw new Error(`${action}: ${message}`);
+  }
+  return unwrapContent(result);
+}
+
+async function createAuthRef() {
+  let cookieData = loadCookieData();
+  if (!cookieData) {
+    cookieData = await triggerLogin();
+  }
+  if (!cookieData || !cookieData.cookies) {
+    throw new Error(t('aggregate_table.no_login'));
+  }
+  return {
+    csrfToken: cookieData.csrf_token,
+    cookies: cookieData.cookies,
+    baseUrl: resolveBaseUrl(cookieData),
+    cookieData,
+  };
+}
+
+function buildCreateEmptyPostData(csrfToken, title) {
+  return querystring.stringify({
+    _csrf_token: csrfToken,
+    formType: 'receipt',
+    isVirtualView: 'y',
+    title: JSON.stringify(buildYidaTitleI18n(title, {
+      en_US: title,
+      ja_JP: title,
+    })),
+  });
+}
+
+function buildDesignPostData(csrfToken, formUuid, designInfo, gmtModified) {
+  const payload = {
+    _csrf_token: csrfToken,
+    formUuid,
+    designInfo: JSON.stringify(designInfo),
+  };
+  if (gmtModified !== undefined) {
+    payload.gmtModified = gmtModified === null ? '' : gmtModified;
+  }
+  return querystring.stringify(payload);
+}
+
+async function checkVirtualViewFeature(authRef, appType) {
+  return requestWithAutoLogin((auth) => {
+    return httpPost(
+      auth.baseUrl,
+      `/dingtalk/web/${appType}/query/virtualview/show.json`,
+      querystring.stringify({ _csrf_token: auth.csrfToken }),
+      auth.cookies
+    );
+  }, authRef);
+}
+
+async function createEmptyVirtualView(authRef, appType, title) {
+  return requestWithAutoLogin((auth) => {
+    return httpPost(
+      auth.baseUrl,
+      `/dingtalk/web/${appType}/query/formdesign/saveFormSchemaInfo.json`,
+      buildCreateEmptyPostData(auth.csrfToken, title),
+      auth.cookies
+    );
+  }, authRef);
+}
+
+async function getVirtualViewConfig(authRef, appType, formUuid) {
+  return requestWithAutoLogin((auth) => {
+    return httpGet(
+      auth.baseUrl,
+      `/alibaba/web/${appType}/query/virtualview/get.json`,
+      { formUuid },
+      auth.cookies
+    );
+  }, authRef);
+}
+
+async function postVirtualViewDesign(authRef, appType, formUuid, designInfo, action, gmtModified) {
+  const endpointMap = {
+    preview: 'preview.json',
+    save: 'saveStashConfig.json',
+    publish: 'update.json',
+  };
+  const endpoint = endpointMap[action];
+  if (!endpoint) {
+    throw new Error(`Unknown aggregate table action: ${action}`);
+  }
+
+  return requestWithAutoLogin((auth) => {
+    return httpPost(
+      auth.baseUrl,
+      `/alibaba/web/${appType}/query/virtualview/${endpoint}`,
+      buildDesignPostData(auth.csrfToken, formUuid, designInfo, gmtModified),
+      auth.cookies
+    );
+  }, authRef);
+}
+
+async function queryBuildState(authRef, appType, formUuid) {
+  return requestWithAutoLogin((auth) => {
+    return httpGet(
+      auth.baseUrl,
+      `/alibaba/web/${appType}/query/virtualview/queryBuildState.json`,
+      { formUuid },
+      auth.cookies
+    );
+  }, authRef);
+}
+
+function isVirtualViewNode(node) {
+  return node && node.formType === FORM_TYPE_VIRTUAL_VIEW;
+}
+
+function filterAggregateTables(items, keyword) {
+  const aggregateTables = (items || []).filter(isVirtualViewNode);
+  if (!keyword) {
+    return aggregateTables;
+  }
+  const normalized = String(keyword).toLowerCase();
+  return aggregateTables.filter((item) => {
+    return [item.formName, item.formUuid, item.pathName]
+      .filter(Boolean)
+      .some((value) => String(value).toLowerCase().includes(normalized));
+  });
+}
+
+function normalizeAggregateTableNode(node) {
+  return {
+    formUuid: node.formUuid,
+    aggregateTableId: node.formUuid,
+    name: node.formName || '',
+    formType: FORM_TYPE_VIRTUAL_VIEW,
+    pathName: node.pathName || '',
+  };
+}
+
+function readJsonInput(input) {
+  if (!input) {
+    throw new Error(t('aggregate_table.design_required'));
+  }
+
+  let raw = input;
+  if (fs.existsSync(input)) {
+    raw = fs.readFileSync(input, 'utf8');
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(t('aggregate_table.invalid_json', err.message));
+  }
+}
+
+function normalizeDesignConfig(rawConfig, formUuid) {
+  let config = rawConfig;
+
+  if (config && typeof config.designInfo === 'string') {
+    config = JSON.parse(config.designInfo);
+  } else if (config && config.designInfo && typeof config.designInfo === 'object') {
+    config = config.designInfo;
+  } else if (config && config.viewDesignConfig) {
+    config = config.viewDesignConfig;
+  } else if (config && Object.prototype.hasOwnProperty.call(config, 'content')) {
+    config = config.content && config.content.viewDesignConfig
+      ? config.content.viewDesignConfig
+      : config.content;
+  }
+
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(t('aggregate_table.design_object_required'));
+  }
+
+  const normalized = { formUuid };
+  for (const key of DESIGN_KEYS) {
+    normalized[key] = Array.isArray(config[key]) ? config[key] : [];
+  }
+  return normalized;
+}
+
+function summarizeDesignConfig(config) {
+  const safeConfig = config || {};
+  return {
+    formUuid: safeConfig.formUuid || '',
+    title: resolveLocalizedText(safeConfig.title, ''),
+    isStashConfig: safeConfig.isStashConfig || '',
+    gmtModified: safeConfig.gmtModified || null,
+    stashGmtModified: safeConfig.stashGmtModified || null,
+    counts: {
+      relationForms: Array.isArray(safeConfig.relationForms) ? safeConfig.relationForms.length : 0,
+      relationships: Array.isArray(safeConfig.relationships) ? safeConfig.relationships.length : 0,
+      aggregatedFields: Array.isArray(safeConfig.aggregatedFields) ? safeConfig.aggregatedFields.length : 0,
+      auxFields: Array.isArray(safeConfig.auxFields) ? safeConfig.auxFields.length : 0,
+      formulaFields: Array.isArray(safeConfig.formulaFields) ? safeConfig.formulaFields.length : 0,
+      validators: Array.isArray(safeConfig.validators) ? safeConfig.validators.length : 0,
+    },
+  };
+}
+
+function buildDesignUrl(baseUrl, appType, formUuid, options = {}) {
+  const suffix = options.fromNew ? '&fromNew=true' : '';
+  return `${baseUrl}/alibaba/web/${appType}/design/virtualViewDesigner.html?formUuid=${formUuid}${suffix}`;
+}
+
+function buildWorkbenchUrl(baseUrl, appType, formUuid) {
+  return `${baseUrl}/${appType}/workbench/${formUuid}`;
+}
+
+function printSummary(title, rows) {
+  const { result } = require('../core/chalk');
+  result(true, title, rows);
+}
+
+async function runList(args) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  if (!appType) {
+    const { error } = require('../core/chalk');
+    error(t('aggregate_table.list_usage'), { hint: t('aggregate_table.example_list') });
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const items = await fetchFormPageList(appType, authRef);
+  const aggregateTables = filterAggregateTables(items, flags.keyword).map(normalizeAggregateTableNode);
+
+  if (!flags.json) {
+    printSummary(t('aggregate_table.list_success'), [
+      ['App', appType],
+      ['Count', String(aggregateTables.length)],
+    ]);
+  }
+
+  console.log(JSON.stringify(aggregateTables, null, 2));
+}
+
+async function runCreateEmpty(args) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  const name = positional[1];
+  if (!appType || !name) {
+    const { error } = require('../core/chalk');
+    error(t('aggregate_table.create_empty_usage'), { hint: t('aggregate_table.example_create_empty') });
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const contentLocale = resolveContentLocale({ locale: flags.locale, baseUrl: authRef.baseUrl });
+
+  const featureResult = await checkVirtualViewFeature(authRef, appType);
+  const featureEnabled = assertSuccess(featureResult, t('aggregate_table.check_feature'));
+  if (featureEnabled !== true) {
+    throw new Error(t('aggregate_table.feature_disabled'));
+  }
+
+  const createResult = await createEmptyVirtualView(authRef, appType, name);
+  const created = assertSuccess(createResult, t('aggregate_table.create_empty'));
+  const formUuid = (created && created.formUuid) || created;
+  const designUrl = buildDesignUrl(authRef.baseUrl, appType, formUuid, { fromNew: true });
+  const workbenchUrl = buildWorkbenchUrl(authRef.baseUrl, appType, formUuid);
+
+  printSummary(t('aggregate_table.create_empty_success'), [
+    ['App', appType],
+    ['Aggregate Table ID', formUuid],
+    ['Locale', contentLocale],
+    ['Design URL', designUrl],
+  ]);
+
+  console.log(JSON.stringify(withBrowserHandoff({
+    success: true,
+    appType,
+    aggregateTableId: formUuid,
+    formUuid,
+    name,
+    formType: FORM_TYPE_VIRTUAL_VIEW,
+    locale: contentLocale,
+    designUrl,
+    workbenchUrl,
+  }, designUrl, { stage: 'aggregate_table_create_empty_success', title: name }, flags.openMode)));
+}
+
+async function runInspect(args) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  const formUuid = positional[1];
+  if (!appType || !formUuid) {
+    const { error } = require('../core/chalk');
+    error(t('aggregate_table.inspect_usage'), { hint: t('aggregate_table.example_inspect') });
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const result = await getVirtualViewConfig(authRef, appType, formUuid);
+  const config = assertSuccess(result, t('aggregate_table.inspect'));
+  const summary = summarizeDesignConfig(config);
+
+  if (!flags.json) {
+    printSummary(t('aggregate_table.inspect_success'), [
+      ['App', appType],
+      ['Aggregate Table ID', formUuid],
+      ['Data Sources', String(summary.counts.relationForms)],
+      ['Relationships', String(summary.counts.relationships)],
+      ['Metrics', String(summary.counts.formulaFields)],
+      ['Validators', String(summary.counts.validators)],
+    ]);
+  }
+
+  console.log(JSON.stringify({
+    success: true,
+    appType,
+    aggregateTableId: formUuid,
+    formUuid,
+    summary,
+    config,
+  }, null, 2));
+}
+
+async function loadDesignForMutation(authRef, appType, formUuid, input, action) {
+  const rawConfig = readJsonInput(input);
+  const designInfo = normalizeDesignConfig(rawConfig, formUuid);
+  const currentResult = await getVirtualViewConfig(authRef, appType, formUuid);
+  const currentConfig = assertSuccess(currentResult, t('aggregate_table.inspect'));
+  const gmtModified = action === 'save'
+    ? currentConfig.stashGmtModified
+    : currentConfig.gmtModified;
+  return { designInfo, currentConfig, gmtModified };
+}
+
+async function runPreview(args) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  const formUuid = positional[1];
+  const input = positional[2];
+  if (!appType || !formUuid || !input) {
+    const { error } = require('../core/chalk');
+    error(t('aggregate_table.preview_usage'), { hint: t('aggregate_table.example_preview') });
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const designInfo = normalizeDesignConfig(readJsonInput(input), formUuid);
+  const result = await postVirtualViewDesign(authRef, appType, formUuid, designInfo, 'preview');
+  const rows = assertSuccess(result, t('aggregate_table.preview'));
+  const rowCount = Array.isArray(rows) ? rows.length : 0;
+
+  if (!flags.json) {
+    printSummary(t('aggregate_table.preview_success'), [
+      ['App', appType],
+      ['Aggregate Table ID', formUuid],
+      ['Rows', String(rowCount)],
+    ]);
+  }
+
+  console.log(JSON.stringify({
+    success: true,
+    appType,
+    aggregateTableId: formUuid,
+    formUuid,
+    rowCount,
+    rows,
+  }, null, 2));
+}
+
+async function runSaveOrPublish(args, action) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  const formUuid = positional[1];
+  const input = positional[2];
+  const isPublish = action === 'publish';
+  if (!appType || !formUuid || !input) {
+    const { error } = require('../core/chalk');
+    error(
+      isPublish ? t('aggregate_table.publish_usage') : t('aggregate_table.save_usage'),
+      { hint: isPublish ? t('aggregate_table.example_publish') : t('aggregate_table.example_save') }
+    );
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const { designInfo, gmtModified } = await loadDesignForMutation(authRef, appType, formUuid, input, action);
+  if (isPublish && designInfo.relationForms.length === 0) {
+    throw new Error(t('aggregate_table.publish_requires_source'));
+  }
+
+  const result = await postVirtualViewDesign(authRef, appType, formUuid, designInfo, action, gmtModified);
+  const content = assertSuccess(result, isPublish ? t('aggregate_table.publish') : t('aggregate_table.save'));
+  const designUrl = buildDesignUrl(authRef.baseUrl, appType, formUuid);
+  const workbenchUrl = buildWorkbenchUrl(authRef.baseUrl, appType, formUuid);
+
+  if (!flags.json) {
+    printSummary(isPublish ? t('aggregate_table.publish_success') : t('aggregate_table.save_success'), [
+      ['App', appType],
+      ['Aggregate Table ID', formUuid],
+      ['Design URL', designUrl],
+    ]);
+  }
+
+  console.log(JSON.stringify(withBrowserHandoff({
+    success: true,
+    action,
+    appType,
+    aggregateTableId: formUuid,
+    formUuid,
+    gmtModified: content && content.gmtModified,
+    response: content,
+    designUrl,
+    workbenchUrl,
+  }, designUrl, { stage: `aggregate_table_${action}_success`, title: formUuid }, flags.openMode), null, 2));
+}
+
+async function runStatus(args) {
+  const { positional, flags } = parseFlags(args);
+  const appType = positional[0];
+  const formUuid = positional[1];
+  if (!appType || !formUuid) {
+    const { error } = require('../core/chalk');
+    error(t('aggregate_table.status_usage'), { hint: t('aggregate_table.example_status') });
+    return;
+  }
+
+  const authRef = await createAuthRef();
+  const result = await queryBuildState(authRef, appType, formUuid);
+  const content = assertSuccess(result, t('aggregate_table.status'));
+
+  if (!flags.json) {
+    printSummary(t('aggregate_table.status_success'), [
+      ['App', appType],
+      ['Aggregate Table ID', formUuid],
+      ['Status', (content && content.status) || String(content || '')],
+    ]);
+  }
+
+  console.log(JSON.stringify({
+    success: true,
+    appType,
+    aggregateTableId: formUuid,
+    formUuid,
+    status: content && content.status,
+    result: content,
+  }, null, 2));
+}
+
+async function run(args) {
+  if (!args || args.length === 0 || hasHelpFlag(args)) {
+    printUsage();
+    return;
+  }
+
+  const subCommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subCommand) {
+    case 'list':
+      return runList(subArgs);
+    case 'create':
+    case 'create-empty':
+      return runCreateEmpty(subArgs);
+    case 'inspect':
+    case 'get':
+      return runInspect(subArgs);
+    case 'preview':
+      return runPreview(subArgs);
+    case 'save':
+      return runSaveOrPublish(subArgs, 'save');
+    case 'publish':
+      return runSaveOrPublish(subArgs, 'publish');
+    case 'status':
+      return runStatus(subArgs);
+    default: {
+      const { error } = require('../core/chalk');
+      error(t('aggregate_table.unknown_subcommand', subCommand), { hint: t('aggregate_table.usage') });
+      return null;
+    }
+  }
+}
+
+module.exports = {
+  DESIGN_KEYS,
+  FORM_TYPE_VIRTUAL_VIEW,
+  buildCreateEmptyPostData,
+  buildDesignPostData,
+  filterAggregateTables,
+  normalizeAggregateTableNode,
+  normalizeDesignConfig,
+  parseFlags,
+  readJsonInput,
+  summarizeDesignConfig,
+  run,
+  __api__: {
+    checkVirtualViewFeature,
+    createEmptyVirtualView,
+    getVirtualViewConfig,
+    postVirtualViewDesign,
+    queryBuildState,
+  },
+};