openyida 2026.7.19 → 2026.7.21

package/lib/schema/remote-dispatch-boundary.js

@@ -0,0 +1,39 @@
+'use strict';
+
+function hasRemoteDispatchBoundary(context) {
+  return !!(context && typeof context.assertRemoteDispatchBoundary === 'function');
+}
+
+function assertRemoteDispatchBoundary(context, phase) {
+  if (hasRemoteDispatchBoundary(context)) {
+    context.assertRemoteDispatchBoundary(phase);
+  }
+}
+
+async function dispatchRemotePrimitive(context, callback) {
+  assertRemoteDispatchBoundary(context, 'before');
+  let result;
+  let requestError;
+  try {
+    result = await callback();
+  } catch (error) {
+    requestError = error;
+  }
+  assertRemoteDispatchBoundary(context, 'after');
+  if (requestError) {
+    throw requestError;
+  }
+  return result;
+}
+
+function rethrowRemoteDispatchBoundaryFailure(error) {
+  if (error && error.code === 'SCHEMA_APPLY_LOCK_LOST') {
+    throw error;
+  }
+}
+
+module.exports = Object.freeze({
+  dispatchRemotePrimitive,
+  hasRemoteDispatchBoundary,
+  rethrowRemoteDispatchBoundaryFailure,
+});

package/lib/schema/remote-missing.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const REMOTE_MISSING_BRAND = Symbol('openyida.schema.remoteMissing');
+
+function createRemoteMissingError() {
+  const error = new Error('Bound remote resource is missing.');
+  error.code = 'SCHEMA_REMOTE_RESOURCE_MISSING';
+  Object.defineProperty(error, REMOTE_MISSING_BRAND, {
+    value: true,
+  });
+  return error;
+}
+
+function isRemoteMissingError(error) {
+  return !!(error && error[REMOTE_MISSING_BRAND] === true);
+}
+
+module.exports = {
+  createRemoteMissingError,
+  isRemoteMissingError,
+};

