openyida 2026.7.19 → 2026.7.21

package/lib/app/schema-field-resolution.js

@@ -0,0 +1,370 @@
+/**
+ * 将 getFormSchema 的完整返回正规化为安全、确定性的字段解析契约。
+ * 本模块无网络、文件或进程状态依赖，不承担跨调用缓存。
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+const CONTRACT_KIND = 'yida_schema_field_resolution';
+const CONTRACT_VERSION = 1;
+const LABEL_LOCALES = [
+  'zh_CN',
+  'zh_HK',
+  'en_US',
+  'ja_JP',
+  'ko_KR',
+  'fr_FR',
+  'de_DE',
+  'es_ES',
+  'pt_PT',
+  'ar_SA',
+  'hi_IN',
+  'vi_VN',
+];
+const LOCALE_KEY_PATTERN = /^[a-z]{2}(?:[_-][A-Z]{2})?$/;
+
+function normalizeText(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (!['string', 'number', 'boolean'].includes(typeof value)) {
+    return '';
+  }
+  return String(value).normalize('NFC').trim();
+}
+
+function collectLocalizedLabels(value, fallback) {
+  const entries = [];
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const knownLocales = LABEL_LOCALES.filter(locale => (
+      Object.prototype.hasOwnProperty.call(value, locale)
+    ));
+    const extraLocales = Object.keys(value)
+      .filter(locale => !LABEL_LOCALES.includes(locale) && LOCALE_KEY_PATTERN.test(locale))
+      .sort();
+    knownLocales.concat(extraLocales).forEach((locale) => {
+      const label = normalizeText(value[locale]);
+      if (label) {
+        entries.push({ locale, label });
+      }
+    });
+  } else {
+    const label = normalizeText(value);
+    if (label) {
+      entries.push({ locale: null, label });
+    }
+  }
+
+  if (entries.length === 0) {
+    entries.push({ locale: null, label: normalizeText(fallback) });
+  }
+  return {
+    label: entries[0].label,
+    entries,
+  };
+}
+
+function normalizeLabel(value, fallback) {
+  return collectLocalizedLabels(value, fallback).label;
+}
+
+function normalizeValueType(value) {
+  const normalized = typeof value === 'string' ? normalizeText(value) : '';
+  return normalized || null;
+}
+
+function stableCopy(value) {
+  if (Array.isArray(value)) {
+    return value.map(stableCopy);
+  }
+  if (value && typeof value === 'object') {
+    const result = {};
+    Object.keys(value).sort().forEach((key) => {
+      if (value[key] !== undefined) {
+        result[key] = stableCopy(value[key]);
+      }
+    });
+    return result;
+  }
+  return value;
+}
+
+function createSchemaHash(schemaResult) {
+  let content = schemaResult && Object.prototype.hasOwnProperty.call(schemaResult, 'content')
+    ? schemaResult.content
+    : null;
+  if (typeof content === 'string') {
+    try {
+      content = JSON.parse(content);
+    } catch (error) {
+      content = null;
+    }
+  }
+  if (content && typeof content === 'object' && !Array.isArray(content)) {
+    content = stableCopy(content);
+    delete content.gmtModified;
+  }
+  const serialized = JSON.stringify(stableCopy(content));
+  const digest = crypto
+    .createHash('sha256')
+    .update(serialized === undefined ? 'null' : serialized)
+    .digest('hex');
+  return `sha256:${digest}`;
+}
+
+function buildAliasByFieldId(schemaResult) {
+  const aliases = {};
+  const pages = schemaResult && schemaResult.content && schemaResult.content.pages;
+  if (!Array.isArray(pages)) {
+    return aliases;
+  }
+  pages.forEach((page) => {
+    const items = page && page.componentAlias && Array.isArray(page.componentAlias.items)
+      ? page.componentAlias.items
+      : [];
+    items.forEach((item) => {
+      const fieldId = item && item.fieldId ? normalizeText(item.fieldId) : '';
+      const alias = item && item.alias ? normalizeText(item.alias) : '';
+      if (fieldId && alias) {
+        aliases[fieldId] = alias;
+      }
+    });
+  });
+  return aliases;
+}
+
+function buildLabelPathSelectors(tableAncestors, labelInfo) {
+  const labelNodes = tableAncestors.map(item => item.labelInfo).concat(labelInfo);
+  const selectors = [];
+  const seen = new Set();
+
+  function append(locale, labels) {
+    const value = labels.join('/');
+    if (!seen.has(value)) {
+      seen.add(value);
+      selectors.push({ locale, value });
+    }
+  }
+
+  append(null, labelNodes.map(item => item.label));
+  const discoveredLocales = new Set();
+  labelNodes.forEach((item) => {
+    item.entries.forEach((entry) => {
+      if (entry.locale) {
+        discoveredLocales.add(entry.locale);
+      }
+    });
+  });
+  const orderedLocales = LABEL_LOCALES.filter(locale => discoveredLocales.has(locale))
+    .concat(Array.from(discoveredLocales)
+      .filter(locale => !LABEL_LOCALES.includes(locale))
+      .sort());
+  orderedLocales.forEach((locale) => {
+    append(locale, labelNodes.map((item) => {
+      const localized = item.entries.find(entry => entry.locale === locale);
+      return localized ? localized.label : item.label;
+    }));
+  });
+  return selectors;
+}
+
+function normalizeSchemaFields(schemaResult) {
+  const fields = [];
+  const pages = schemaResult && schemaResult.content && schemaResult.content.pages;
+  if (!Array.isArray(pages)) {
+    return fields;
+  }
+  const aliases = buildAliasByFieldId(schemaResult);
+
+  function traverse(node, tableAncestors) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+
+    const props = node.props && typeof node.props === 'object' ? node.props : {};
+    const fieldId = props.fieldId ? normalizeText(props.fieldId) : '';
+    const componentType = node.componentName ? normalizeText(node.componentName) : '';
+    let childTableAncestors = tableAncestors;
+
+    if (fieldId && componentType) {
+      const labelInfo = collectLocalizedLabels(props.label, fieldId);
+      const label = labelInfo.label;
+      const parentTable = tableAncestors.length > 0
+        ? tableAncestors[tableAncestors.length - 1]
+        : null;
+      fields.push({
+        label,
+        fieldId,
+        componentType,
+        valueType: normalizeValueType(props.valueType),
+        path: tableAncestors.map(item => item.fieldId).concat(fieldId),
+        labelPath: tableAncestors.map(item => item.label).concat(label),
+        parentFieldId: parentTable ? parentTable.fieldId : null,
+        alias: aliases[fieldId] || '',
+        localizedLabels: labelInfo.entries,
+        labelPathSelectors: buildLabelPathSelectors(tableAncestors, labelInfo),
+      });
+
+      if (componentType === 'TableField') {
+        childTableAncestors = tableAncestors.concat({ label, fieldId, labelInfo });
+      }
+    }
+
+    if (Array.isArray(node.children)) {
+      node.children.forEach(child => traverse(child, childTableAncestors));
+    }
+  }
+
+  pages.forEach((page) => {
+    const roots = page && Array.isArray(page.componentsTree) ? page.componentsTree : [];
+    roots.forEach(root => traverse(root, []));
+  });
+
+  return fields;
+}
+
+function normalizeQueries(queries) {
+  const result = [];
+  (Array.isArray(queries) ? queries : []).forEach((query) => {
+    const normalized = normalizeText(query);
+    if (normalized && !result.includes(normalized)) {
+      result.push(normalized);
+    }
+  });
+  return result;
+}
+
+function findExactMatches(fields, query) {
+  const normalizedQuery = normalizeText(query);
+  if (!normalizedQuery) {
+    return [];
+  }
+  const matchesByFieldId = new Map();
+
+  fields.forEach((field) => {
+    const matchedBy = [];
+    if (field.fieldId === normalizedQuery) {
+      matchedBy.push('fieldId');
+    }
+    if (field.alias && field.alias === normalizedQuery) {
+      matchedBy.push('alias');
+    }
+    if (field.path.length > 1 && field.path.join('/') === normalizedQuery) {
+      matchedBy.push('path');
+    }
+    (field.localizedLabels || []).forEach((entry) => {
+      if (entry.label === normalizedQuery) {
+        matchedBy.push(entry.locale ? `label:${entry.locale}` : 'label');
+      }
+    });
+    (field.labelPathSelectors || []).forEach((selector) => {
+      if (field.labelPath.length > 1 && selector.value === normalizedQuery) {
+        matchedBy.push(selector.locale ? `labelPath:${selector.locale}` : 'labelPath');
+      }
+    });
+
+    if (matchedBy.length === 0) {
+      return;
+    }
+    const existing = matchesByFieldId.get(field.fieldId);
+    if (existing) {
+      matchedBy.forEach((identity) => {
+        if (!existing.matchedBy.includes(identity)) {
+          existing.matchedBy.push(identity);
+        }
+      });
+    } else {
+      matchesByFieldId.set(field.fieldId, { field, matchedBy });
+    }
+  });
+
+  return Array.from(matchesByFieldId.values()).map(({ field, matchedBy }) => ({
+    ...field,
+    matchedBy,
+  }));
+}
+
+function publicField(field, query) {
+  const result = {
+    query: query === undefined ? null : query,
+    label: field.label,
+    fieldId: field.fieldId,
+    componentType: field.componentType,
+    valueType: field.valueType,
+    path: field.path.slice(),
+    labelPath: field.labelPath.slice(),
+    parentFieldId: field.parentFieldId,
+    alias: field.alias,
+  };
+  if (Array.isArray(field.matchedBy) && field.matchedBy.length > 0) {
+    result.matchedBy = field.matchedBy.slice();
+  }
+  return result;
+}
+
+function resolveFields(fields, queries) {
+  const normalizedQueries = normalizeQueries(queries);
+  if (normalizedQueries.length === 0) {
+    return {
+      fields: fields.map(field => publicField(field)),
+      missingFields: [],
+      ambiguousFields: [],
+    };
+  }
+
+  const resolution = {
+    fields: [],
+    missingFields: [],
+    ambiguousFields: [],
+  };
+
+  normalizedQueries.forEach((query) => {
+    const matches = findExactMatches(fields, query);
+    if (matches.length === 0) {
+      resolution.missingFields.push(query);
+    } else if (matches.length === 1) {
+      resolution.fields.push(publicField(matches[0], query));
+    } else {
+      resolution.ambiguousFields.push({
+        query,
+        reason: 'multiple_exact_matches',
+        matches: matches.map(field => publicField(field, query)),
+      });
+    }
+  });
+
+  return resolution;
+}
+
+function buildFieldResolution(appType, formUuid, schemaResult, queries) {
+  const normalizedFields = normalizeSchemaFields(schemaResult);
+  const resolution = resolveFields(normalizedFields, queries);
+  return {
+    kind: CONTRACT_KIND,
+    contractVersion: CONTRACT_VERSION,
+    resource: {
+      appType,
+      formUuid,
+      schemaHash: createSchemaHash(schemaResult),
+    },
+    ...resolution,
+  };
+}
+
+module.exports = {
+  CONTRACT_KIND,
+  CONTRACT_VERSION,
+  LABEL_LOCALES,
+  normalizeText,
+  collectLocalizedLabels,
+  normalizeLabel,
+  stableCopy,
+  createSchemaHash,
+  normalizeSchemaFields,
+  normalizeQueries,
+  findExactMatches,
+  resolveFields,
+  buildFieldResolution,
+};

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

@@ -0,0 +1,85 @@
+'use strict';
+
+const { createAuthRef, createYidaClient } = require('../../core/yida-client');
+const {
+  dispatchRemotePrimitive,
+  hasRemoteDispatchBoundary,
+} = require('../../schema/remote-dispatch-boundary');
+
+function resolveAuthRef(context) {
+  return context && context.authRef ? context.authRef : context;
+}
+
+function createAppReaderError(message, code, details) {
+  const error = new Error(message);
+  error.code = code || 'APP_READ_FAILED';
+  if (details) {
+    error.details = details;
+  }
+  return error;
+}
+
+async function readApp(context, input) {
+  const appType = input && input.appType;
+  if (!appType) {
+    throw createAppReaderError('appType is required', 'APP_READ_INVALID_ARGUMENTS');
+  }
+
+  const authRef = resolveAuthRef(context) || createAuthRef();
+  const result = await fetchAppDetail(authRef, appType, context);
+  const app = normalizeAppDetail(result, appType);
+
+  return {
+    appType,
+    appName: app.appName || app.name || '',
+    systemLink: app.systemLink || '',
+  };
+}
+
+function fetchAppDetail(authRef, appType, context) {
+  const client = createYidaClient({ authRef });
+  const method = hasRemoteDispatchBoundary(context) ? 'getOnce' : 'get';
+  return dispatchRemotePrimitive(context, () => client[method](`/${appType}/query/app/getAppIncludingAecpInfo.json`, (ref) => ({
+    _api: 'nattyFetch',
+    _mock: 'false',
+    appKey: appType,
+    _csrf_token: ref.csrfToken,
+    _stamp: Date.now(),
+  })));
+}
+
+function normalizeAppDetail(result, appType) {
+  if (result && result.success && result.content && typeof result.content === 'object') {
+    return result.content;
+  }
+  if (result && (result.__needLogin || result.__csrfExpired)) {
+    throw createAppReaderError('login required', 'APP_READ_AUTH_REQUIRED');
+  }
+  if (isAppDetailMissing(result)) {
+    throw createAppReaderError('app not found', 'APP_READ_NOT_FOUND', { appType });
+  }
+  throw createAppReaderError(result && result.errorMsg || 'app detail request failed', 'APP_READ_FAILED', { appType });
+}
+
+function isAppDetailMissing(result) {
+  if (!result) {
+    return false;
+  }
+  const statusCode = Number(result.__httpStatus || result.statusCode || result.status || 0);
+  const errorCode = String(result.errorCode || result.code || '').toUpperCase();
+  const message = String(result.errorMsg || result.message || result.throwable || '').toLowerCase();
+  return (
+    statusCode === 404 ||
+    errorCode === '404' ||
+    errorCode.includes('NOT_FOUND') ||
+    message.includes('not found') ||
+    message.includes('不存在') ||
+    message.includes('不存在该应用') ||
+    message.includes('应用不存在')
+  );
+}
+
+module.exports = {
+  readApp,
+  fetchAppDetail,
+};

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

@@ -0,0 +1,235 @@
+'use strict';
+
+const querystring = require('querystring');
+const { httpPost, requestWithAutoLogin } = require('../../core/utils');
+const { buildYidaI18n } = require('../../core/yida-i18n');
+const {
+  dispatchRemotePrimitive,
+  hasRemoteDispatchBoundary,
+  rethrowRemoteDispatchBoundaryFailure,
+} = require('../../schema/remote-dispatch-boundary');
+const { isTokenAuthRef } = require('../../core/yida-client');
+
+const DEFAULT_APP_OPTIONS = Object.freeze({
+  icon: 'xian-yingyong',
+  iconColor: '#0089FF',
+  colour: 'deepBlue',
+  navTheme: 'dark',
+  layoutDirection: 'slide',
+});
+
+function createAppServiceError(message, code, details) {
+  const error = new Error(message);
+  error.code = code || 'APP_SERVICE_FAILED';
+  if (details) {
+    error.details = details;
+  }
+  return error;
+}
+
+function resolveAuthRef(context) {
+  return context && context.authRef ? context.authRef : context;
+}
+
+function resolveServices(context) {
+  const services = context && context.services || {};
+  return {
+    httpPost: services.httpPost || httpPost,
+    requestWithAutoLogin: services.requestWithAutoLogin || requestWithAutoLogin,
+  };
+}
+
+async function readExclusiveAppConfig(context) {
+  const authRef = resolveAuthRef(context);
+  const services = resolveServices(context);
+  let openExclusive = 'n';
+  let openPhysicColumn = 'n';
+
+  try {
+    const result = await dispatchRemotePrimitive(context, () => services.httpPost(
+      authRef.baseUrl,
+      `/query/exclusive/queryCorpAppConfig.json?_api=Global.queryCorpAppConfig&_mock=false&_csrf_token=${authRef.csrfToken}&_locale_time_zone_offset=28800000&_stamp=${Date.now()}`,
+      '',
+      authRef.cookies
+    ));
+    if (result && result.content) {
+      if (result.content.forceExclusiveDb === 'y') {
+        openExclusive = 'y';
+      }
+      if (result.content.forcePhysicalColumn === 'y') {
+        openPhysicColumn = 'y';
+      }
+    }
+  } catch (error) {
+    rethrowRemoteDispatchBoundaryFailure(error);
+    // This lookup is advisory; legacy create-app also falls back to defaults.
+  }
+
+  return { openExclusive, openPhysicColumn };
+}
+
+async function createAppResource(context, input = {}) {
+  const authRef = resolveAuthRef(context);
+  const services = resolveServices(context);
+  const appName = input.appName || input.name;
+  if (!appName) {
+    throw createAppServiceError('app name is required', 'APP_CREATE_INVALID_ARGUMENTS');
+  }
+
+  const description = input.description || appName;
+  const icon = input.icon || DEFAULT_APP_OPTIONS.icon;
+  const iconColor = input.iconColor || DEFAULT_APP_OPTIONS.iconColor;
+  const colour = input.colour || DEFAULT_APP_OPTIONS.colour;
+  const navTheme = input.navTheme || DEFAULT_APP_OPTIONS.navTheme;
+  const layoutDirection = input.layoutDirection || DEFAULT_APP_OPTIONS.layoutDirection;
+  const contentLocale = input.contentLocale || input.defaultLanguage || 'zh_CN';
+  const exclusive = await readExclusiveAppConfig(context);
+  const iconValue = `${icon}%%${iconColor}`;
+
+  const response = await dispatchAppWrite(context, services, authRef, (auth) => {
+    const postData = querystring.stringify({
+      _csrf_token: auth.csrfToken,
+      appName: JSON.stringify(buildYidaI18n(appName, { en_US: appName, ja_JP: appName })),
+      description: JSON.stringify(buildYidaI18n(description, { en_US: description, ja_JP: description })),
+      icon: iconValue,
+      iconUrl: iconValue,
+      colour,
+      navTheme,
+      layoutDirection,
+      defaultLanguage: contentLocale,
+      openExclusive: exclusive.openExclusive,
+      openPhysicColumn: exclusive.openPhysicColumn,
+      openIsolationDatabase: 'n',
+      openExclusiveUnit: 'n',
+      group: 'ALL',
+    });
+    return services.httpPost(auth.baseUrl, '/query/app/registerApp.json', postData, auth.cookies);
+  });
+
+  if (!response || !response.success || !response.content) {
+    throw createAppServiceError(
+      response && response.errorMsg || 'app create request failed',
+      'APP_CREATE_FAILED',
+      { result: sanitizeServiceResult(response) }
+    );
+  }
+
+  return {
+    appType: response.content,
+    appName,
+    response,
+  };
+}
+
+async function updateAppResource(context, input = {}) {
+  const authRef = resolveAuthRef(context);
+  const services = resolveServices(context);
+  const appType = input.appType;
+  if (!appType) {
+    throw createAppServiceError('appType is required', 'APP_UPDATE_INVALID_ARGUMENTS');
+  }
+
+  const updateFields = {
+    _locale_time_zone_offset: '28800000',
+    appType,
+  };
+  if (input.name) {
+    updateFields.appName = JSON.stringify(buildYidaI18n(input.name, {
+      en_US: input.name,
+      ja_JP: input.name,
+    }, { includePureEn: true }));
+  }
+  if (input.desc) {
+    updateFields.description = JSON.stringify(buildYidaI18n(input.desc, {
+      en_US: input.desc,
+      ja_JP: input.desc,
+    }));
+  }
+  if (input.icon) {
+    const iconValue = `${input.icon}%%${input.iconColor || DEFAULT_APP_OPTIONS.iconColor}`;
+    updateFields.icon = iconValue;
+    updateFields.iconUrl = iconValue;
+  }
+  if (input.colour) {
+    updateFields.colour = input.colour;
+  }
+  if (input.navTheme) {
+    updateFields.navTheme = input.navTheme;
+  }
+  if (input.layoutDirection) {
+    updateFields.layoutDirection = input.layoutDirection;
+  }
+
+  const response = await dispatchAppWrite(context, services, authRef, (auth) => {
+    const postDataObject = {
+      _csrf_token: auth.csrfToken,
+      ...updateFields,
+    };
+    return services.httpPost(
+      auth.baseUrl,
+      `/query/app/updateAppName.json?_api=Form.updateAppName&_mock=false&_stamp=${Date.now()}`,
+      querystring.stringify(postDataObject),
+      auth.cookies
+    );
+  });
+
+  if (!response || !response.success) {
+    throw createAppServiceError(
+      response && response.errorMsg || 'app update request failed',
+      'APP_UPDATE_FAILED',
+      { result: sanitizeServiceResult(response) }
+    );
+  }
+
+  return { appType, response };
+}
+
+async function dispatchAppWrite(context, services, authRef, callback) {
+  if (!hasRemoteDispatchBoundary(context)) {
+    return services.requestWithAutoLogin(callback, authRef);
+  }
+  requireAppWriteAuth(authRef);
+  return dispatchRemotePrimitive(context, () => callback(authRef));
+}
+
+function requireAppWriteAuth(authRef) {
+  if (!authRef || typeof authRef.baseUrl !== 'string' || !authRef.baseUrl) {
+    throw createAppServiceError(
+      'app write authentication is not ready',
+      'APP_WRITE_PRECHECK_FAILED'
+    );
+  }
+  if (isTokenAuthRef(authRef)) {
+    return authRef;
+  }
+  if (
+    typeof authRef.csrfToken !== 'string' || !authRef.csrfToken ||
+    !Array.isArray(authRef.cookies)
+  ) {
+    throw createAppServiceError(
+      'app write authentication is not ready',
+      'APP_WRITE_PRECHECK_FAILED'
+    );
+  }
+  return authRef;
+}
+
+function sanitizeServiceResult(result) {
+  if (!result || typeof result !== 'object') {
+    return result || null;
+  }
+  const sanitized = {};
+  ['success', 'errorMsg', 'errorCode', 'code', 'message'].forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(result, key)) {
+      sanitized[key] = result[key];
+    }
+  });
+  return sanitized;
+}
+
+module.exports = {
+  DEFAULT_APP_OPTIONS,
+  createAppResource,
+  createAppServiceError,
+  updateAppResource,
+};