openyida 2026.7.18 → 2026.7.21

package/lib/app/services/form-mode-service.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { createYidaClient } = require('../../core/yida-client');
+const {
+  dispatchRemotePrimitive,
+  hasRemoteDispatchBoundary,
+} = require('../../schema/remote-dispatch-boundary');
+
+const MODE_READ_OPERATION = 'FormProcBinding.getBindingByFormUuid';
+const MODE_CONVERSION_OPERATION = 'Nav.transformForm';
+
+class FormModeServiceError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.name = 'FormModeServiceError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function queryFormProcessBinding(authRef, appType, formUuid, options = {}) {
+  const requestPath = '/' + appType + '/query/formProcBinding/getBindingByFormUuid.json';
+  const client = createYidaClient({ authRef });
+  const method = options.oneShot === true ? 'getOnce' : 'get';
+  return client[method](requestPath, auth => ({
+    _api: 'nattyFetch',
+    _mock: 'false',
+    _csrf_token: auth.csrfToken,
+    formUuid,
+    _stamp: Date.now(),
+  }));
+}
+
+function switchFormType(authRef, appType, formUuid, options = {}) {
+  const requestPath = '/' + appType + '/query/formdesign/switchFormType.json'
+    + '?_api=Nav.transformForm&_mock=false&_stamp=' + Date.now();
+  const client = createYidaClient({ authRef });
+  const method = options.oneShot === true ? 'postFormOnce' : 'postForm';
+  return client[method](requestPath, auth => ({
+    _csrf_token: auth.csrfToken,
+    _locale_time_zone_offset: '28800000',
+    toFormType: 'process',
+    formUuid,
+  }));
+}
+
+async function readFormMode(context, input) {
+  const authRef = context && context.authRef ? context.authRef : context;
+  const appType = input && input.appType;
+  const result = await dispatchRemotePrimitive(context, () => queryFormProcessBinding(
+    authRef,
+    appType,
+    input && input.formUuid,
+    { oneShot: hasRemoteDispatchBoundary(context) }
+  ));
+  const binding = normalizeFormProcessBinding(result, appType, input && input.formUuid);
+  if (!binding) {
+    throw modeError('FORM_MODE_READ_FAILED', MODE_READ_OPERATION, {
+      result: sanitizeModeResult(result),
+    });
+  }
+  if (binding.processCode) {
+    const observed = {
+      mode: 'process',
+      processCode: binding.processCode,
+    };
+    if (binding.processId) {
+      observed.processId = binding.processId;
+    }
+    return observed;
+  }
+  return { mode: 'receipt' };
+}
+
+async function convertFormToProcess(context, input) {
+  const authRef = context && context.authRef ? context.authRef : context;
+  const result = await dispatchRemotePrimitive(context, () => switchFormType(
+    authRef,
+    input && input.appType,
+    input && input.formUuid,
+    { oneShot: hasRemoteDispatchBoundary(context) }
+  ));
+  if (!result || result.success !== true) {
+    throw modeError('FORM_MODE_CONVERSION_FAILED', MODE_CONVERSION_OPERATION);
+  }
+  return result;
+}
+
+async function getProcessCodeFromAppParam(authRef, appType, formUuid) {
+  // Keep the legacy helper name for callers; the implementation now uses the exact form binding endpoint.
+  return getProcessCodeFromFormBinding(authRef, appType, formUuid);
+}
+
+async function getProcessCodeFromFormBinding(authRef, appType, formUuid) {
+  const result = await queryFormProcessBinding(authRef, appType, formUuid);
+  const binding = normalizeFormProcessBinding(result, appType, formUuid);
+  return binding && binding.processCode || null;
+}
+
+function normalizeFormProcessBinding(result, expectedAppType, expectedFormUuid) {
+  const content = result && result.success === true && result.content;
+  if (!content || typeof content !== 'object' || Array.isArray(content)) {
+    return null;
+  }
+  if (
+    isNonEmptyString(content.appType) &&
+    content.appType !== expectedAppType
+  ) {
+    return null;
+  }
+  if (
+    isNonEmptyString(content.formUuid) &&
+    content.formUuid !== expectedFormUuid
+  ) {
+    return null;
+  }
+  if (!Object.prototype.hasOwnProperty.call(content, 'procCode')) {
+    return { processCode: '' };
+  }
+  if (typeof content.procCode !== 'string') {
+    return null;
+  }
+  const processId = normalizeIdentifier(content.procId);
+  return {
+    processCode: content.procCode.trim(),
+    ...(processId ? { processId } : {}),
+  };
+}
+
+function normalizeIdentifier(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return String(value);
+  }
+  return isNonEmptyString(value) ? value.trim() : null;
+}
+
+function modeError(code, operation, details = {}) {
+  return new FormModeServiceError(code, 'Form mode operation failed.', {
+    operation,
+    ...details,
+  });
+}
+
+function sanitizeModeResult(result) {
+  if (!result || typeof result !== 'object') {
+    return result || null;
+  }
+  const sanitized = {};
+  [
+    'success',
+    'errorMsg',
+    'errorCode',
+    'code',
+    'message',
+    '__httpStatus',
+    '__needLogin',
+    '__csrfExpired',
+    '__nonJsonResponse',
+    '__emptyBody',
+  ].forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(result, key)) {
+      sanitized[key] = result[key];
+    }
+  });
+  return sanitized;
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}
+
+module.exports = {
+  FormModeServiceError,
+  MODE_CONVERSION_OPERATION,
+  MODE_READ_OPERATION,
+  convertFormToProcess,
+  getProcessCodeFromAppParam,
+  getProcessCodeFromFormBinding,
+  queryFormProcessBinding,
+  readFormMode,
+  switchFormType,
+};