package/lib/schema/remote-reader.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const { schemaError } = require('./errors');
+const { isSha256 } = require('./hash');
+const { isRemoteMissingError } = require('./remote-missing');
+const { createDefaultRegistry } = require('./resource-registry');
+const { compareResourceIds, getResourceState, hashStable } = require('./state-store');
+
+async function readObservedResources(resources, state, options = {}) {
+  const registry = options.registry || createDefaultRegistry();
+  const context = Object.assign({}, options.context || {}, {
+    services: options.services || options.context && options.context.services || {},
+    state,
+  });
+  const observedResources = [];
+  const missingResources = [];
+
+  for (const resource of sortResources(resources || [])) {
+    const adapter = registry.get(resource.resourceType);
+    assertObservedAdapter(adapter);
+    const stateResource = getResourceState(state, resource.resourceType, resource.key);
+    if (!stateResource) {
+      throw schemaError('SCHEMA_STATE_RESOURCE_BINDING_MISSING', 'State does not contain bindings for resource.', {
+        details: {
+          resourceType: resource.resourceType,
+          key: resource.key,
+        },
+      });
+    }
+    if (stateResource.adapterVersion !== adapter.adapterVersion) {
+      throw schemaError('SCHEMA_STATE_ADAPTER_VERSION_UNSUPPORTED', 'State resource adapterVersion is not supported by the current adapter.', {
+        details: {
+          resourceType: resource.resourceType,
+          key: resource.key,
+          stateAdapterVersion: stateResource.adapterVersion,
+          adapterVersion: adapter.adapterVersion,
+        },
+      });
+    }
+
+    const adapterContext = Object.assign({}, context, {
+      resource,
+      stateResource,
+    });
+    assertDispatchBoundary(options);
+    const observed = await readObservedWithStableError(adapter, stateResource, adapterContext, resource);
+    assertDispatchBoundary(options);
+    if (isRemoteMissingError(observed)) {
+      missingResources.push({
+        resourceType: resource.resourceType,
+        key: resource.key,
+      });
+      continue;
+    }
+    const projection = projectObservedWithStableError(adapter, observed, stateResource, adapterContext, resource);
+    const managed = projection.managed || {};
+    const observedManagedHash = projection.observedManagedHash || hashObservedManaged({
+      resourceType: resource.resourceType,
+      key: resource.key,
+      adapterVersion: adapter.adapterVersion,
+      managed,
+    });
+
+    const observedResource = {
+      resourceType: resource.resourceType,
+      key: resource.key,
+      adapterVersion: adapter.adapterVersion,
+      managed,
+      observedManagedHash,
+      bindings: projection.bindings || stateResource.bindings || {},
+    };
+    if (projection.remoteSchemaHash !== undefined) {
+      if (!isSha256(projection.remoteSchemaHash)) {
+        throw schemaError('SCHEMA_INTERNAL_ERROR', 'Resource adapter returned an invalid remote Schema hash.');
+      }
+      observedResource.remoteSchemaHash = projection.remoteSchemaHash;
+    }
+    copyPlannerObservation(projection, observedResource);
+    observedResources.push(observedResource);
+  }
+
+  return {
+    missingResources,
+    resources: observedResources,
+  };
+}
+
+function assertDispatchBoundary(options) {
+  if (typeof options.assertDispatchBoundary === 'function') {
+    options.assertDispatchBoundary();
+  }
+}
+
+function copyPlannerObservation(projection, target) {
+  for (const property of ['observedIdentityHash', 'observedDraftHash']) {
+    if (projection[property] === undefined) {
+      continue;
+    }
+    if (!isSha256(projection[property])) {
+      throw schemaError('SCHEMA_INTERNAL_ERROR', 'Resource adapter returned an invalid observed identity hash.');
+    }
+    target[property] = projection[property];
+  }
+  if (projection.observedIdentityMatchesBindings !== undefined) {
+    if (typeof projection.observedIdentityMatchesBindings !== 'boolean') {
+      throw schemaError('SCHEMA_INTERNAL_ERROR', 'Resource adapter returned an invalid observed identity comparison.');
+    }
+    target.observedIdentityMatchesBindings = projection.observedIdentityMatchesBindings;
+  }
+  if (projection.observedDraftCount !== undefined) {
+    if (!Number.isInteger(projection.observedDraftCount) || projection.observedDraftCount < 0) {
+      throw schemaError('SCHEMA_INTERNAL_ERROR', 'Resource adapter returned an invalid observed draft count.');
+    }
+    target.observedDraftCount = projection.observedDraftCount;
+  }
+}
+
+function hashObservedManaged(value) {
+  return hashStable({
+    contractVersion: 1,
+    observed: value,
+  });
+}
+
+function assertObservedAdapter(adapter) {
+  if (
+    !adapter ||
+    typeof adapter.readObserved !== 'function' ||
+    typeof adapter.projectObserved !== 'function'
+  ) {
+    throw schemaError('SCHEMA_RESOURCE_TYPE_UNSUPPORTED', 'Resource adapter does not support observed reads.', {
+      details: { resourceType: adapter && adapter.resourceType },
+    });
+  }
+}
+
+async function readObservedWithStableError(adapter, stateResource, context, resource) {
+  try {
+    return await adapter.readObserved(stateResource, context);
+  } catch (error) {
+    if (isRemoteMissingError(error)) {
+      return error;
+    }
+    if (error && error.code === 'SCHEMA_REMOTE_RESOURCE_MISSING') {
+      throwRemoteReadFailed(resource);
+    }
+    if (error && error.code && String(error.code).startsWith('SCHEMA_')) {
+      throw error;
+    }
+    throwRemoteReadFailed(resource, error && error.code);
+  }
+}
+
+function throwRemoteReadFailed(resource, adapterCode) {
+  throw schemaError('SCHEMA_REMOTE_READ_FAILED', 'Remote observed read failed.', {
+    details: {
+      resourceType: resource.resourceType,
+      key: resource.key,
+      adapterCode,
+    },
+  });
+}
+
+function projectObservedWithStableError(adapter, observed, stateResource, context, resource) {
+  try {
+    return adapter.projectObserved(observed, stateResource, context);
+  } catch (error) {
+    if (error && error.code && String(error.code).startsWith('SCHEMA_')) {
+      throw error;
+    }
+    throw schemaError('SCHEMA_REMOTE_PROJECT_FAILED', 'Remote observed projection failed.', {
+      details: {
+        resourceType: resource.resourceType,
+        key: resource.key,
+        adapterCode: error && error.code,
+      },
+    });
+  }
+}
+
+function sortResources(resources) {
+  return resources.slice().sort(compareResourceIds);
+}
+
+module.exports = {
+  hashObservedManaged,
+  isRemoteMissingError,
+  readObservedResources,
+};

