openyida 2026.7.19 → 2026.7.21

package/lib/app/services/native-page-schema-builder.js

@@ -0,0 +1,428 @@
+'use strict';
+
+const { stripSubtableFieldPrefix } = require('../../formula/field-refs');
+
+function createNodeIdGenerator() {
+  let counter = 1;
+  return function nextNodeId() {
+    return 'node_oc' + Date.now().toString(36) + (counter++).toString(36);
+  };
+}
+
+function generateSuffix() {
+  return Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
+}
+
+function getGlobalDataSourceFitConfig() {
+  const fitCompiled = "'use strict';\n\nvar __preParser__ = function fit(response) {\n  var content = response.content !== undefined ? response.content : response;\n  var error = {\n    message: response.errorMsg || response.errors && response.errors[0] && response.errors[0].msg || response.content || '远程数据源请求出错，success is false'\n  };\n  var success = true;\n  if (response.success !== undefined) {\n    success = response.success;\n  } else if (response.hasError !== undefined) {\n    success = !response.hasError;\n  }\n  return {\n    content: content,\n    success: success,\n    error: error\n  };\n};";
+  const fitSource = "function fit(response) {\r\n  const content = (response.content !== undefined) ? response.content : response;\r\n  const error = {\r\n    message: response.errorMsg ||\r\n      (response.errors && response.errors[0] && response.errors[0].msg) ||\r\n      response.content || '远程数据源请求出错，success is false',\r\n  };\r\n  let success = true;\r\n  if (response.success !== undefined) {\r\n    success = response.success;\r\n  } else if (response.hasError !== undefined) {\r\n    success = !response.hasError;\r\n  }\r\n  return {\r\n    content,\r\n    success,\r\n    error,\r\n  };\r\n}";
+
+  return {
+    fit: {
+      compiled: fitCompiled,
+      source: fitSource,
+      type: 'js',
+      error: {},
+    },
+  };
+}
+
+function buildDefaultPageDataSource(formUuid) {
+  const urlParamsDataSource = {
+    id: 'VCB660714833IBHEOXK376TA7XJH2AXUWR8MMW',
+    name: 'urlParams',
+    description: '当前页面地址的参数：如 aliwork.com/APP_XXX/workbench?id=1&name=宜搭，可通过 this.state.urlParams.name 获取到宜搭',
+    formUuid,
+    protocal: 'URI',
+    isReadonly: true,
+  };
+  const timestampDataSource = {
+    id: '',
+    name: 'timestamp',
+    description: '',
+    formUuid,
+    protocal: 'VALUE',
+    initialData: '',
+  };
+
+  return {
+    offline: [],
+    globalConfig: getGlobalDataSourceFitConfig(),
+    online: [urlParamsDataSource, timestampDataSource],
+    list: [urlParamsDataSource, timestampDataSource],
+    sync: true,
+  };
+}
+
+function cloneJson(value) {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+function isBuiltInPageDataSource(item) {
+  return !!(item && (item.name === 'urlParams' || item.name === 'timestamp'));
+}
+
+function getDataSourceIdentity(item) {
+  if (!item || typeof item !== 'object') {
+    return '';
+  }
+  if (isBuiltInPageDataSource(item)) {
+    return 'builtin:' + item.name;
+  }
+  if (item.id) {
+    return 'id:' + item.id;
+  }
+  if (item.name && item.protocal) {
+    return 'name:' + item.name + '|protocal:' + item.protocal;
+  }
+  if (item.name) {
+    return 'name:' + item.name;
+  }
+  return JSON.stringify(item);
+}
+
+function mergeDataSourceArray(existingItems, generatedItems) {
+  const merged = Array.isArray(existingItems) ? cloneJson(existingItems) : [];
+  const seen = new Set(merged.map(getDataSourceIdentity).filter(Boolean));
+
+  (Array.isArray(generatedItems) ? generatedItems : []).forEach((item) => {
+    const identity = getDataSourceIdentity(item);
+    if (!identity || !seen.has(identity)) {
+      merged.push(cloneJson(item));
+      if (identity) {
+        seen.add(identity);
+      }
+    }
+  });
+
+  return merged;
+}
+
+function mergePageDataSource(existingDataSource, generatedDataSource) {
+  if (!existingDataSource || typeof existingDataSource !== 'object') {
+    return cloneJson(generatedDataSource);
+  }
+
+  const existing = cloneJson(existingDataSource);
+  const generated = cloneJson(generatedDataSource || {});
+  const merged = Object.assign({}, generated, existing);
+
+  merged.offline = mergeDataSourceArray(existing.offline, generated.offline);
+  merged.online = mergeDataSourceArray(existing.online, generated.online);
+  merged.list = mergeDataSourceArray(existing.list, generated.list);
+  merged.globalConfig = Object.assign(
+    {},
+    generated.globalConfig || {},
+    existing.globalConfig || {}
+  );
+  merged.sync = existing.sync !== undefined ? existing.sync : generated.sync;
+
+  return merged;
+}
+
+function extractSchemaContent(schemaResult) {
+  if (!schemaResult) {
+    return null;
+  }
+
+  let content = schemaResult.content !== undefined ? schemaResult.content : schemaResult;
+  if (typeof content === 'string') {
+    try {
+      content = JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  if (content && typeof content === 'object' && content.pages) {
+    return content;
+  }
+  if (schemaResult.pages) {
+    return schemaResult;
+  }
+  return null;
+}
+
+function extractPageDataSource(schema) {
+  if (!schema || !Array.isArray(schema.pages)) {
+    return null;
+  }
+
+  function findPageDataSource(node) {
+    if (!node || typeof node !== 'object') {
+      return null;
+    }
+    if (node.componentName === 'Page' && node.dataSource) {
+      return node.dataSource;
+    }
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (const child of children) {
+      const dataSource = findPageDataSource(child);
+      if (dataSource) {
+        return dataSource;
+      }
+    }
+    return null;
+  }
+
+  for (const page of schema.pages) {
+    const tree = page && Array.isArray(page.componentsTree) ? page.componentsTree : [];
+    for (const component of tree) {
+      const dataSource = findPageDataSource(component);
+      if (dataSource) {
+        return dataSource;
+      }
+    }
+  }
+  return null;
+}
+
+function countCustomPageDataSources(dataSource) {
+  if (!dataSource || typeof dataSource !== 'object') {
+    return 0;
+  }
+
+  const identities = new Set();
+  ['offline', 'online', 'list'].forEach((key) => {
+    (Array.isArray(dataSource[key]) ? dataSource[key] : []).forEach((item) => {
+      if (!isBuiltInPageDataSource(item)) {
+        const identity = getDataSourceIdentity(item);
+        if (identity) {
+          identities.add(identity);
+        }
+      }
+    });
+  });
+  return identities.size;
+}
+
+function buildNativePageSchemaContent(sourceCode, compiledCode, formUuid, options = {}) {
+  const onBuildingSchema = normalizeOptionalCallback(options.onBuildingSchema, 'onBuildingSchema');
+  const onFormulaPrefixFixed = normalizeOptionalCallback(
+    options.onFormulaPrefixFixed,
+    'onFormulaPrefixFixed'
+  );
+  onBuildingSchema();
+
+  const sourceFix = stripSubtableFieldPrefix(sourceCode);
+  const compiledFix = stripSubtableFieldPrefix(compiledCode);
+  sourceCode = sourceFix.value;
+  compiledCode = compiledFix.value;
+  const fixedRefs = sourceFix.count + compiledFix.count;
+  if (fixedRefs > 0) {
+    onFormulaPrefixFixed(fixedRefs);
+  }
+
+  const nextNodeId = resolveSchemaBuilderDependency(
+    options.nextNodeId,
+    createNodeIdGenerator,
+    'nextNodeId'
+  );
+  const nextSuffix = resolveSchemaBuilderDependency(
+    options.nextSuffix,
+    () => generateSuffix,
+    'nextSuffix'
+  );
+  const constructorCode = "function constructor() {\nvar module = { exports: {} };\nvar _this = this;\nthis.__initMethods__(module.exports, module);\nObject.keys(module.exports).forEach(function(item) {\n  if(typeof module.exports[item] === 'function'){\n    _this[item] = module.exports[item];\n  }\n});\n\n}";
+  const pageDataSource = mergePageDataSource(
+    options.existingDataSource,
+    buildDefaultPageDataSource(formUuid)
+  );
+
+  const schema = {
+    schemaType: 'superform',
+    schemaVersion: '5.0',
+    pages: [
+      {
+        utils: [
+          {
+            name: 'legaoBuiltin',
+            type: 'npm',
+            content: {
+              package: '@ali/vu-legao-builtin',
+              version: '3.0.0',
+              exportName: 'legaoBuiltin',
+            },
+          },
+          {
+            name: 'yidaPlugin',
+            type: 'npm',
+            content: {
+              package: '@ali/vu-yida-plugin',
+              version: '1.1.0',
+              exportName: 'yidaPlugin',
+            },
+          },
+        ],
+        componentsMap: [
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootHeader' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'Jsx' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootContent' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootFooter' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'Page' },
+        ],
+        componentsTree: [
+          {
+            componentName: 'Page',
+            id: nextNodeId(),
+            props: {
+              contentBgColor: 'white',
+              pageStyle: { backgroundColor: '#f2f3f5' },
+              contentMargin: '0',
+              contentPadding: '0',
+              showTitle: false,
+              contentPaddingMobile: '0',
+              templateVersion: '1.0.0',
+              contentMarginMobile: '0',
+              className: 'page_' + nextSuffix(),
+              contentBgColorMobile: 'white',
+            },
+            condition: true,
+            css: 'body{background-color:#f2f3f5}.vc-page-yida-page{--yida-form-content-padding:0;--yida-form-content-margin:0;--yida-layout-padding:0}.vc-deep-container-entry.vc-rootcontent{padding:0!important;margin-top:0!important;margin-right:0!important;margin-bottom:0!important;margin-left:0!important}',
+            methods: {
+              __initMethods__: {
+                type: 'js',
+                source: 'function (exports, module) { /*set actions code here*/ }',
+                compiled: 'function (exports, module) { /*set actions code here*/ }',
+              },
+            },
+            dataSource: pageDataSource,
+            lifeCycles: {
+              constructor: {
+                type: 'js',
+                compiled: constructorCode,
+                source: constructorCode,
+              },
+              componentWillUnmount: {
+                name: 'didUnmount',
+                id: 'didUnmount',
+                type: 'actionRef',
+                params: {},
+              },
+              componentDidMount: {
+                name: 'didMount',
+                id: 'didMount',
+                params: {},
+                type: 'actionRef',
+              },
+            },
+            hidden: false,
+            title: '',
+            isLocked: false,
+            conditionGroup: '',
+            children: [
+              {
+                componentName: 'RootHeader',
+                id: nextNodeId(),
+                props: {},
+                condition: true,
+                hidden: false,
+                title: '',
+                isLocked: false,
+                conditionGroup: '',
+              },
+              {
+                componentName: 'RootContent',
+                id: nextNodeId(),
+                props: {},
+                condition: true,
+                hidden: false,
+                title: '',
+                isLocked: false,
+                conditionGroup: '',
+                children: [
+                  {
+                    componentName: 'Jsx',
+                    id: nextNodeId(),
+                    props: {
+                      render: {
+                        type: 'js',
+                        compiled: 'function main(){\n    \n    "use strict";\n\nvar __compiledFunc__ = function render() {\n  return this.renderJsx();\n};\n    return __compiledFunc__.apply(this, arguments);\n  }',
+                        source: 'function render() {\n  return this.renderJsx();\n}',
+                        error: {},
+                      },
+                      __style__: {},
+                      fieldId: 'jsx_' + nextSuffix(),
+                    },
+                    condition: true,
+                    hidden: false,
+                    title: '',
+                    isLocked: false,
+                    conditionGroup: '',
+                  },
+                ],
+              },
+              {
+                componentName: 'RootFooter',
+                id: nextNodeId(),
+                props: {},
+                condition: true,
+                hidden: false,
+                title: '',
+                isLocked: false,
+                conditionGroup: '',
+              },
+            ],
+          },
+        ],
+        id: formUuid,
+        connectComponent: [],
+      },
+    ],
+    actions: {
+      module: {
+        compiled: compiledCode,
+        source: sourceCode,
+      },
+      type: 'FUNCTION',
+      list: [
+        { id: 'getCustomState', title: 'getCustomState' },
+        { id: 'setCustomState', title: 'setCustomState' },
+        { id: 'forceUpdate', title: 'forceUpdate' },
+        { id: 'didMount', title: 'didMount' },
+        { id: 'didUnmount', title: 'didUnmount' },
+        { id: 'renderJsx', title: 'renderJsx' },
+      ],
+    },
+    config: {
+      connectComponent: [],
+    },
+  };
+
+  return JSON.stringify(schema);
+}
+
+function normalizeOptionalCallback(value, property) {
+  if (value === undefined) {
+    return () => {};
+  }
+  if (typeof value !== 'function') {
+    throw new TypeError(`buildNativePageSchemaContent ${property} must be a function`);
+  }
+  return value;
+}
+
+function resolveSchemaBuilderDependency(value, createDefault, property) {
+  if (value === undefined) {
+    return createDefault();
+  }
+  if (typeof value !== 'function') {
+    throw new TypeError(`buildSchemaContent ${property} must be a function`);
+  }
+  return value;
+}
+
+module.exports = Object.freeze({
+  buildDefaultPageDataSource,
+  buildNativePageSchemaContent,
+  countCustomPageDataSources,
+  createNodeIdGenerator,
+  extractPageDataSource,
+  extractSchemaContent,
+  generateSuffix,
+  getGlobalDataSourceFitConfig,
+  mergePageDataSource,
+});

package/lib/app/services/page-resource-service.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const querystring = require('querystring');
+const { schemaError } = require('../../schema/errors');
+const { normalizeFormNavigationNode } = require('../form-navigation');
+const { buildYidaI18n } = require('../../core/yida-i18n');
+const { httpGet, httpPost } = require('../../core/utils');
+const { isTokenAuthRef } = require('../../core/yida-client');
+const {
+  createServerRevisionConflict,
+  isSaveFormSchemaRevisionConflict,
+  requireSchemaServerRevision,
+} = require('../../schema/server-revision');
+const { dispatchRemotePrimitive } = require('../../schema/remote-dispatch-boundary');
+
+function assertPageWriteReady(context = {}) {
+  const auth = resolveAuth(context);
+  if (!auth || typeof auth.baseUrl !== 'string' || !auth.baseUrl) {
+    pageServiceError('SCHEMA_PAGE_WRITE_PRECHECK_FAILED', 'Page write authentication is not ready.');
+  }
+  if (isTokenAuthRef(auth)) {
+    return true;
+  }
+  if (!auth.cookies || typeof auth.csrfToken !== 'string' || !auth.csrfToken) {
+    pageServiceError('SCHEMA_PAGE_WRITE_PRECHECK_FAILED', 'Page write authentication is not ready.');
+  }
+  return true;
+}
+
+async function createPageShellOnce(context, input = {}) {
+  const auth = requireWriteAuth(context);
+  const request = resolveService(context, 'httpPost', httpPost);
+  const result = await dispatchRemotePrimitive(context, () => request(
+    auth.baseUrl,
+    `/dingtalk/web/${input.appType}/query/formdesign/saveFormSchemaInfo.json`,
+    querystring.stringify({
+      _csrf_token: auth.csrfToken,
+      formType: 'display',
+      title: JSON.stringify(buildYidaI18n(input.title, {
+        en_US: input.title,
+        ja_JP: input.title,
+      })),
+    }),
+    auth.cookies
+  ));
+  if (!result || result.success !== true || result.__needLogin || result.__csrfExpired) {
+    pageServiceError('SCHEMA_PAGE_CREATE_FAILED', 'Page create request did not return a confirmed identity.');
+  }
+  const formUuid = result.content && result.content.formUuid || result.content;
+  if (typeof formUuid !== 'string' || !formUuid) {
+    pageServiceError('SCHEMA_PAGE_CREATE_FAILED', 'Page create request did not return a confirmed identity.');
+  }
+  return { appType: input.appType, formUuid };
+}
+
+async function readPageResource(context, input = {}) {
+  const auth = requireReadAuth(context);
+  const request = resolveService(context, 'httpGet', httpGet);
+  const schemaResult = await dispatchRemotePrimitive(context, () => request(
+    auth.baseUrl,
+    `/alibaba/web/${input.appType}/_view/query/formdesign/getFormSchema.json`,
+    { formUuid: input.formUuid, schemaVersion: 'V5' },
+    auth.cookies
+  ));
+  if (
+    !schemaResult ||
+    schemaResult.success === false ||
+    schemaResult.__needLogin ||
+    schemaResult.__csrfExpired ||
+    !hasSchemaContent(schemaResult.content)
+  ) {
+    pageServiceError('SCHEMA_PAGE_READ_FAILED', 'Bound page Schema could not be read.');
+  }
+
+  const navigationResult = await dispatchRemotePrimitive(context, () => request(
+    auth.baseUrl,
+    `/dingtalk/web/${input.appType}/query/formnav/getFormNavigationListByOrder.json`,
+    { _api: 'Nav.queryList', _mock: false },
+    auth.cookies
+  ));
+  if (
+    !navigationResult ||
+    navigationResult.success === false ||
+    navigationResult.__needLogin ||
+    navigationResult.__csrfExpired ||
+    !Array.isArray(navigationResult.content)
+  ) {
+    pageServiceError('SCHEMA_PAGE_READ_FAILED', 'Bound page identity could not be read.');
+  }
+  const matches = navigationResult.content
+    .map(normalizeFormNavigationNode)
+    .filter(Boolean)
+    .filter(item => item.formUuid === input.formUuid);
+  if (matches.length !== 1) {
+    pageServiceError('SCHEMA_PAGE_READ_FAILED', 'Bound page identity is missing or ambiguous.');
+  }
+  return {
+    appType: input.appType,
+    formUuid: input.formUuid,
+    observedFormType: matches[0].formType,
+    observedTitle: matches[0].formName,
+    schema: schemaResult.content,
+    serverRevision: requireSchemaServerRevision(schemaResult, () => pageReadError()),
+  };
+}
+
+async function savePageSchemaOnce(context, input = {}) {
+  const auth = requireWriteAuth(context);
+  const request = resolveService(context, 'httpPost', httpPost);
+  const result = await dispatchRemotePrimitive(context, () => request(
+    auth.baseUrl,
+    `/alibaba/web/${input.appType}/_view/query/formdesign/saveFormSchema.json`,
+    querystring.stringify({
+      _csrf_token: auth.csrfToken,
+      appType: input.appType,
+      content: JSON.stringify(input.schema),
+      formUuid: input.formUuid,
+      gmtModified: requireSchemaServerRevision(
+        { gmtModified: input.serverRevision },
+        () => pageServiceError('SCHEMA_PAGE_WRITE_PRECHECK_FAILED', 'Page Schema revision is missing or invalid.')
+      ),
+      prefix: '_view',
+      schemaVersion: 'V5',
+    }),
+    auth.cookies
+  ));
+  if (isSaveFormSchemaRevisionConflict(result)) {
+    throw createServerRevisionConflict('page');
+  }
+  if (!result || result.success !== true || result.__needLogin || result.__csrfExpired) {
+    pageServiceError('SCHEMA_PAGE_SAVE_FAILED', 'Page Schema save did not return an explicit success response.');
+  }
+  return { success: true };
+}
+
+function pageReadError() {
+  return schemaError('SCHEMA_PAGE_READ_FAILED', 'Bound page Schema revision is missing or invalid.', {
+    details: { resourceType: 'page' },
+  });
+}
+
+function requireReadAuth(context) {
+  const auth = resolveAuth(context);
+  if (!auth || typeof auth.baseUrl !== 'string' || !auth.baseUrl) {
+    pageServiceError('SCHEMA_PAGE_READ_PRECHECK_FAILED', 'Page read authentication is not ready.');
+  }
+  if (isTokenAuthRef(auth)) {
+    return auth;
+  }
+  if (!auth.cookies) {
+    pageServiceError('SCHEMA_PAGE_READ_PRECHECK_FAILED', 'Page read authentication is not ready.');
+  }
+  return auth;
+}
+
+function requireWriteAuth(context) {
+  assertPageWriteReady(context);
+  return resolveAuth(context);
+}
+
+function resolveAuth(context) {
+  return context && context.authRef ? context.authRef : context;
+}
+
+function resolveService(context, name, fallback) {
+  return context && context.services && context.services[name] || fallback;
+}
+
+function hasSchemaContent(value) {
+  if (typeof value === 'string') {
+    return value.trim().length > 0;
+  }
+  return !!(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function pageServiceError(code, message) {
+  throw schemaError(code, message, { details: { resourceType: 'page' } });
+}
+
+module.exports = Object.freeze({
+  assertPageWriteReady,
+  createPageShellOnce,
+  readPageResource,
+  savePageSchemaOnce,
+});

package/lib/app/update-app.js

@@ -16,6 +16,10 @@ const { createAuthRef } = require('../core/yida-client');
 const { t } = require('../core/i18n');
 const { buildYidaI18n } = require('../core/yida-i18n');
 const { throwCommandError, throwUsage } = require('../core/command-errors');
+const {
+  assertLegacyDirectWriteAllowed,
+  extractLegacyGuardArgs,
+} = require('../core/legacy-schema-guard');
 const { assertPresetThemeKey } = require('./theme-presets');
 
 /**
@@ -218,7 +222,8 @@ async function fetchCurrentApp(appType, authRef) {
 }
 
 async function run(args) {
-  const params = parseArgs(args);
+  const guardSplit = extractLegacyGuardArgs(args || []);
+  const params = parseArgs(guardSplit.args);
 
   // 验证必填参数
   const { c, banner, step, label, warn, success: chalkSuccess, result: chalkResult, error: chalkError } = require('../core/chalk');
@@ -235,6 +240,12 @@ async function run(args) {
     throwUsage(t('update_app.missing_update_field'), t('update_app.usage'));
   }
   assertPresetThemeKey(params.colour);
+  assertLegacyDirectWriteAllowed({
+    command: 'update-app',
+    resourceType: 'app',
+    action: 'update',
+    appType: params.appType,
+  }, { guardOptions: guardSplit.guardOptions });
 
   banner(t('update_app.title'));
   label('App', params.appType);
@@ -259,19 +270,20 @@ async function run(args) {
   }
 
   const currentApp = shellUpdate ? await fetchCurrentApp(params.appType, authRef) : null;
-  const postDataObj = shellUpdate
-    ? buildUpdateAppPostData(params, currentApp, authRef)
-    : buildUpdateAppNamePostData(params, authRef);
-  const postData = querystring.stringify(postDataObj);
   const requestPath = shellUpdate
     ? `/${params.appType}/query/app/updateApp.json?_api=Form.updateApp&_mock=false&_stamp=${Date.now()}`
     : `/query/app/updateAppName.json?_api=Form.updateAppName&_mock=false&_stamp=${Date.now()}`;
 
   const response = await requestWithAutoLogin((auth) => {
+    const postDataObj = shellUpdate
+      ? buildUpdateAppPostData(params, currentApp, auth)
+      : buildUpdateAppNamePostData(params, auth);
+    const postData = querystring.stringify(postDataObj);
     return httpPost(
       auth.baseUrl,
       requestPath,
-      postData
+      postData,
+      auth.cookies
     );
   }, authRef);