package/lib/app/services/form-schema-patcher.js

@@ -0,0 +1,333 @@
+'use strict';
+
+const { createFormServiceError } = require('./form-schema-reader');
+
+const MANAGED_PROP_KEYS = Object.freeze([
+  'associationForm',
+  'dataSource',
+  'defaultDataSource',
+  'label',
+  'required',
+  'validation',
+]);
+
+function patchManagedFormSchema(currentSchemaResult, compiled, options = {}) {
+  const schema = clonePlain(extractSchema(currentSchemaResult));
+  const compiledSchema = compiled && compiled.schema || {};
+  const currentContainer = findFirstComponent(schema, 'FormContainer');
+  const compiledContainer = findFirstComponent(compiledSchema, 'FormContainer');
+  if (!currentContainer || !compiledContainer) {
+    throw createFormServiceError(
+      'form Schema does not contain FormContainer',
+      'FORM_SCHEMA_PATCH_INVALID'
+    );
+  }
+
+  const existingBindings = normalizeFieldBindings(options.existingBindings);
+  const desiredBindings = normalizeFieldBindings(compiled && compiled.fieldBindings);
+  const removedSemanticPath = Object.keys(existingBindings).find(semanticPath => !desiredBindings[semanticPath]);
+  if (removedSemanticPath) {
+    throw createFormServiceError(
+      'managed field removal is not supported',
+      'FORM_SCHEMA_DESTRUCTIVE_CHANGE_UNSUPPORTED',
+      { semanticPath: removedSemanticPath, operation: 'remove' }
+    );
+  }
+
+  const currentByFieldId = indexComponentsByFieldId(schema);
+  const compiledByFieldId = indexComponentsByFieldId(compiledSchema);
+  patchFormTitle(currentContainer, compiledContainer);
+
+  for (const semanticPath of Object.keys(desiredBindings).sort(compareCodePoints)) {
+    const fieldId = desiredBindings[semanticPath].fieldId;
+    const desiredComponent = compiledByFieldId.get(fieldId);
+    if (!desiredComponent) {
+      throw createFormServiceError(
+        'compiled field binding was not found in generated Schema',
+        'FORM_SCHEMA_PATCH_INVALID',
+        { semanticPath }
+      );
+    }
+
+    const currentComponent = currentByFieldId.get(fieldId);
+    if (currentComponent) {
+      if (currentComponent.componentName !== desiredComponent.componentName) {
+        throw createFormServiceError(
+          'managed field type replacement is not supported',
+          'FORM_SCHEMA_DESTRUCTIVE_CHANGE_UNSUPPORTED',
+          { semanticPath, operation: 'replace_type' }
+        );
+      }
+      assertSafeManagedPropChanges(currentComponent, desiredComponent, semanticPath);
+      patchManagedProps(currentComponent, desiredComponent);
+      continue;
+    }
+
+    if (existingBindings[semanticPath]) {
+      throw createFormServiceError(
+        'managed field is missing from current Schema',
+        'FORM_SCHEMA_DESTRUCTIVE_CHANGE_UNSUPPORTED',
+        { semanticPath, operation: 'managed_missing' }
+      );
+    }
+
+    const parentPath = parentSemanticPath(semanticPath);
+    const parent = parentPath
+      ? currentByFieldId.get(desiredBindings[parentPath] && desiredBindings[parentPath].fieldId)
+      : currentContainer;
+    if (!parent) {
+      throw createFormServiceError(
+        'managed field parent was not found in current Schema',
+        'FORM_SCHEMA_PATCH_INVALID',
+        { semanticPath }
+      );
+    }
+    if (!Array.isArray(parent.children)) {
+      parent.children = [];
+    }
+    const added = clonePlain(desiredComponent);
+    parent.children.push(added);
+    indexComponentTree(added, currentByFieldId);
+  }
+
+  mergeComponentsMap(schema, compiledSchema);
+  mergeComponentAliases(schema, compiledSchema, currentByFieldId);
+  return schema;
+}
+
+function extractSchema(schemaResult) {
+  let value = schemaResult && Object.prototype.hasOwnProperty.call(schemaResult, 'content')
+    ? schemaResult.content
+    : schemaResult;
+  if (typeof value === 'string') {
+    try {
+      value = JSON.parse(value);
+    } catch (error) {
+      throw createFormServiceError('form Schema content is not valid JSON', 'FORM_SCHEMA_PATCH_INVALID');
+    }
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw createFormServiceError('form Schema content must be an object', 'FORM_SCHEMA_PATCH_INVALID');
+  }
+  return value;
+}
+
+function patchFormTitle(currentContainer, compiledContainer) {
+  currentContainer.props = currentContainer.props || {};
+  const compiledProps = compiledContainer.props || {};
+  if (Object.prototype.hasOwnProperty.call(compiledProps, 'formLabel')) {
+    currentContainer.props.formLabel = clonePlain(compiledProps.formLabel);
+  }
+}
+
+function patchManagedProps(currentComponent, desiredComponent) {
+  currentComponent.props = currentComponent.props || {};
+  const desiredProps = desiredComponent.props || {};
+  for (const key of MANAGED_PROP_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(desiredProps, key)) {
+      currentComponent.props[key] = clonePlain(desiredProps[key]);
+    }
+  }
+}
+
+function assertSafeManagedPropChanges(currentComponent, desiredComponent, semanticPath) {
+  const currentProps = currentComponent.props || {};
+  const desiredProps = desiredComponent.props || {};
+  const currentOptionValues = extractOptionValues(currentProps);
+  const desiredOptionValues = new Set(extractOptionValues(desiredProps));
+  if (currentOptionValues.some(value => !desiredOptionValues.has(value))) {
+    throw createFormServiceError(
+      'managed option value deletion or rename is not supported',
+      'FORM_SCHEMA_DESTRUCTIVE_CHANGE_UNSUPPORTED',
+      { semanticPath, operation: 'remove_option_value' }
+    );
+  }
+  if (
+    (currentProps.associationForm || desiredProps.associationForm) &&
+    !sameAssociationTarget(currentProps.associationForm, desiredProps.associationForm)
+  ) {
+    throw createFormServiceError(
+      'managed association target replacement is not supported',
+      'FORM_SCHEMA_DESTRUCTIVE_CHANGE_UNSUPPORTED',
+      { semanticPath, operation: 'replace_association' }
+    );
+  }
+}
+
+function extractOptionValues(props) {
+  const options = Array.isArray(props && props.dataSource)
+    ? props.dataSource
+    : props && props.defaultDataSource && Array.isArray(props.defaultDataSource.options)
+      ? props.defaultDataSource.options
+      : [];
+  return options.map((option) => {
+    if (option && typeof option === 'object') {
+      const value = option.value !== undefined
+        ? option.value
+        : option.text !== undefined
+          ? option.text
+          : option.label;
+      return String(value === undefined ? '' : value);
+    }
+    return String(option);
+  });
+}
+
+function sameAssociationTarget(left, right) {
+  const normalize = value => ({
+    appType: String(value && value.appType || ''),
+    formUuid: String(value && value.formUuid || ''),
+  });
+  const leftTarget = normalize(left);
+  const rightTarget = normalize(right);
+  return leftTarget.appType === rightTarget.appType &&
+    leftTarget.formUuid === rightTarget.formUuid;
+}
+
+function normalizeFieldBindings(bindings) {
+  const source = bindings && bindings.fieldBindings || bindings && bindings.fields || bindings || {};
+  const result = {};
+  const usedFieldIds = new Set();
+  for (const semanticPath of Object.keys(source)) {
+    const value = source[semanticPath];
+    const fieldId = typeof value === 'string'
+      ? value
+      : value && (value.fieldId || value.id || value.value);
+    if (fieldId) {
+      const normalizedFieldId = String(fieldId);
+      if (usedFieldIds.has(normalizedFieldId)) {
+        throw createFormServiceError(
+          'field bindings contain a duplicate fieldId',
+          'FORM_SCHEMA_PATCH_INVALID',
+          { semanticPath }
+        );
+      }
+      usedFieldIds.add(normalizedFieldId);
+      result[semanticPath] = { fieldId: normalizedFieldId };
+    }
+  }
+  return result;
+}
+
+function indexComponentsByFieldId(schema) {
+  const result = new Map();
+  visitSchemaComponents(schema, node => indexComponent(node, result));
+  return result;
+}
+
+function indexComponentTree(node, index) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+  indexComponent(node, index);
+  if (Array.isArray(node.children)) {
+    node.children.forEach(child => indexComponentTree(child, index));
+  }
+}
+
+function indexComponent(node, index) {
+  const fieldId = node && node.props && node.props.fieldId;
+  if (!fieldId) {
+    return;
+  }
+  const normalizedFieldId = String(fieldId);
+  if (index.has(normalizedFieldId)) {
+    throw createFormServiceError(
+      'form Schema contains a duplicate fieldId',
+      'FORM_SCHEMA_PATCH_INVALID'
+    );
+  }
+  index.set(normalizedFieldId, node);
+}
+
+function findFirstComponent(schema, componentName) {
+  let found = null;
+  visitSchemaComponents(schema, (node) => {
+    if (!found && node.componentName === componentName) {
+      found = node;
+    }
+  });
+  return found;
+}
+
+function visitSchemaComponents(schema, visitor) {
+  const pages = schema && schema.pages;
+  if (!Array.isArray(pages)) {
+    return;
+  }
+  function visit(node) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+    visitor(node);
+    if (Array.isArray(node.children)) {
+      node.children.forEach(visit);
+    }
+  }
+  pages.forEach((page) => {
+    const roots = page && Array.isArray(page.componentsTree) ? page.componentsTree : [];
+    roots.forEach(visit);
+  });
+}
+
+function mergeComponentsMap(schema, compiledSchema) {
+  const currentPage = schema && Array.isArray(schema.pages) && schema.pages[0];
+  const compiledPage = compiledSchema && Array.isArray(compiledSchema.pages) && compiledSchema.pages[0];
+  if (!currentPage || !compiledPage || !Array.isArray(compiledPage.componentsMap)) {
+    return;
+  }
+  const current = Array.isArray(currentPage.componentsMap) ? currentPage.componentsMap : [];
+  const names = new Set(current.map(item => item && item.componentName).filter(Boolean));
+  for (const item of compiledPage.componentsMap) {
+    if (item && item.componentName && !names.has(item.componentName)) {
+      current.push(clonePlain(item));
+      names.add(item.componentName);
+    }
+  }
+  currentPage.componentsMap = current;
+}
+
+function mergeComponentAliases(schema, compiledSchema, currentByFieldId) {
+  const currentPage = schema && Array.isArray(schema.pages) && schema.pages[0];
+  const compiledPage = compiledSchema && Array.isArray(compiledSchema.pages) && compiledSchema.pages[0];
+  const compiledItems = compiledPage && compiledPage.componentAlias && compiledPage.componentAlias.items;
+  if (!currentPage || !Array.isArray(compiledItems)) {
+    return;
+  }
+  const currentAlias = currentPage.componentAlias && typeof currentPage.componentAlias === 'object'
+    ? currentPage.componentAlias
+    : { items: [] };
+  const items = Array.isArray(currentAlias.items) ? currentAlias.items : [];
+  const fieldIds = new Set(items.map(item => item && item.fieldId).filter(Boolean));
+  for (const item of compiledItems) {
+    if (
+      item &&
+      item.fieldId &&
+      currentByFieldId.has(String(item.fieldId)) &&
+      !fieldIds.has(item.fieldId)
+    ) {
+      items.push(clonePlain(item));
+      fieldIds.add(item.fieldId);
+    }
+  }
+  currentAlias.items = items;
+  currentPage.componentAlias = currentAlias;
+}
+
+function parentSemanticPath(semanticPath) {
+  const separator = String(semanticPath).lastIndexOf('.');
+  return separator === -1 ? '' : String(semanticPath).slice(0, separator);
+}
+
+function clonePlain(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function compareCodePoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+module.exports = {
+  MANAGED_PROP_KEYS,
+  patchManagedFormSchema,
+};

package/lib/app/services/form-schema-reader.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { httpGet, requestWithAutoLogin } = require('../../core/utils');
+const { requireSchemaServerRevision } = require('../../schema/server-revision');
+const {
+  dispatchRemotePrimitive,
+  hasRemoteDispatchBoundary,
+} = require('../../schema/remote-dispatch-boundary');
+
+function resolveAuthRef(context) {
+  return context && context.authRef ? context.authRef : context;
+}
+
+function createFormServiceError(message, code, details) {
+  const error = new Error(message);
+  error.code = code || 'FORM_SERVICE_FAILED';
+  if (details) {
+    error.details = details;
+  }
+  return error;
+}
+
+function assertSuccess(result, code, details) {
+  if (result && result.success !== false && !result.__needLogin && !result.__csrfExpired) {
+    return result;
+  }
+  const message = result ? result.errorMsg || 'request failed' : 'request failed';
+  throw createFormServiceError(message, code, Object.assign({ result }, details));
+}
+
+async function readFormSchema(context, input) {
+  const authRef = resolveAuthRef(context);
+  const services = context && context.services || {};
+  const requestWithAutoLoginImpl = services.requestWithAutoLogin || requestWithAutoLogin;
+  const httpGetImpl = services.httpGet || httpGet;
+  const appType = input && input.appType;
+  const formUuid = input && input.formUuid;
+  const send = auth => httpGetImpl(
+    auth.baseUrl,
+    `/alibaba/web/${appType}/_view/query/formdesign/getFormSchema.json`,
+    { formUuid, schemaVersion: input && input.schemaVersion || 'V5' },
+    auth.cookies
+  );
+  const result = hasRemoteDispatchBoundary(context)
+    ? await dispatchRemotePrimitive(context, () => send(authRef))
+    : await requestWithAutoLoginImpl(send, authRef);
+  const schemaResult = assertSuccess(result, 'FORM_SCHEMA_READ_FAILED', { appType, formUuid });
+  requireSchemaServerRevision(schemaResult, () => createFormServiceError(
+    'remote Schema revision is missing or invalid',
+    'FORM_SCHEMA_READ_FAILED',
+    { appType, formUuid }
+  ));
+  return schemaResult;
+}
+
+module.exports = {
+  readFormSchema,
+  createFormServiceError,
+};