package/lib/schema/resource-registry.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const { schemaError } = require('./errors');
+const { sortStrings } = require('./sort');
+
+const OPTIONAL_ADAPTER_METHODS = Object.freeze([
+  'buildBindings',
+  'classifyObservedConflict',
+  'classifyUpdate',
+  'create',
+  'preflightApply',
+  'prepareComparison',
+  'prepareOperation',
+  'projectObserved',
+  'projectOperationResult',
+  'readObserved',
+  'reconcileStaged',
+  'resumeCreate',
+  'advanceStagedCheckpoint',
+  'isStagedCheckpointRemoteComplete',
+  'update',
+  'validateStageCheckpoint',
+  'validateStateResource',
+  'verify',
+]);
+const STAGED_ADAPTER_METHODS = Object.freeze([
+  'advanceStagedCheckpoint',
+  'isStagedCheckpointRemoteComplete',
+  'reconcileStaged',
+  'validateStageCheckpoint',
+]);
+const REQUIRED_ADAPTER_METHODS = Object.freeze(['normalize', 'validate']);
+const ADAPTER_METADATA = Object.freeze(['adapterVersion', 'resourceType']);
+const ADAPTER_CONTRACT_KEYS = new Set([
+  ...ADAPTER_METADATA,
+  ...REQUIRED_ADAPTER_METHODS,
+  ...OPTIONAL_ADAPTER_METHODS,
+]);
+
+class ResourceRegistry {
+  constructor() {
+    this.adapters = new Map();
+  }
+
+  register(adapter) {
+    const contract = createAdapterContract(adapter);
+    const stagedMethodCount = STAGED_ADAPTER_METHODS.filter(method => typeof contract[method] === 'function').length;
+    if (stagedMethodCount > 0 && contract.resourceType !== 'process') {
+      throw new Error('Resource adapter staged methods are reserved for process: ' + contract.resourceType);
+    }
+    if (stagedMethodCount > 0 && stagedMethodCount !== STAGED_ADAPTER_METHODS.length) {
+      throw new Error('Process staged adapter must implement the complete staged method contract: ' + contract.resourceType);
+    }
+    if (this.adapters.has(contract.resourceType)) {
+      throw new Error('Duplicate resource adapter: ' + contract.resourceType);
+    }
+    this.adapters.set(contract.resourceType, contract);
+    return this;
+  }
+
+  get(resourceType) {
+    const adapter = this.adapters.get(resourceType);
+    if (!adapter) {
+      throw schemaError('SCHEMA_RESOURCE_TYPE_UNSUPPORTED', 'Resource type is not supported by this validator.', {
+        details: { resourceType },
+      });
+    }
+    return adapter;
+  }
+
+  listTypes() {
+    return sortStrings(this.adapters.keys());
+  }
+}
+
+function createAdapterContract(adapter) {
+  if (!adapter || typeof adapter !== 'object' || Array.isArray(adapter)) {
+    throw new Error('Resource adapter must be a plain contract object');
+  }
+  const prototype = Object.getPrototypeOf(adapter);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error('Resource adapter must not inherit contract properties');
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(adapter);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (typeof key !== 'string' || key === 'capabilities' || !ADAPTER_CONTRACT_KEYS.has(key)) {
+      throw new Error('Resource adapter declares an unknown contract property: ' + String(key));
+    }
+    const descriptor = descriptors[key];
+    if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+      throw new Error('Resource adapter contract properties must be data properties: ' + key);
+    }
+  }
+
+  const resourceType = valueFromDescriptor(descriptors, 'resourceType');
+  const adapterVersion = valueFromDescriptor(descriptors, 'adapterVersion');
+  if (typeof resourceType !== 'string' || !resourceType) {
+    throw new Error('Resource adapter must declare resourceType');
+  }
+  if (!Number.isInteger(adapterVersion) || adapterVersion < 1) {
+    throw new Error('Resource adapter must declare a positive integer adapterVersion: ' + resourceType);
+  }
+  for (const method of REQUIRED_ADAPTER_METHODS) {
+    if (typeof valueFromDescriptor(descriptors, method) !== 'function') {
+      throw new Error('Resource adapter must implement normalize and validate: ' + resourceType);
+    }
+  }
+  for (const method of OPTIONAL_ADAPTER_METHODS) {
+    if (descriptors[method] && typeof descriptors[method].value !== 'function') {
+      throw new Error(`Resource adapter method must be a function ${method}: ` + resourceType);
+    }
+  }
+
+  const contract = {};
+  for (const key of ADAPTER_METADATA) {
+    contract[key] = descriptors[key].value;
+  }
+  for (const method of [...REQUIRED_ADAPTER_METHODS, ...OPTIONAL_ADAPTER_METHODS]) {
+    if (descriptors[method]) {
+      contract[method] = descriptors[method].value;
+    }
+  }
+  return Object.freeze(contract);
+}
+
+function valueFromDescriptor(descriptors, property) {
+  const descriptor = descriptors[property];
+  return descriptor && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+    ? descriptor.value
+    : undefined;
+}
+
+function isStagedAdapter(adapter) {
+  return !!(
+    adapter &&
+    adapter.resourceType === 'process' &&
+    STAGED_ADAPTER_METHODS.every(method => typeof adapter[method] === 'function')
+  );
+}
+
+function createDefaultRegistry() {
+  const { appAdapter } = require('./adapters/app-adapter');
+  const { formAdapter } = require('./adapters/form-adapter');
+  const { pageAdapter } = require('./adapters/page-adapter');
+  const { processAdapter } = require('./adapters/process-adapter');
+  return new ResourceRegistry()
+    .register(appAdapter)
+    .register(formAdapter)
+    .register(pageAdapter)
+    .register(processAdapter);
+}
+
+module.exports = {
+  ResourceRegistry,
+  createDefaultRegistry,
+  isStagedAdapter,
+};

package/lib/schema/server-revision.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { schemaError } = require('./errors');
+
+const STALE_SCHEMA_MESSAGE = '页面已变更，请更新后再修改并重新保存';
+const SERVER_REVISION_CONFLICTS = new WeakSet();
+
+function getSchemaServerRevision(value) {
+  const schema = normalizeSchemaContent(value);
+  if (!schema) {
+    return undefined;
+  }
+  const revision = schema.gmtModified;
+  return Number.isFinite(revision) && revision >= 0 ? revision : undefined;
+}
+
+function requireSchemaServerRevision(value, createError) {
+  const revision = getSchemaServerRevision(value);
+  if (revision !== undefined) {
+    return revision;
+  }
+  if (typeof createError === 'function') {
+    throw createError();
+  }
+  throw schemaError('SCHEMA_REMOTE_READ_FAILED', 'Remote Schema revision is missing or invalid.');
+}
+
+function isSaveFormSchemaRevisionConflict(result) {
+  if (!result || typeof result !== 'object' || result.success !== false) {
+    return false;
+  }
+  if (String(result.errorCode || '') !== '500') {
+    return false;
+  }
+  return result.errorMsg === STALE_SCHEMA_MESSAGE || result.throwable === STALE_SCHEMA_MESSAGE;
+}
+
+function createServerRevisionConflict(resourceType) {
+  const error = schemaError('SCHEMA_APPLY_JIT_CONFLICT', 'Resource changed after the JIT read.', {
+    details: { resourceType },
+  });
+  SERVER_REVISION_CONFLICTS.add(error);
+  return error;
+}
+
+function isServerRevisionConflict(error) {
+  return !!error && SERVER_REVISION_CONFLICTS.has(error);
+}
+
+function normalizeSchemaContent(value) {
+  let schema = value && Object.prototype.hasOwnProperty.call(value, 'content')
+    ? value.content
+    : value;
+  if (typeof schema === 'string') {
+    try {
+      schema = JSON.parse(schema);
+    } catch (error) {
+      return null;
+    }
+  }
+  return schema && typeof schema === 'object' && !Array.isArray(schema) ? schema : null;
+}
+
+module.exports = Object.freeze({
+  STALE_SCHEMA_MESSAGE,
+  createServerRevisionConflict,
+  getSchemaServerRevision,
+  isSaveFormSchemaRevisionConflict,
+  isServerRevisionConflict,
+  requireSchemaServerRevision,
+});

package/lib/schema/sort.js

@@ -0,0 +1,28 @@
+'use strict';
+
+function compareCodePoints(left, right) {
+  const leftString = String(left);
+  const rightString = String(right);
+  const leftPoints = Array.from(leftString);
+  const rightPoints = Array.from(rightString);
+  const length = Math.min(leftPoints.length, rightPoints.length);
+
+  for (let index = 0; index < length; index++) {
+    const leftCode = leftPoints[index].codePointAt(0);
+    const rightCode = rightPoints[index].codePointAt(0);
+    if (leftCode !== rightCode) {
+      return leftCode - rightCode;
+    }
+  }
+
+  return leftPoints.length - rightPoints.length;
+}
+
+function sortStrings(values) {
+  return [...values].sort(compareCodePoints);
+}
+
+module.exports = {
+  compareCodePoints,
+  sortStrings,
+};