openxiangda 1.0.172 → 1.0.173

package/lib/form-schema-loader.js

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+const { builtinModules, createRequire } = require('module');
+const esbuild = require('esbuild');
+
+function resolveWorkspaceAlias(workspaceRoot, importPath) {
+  const raw = path.join(
+    workspaceRoot,
+    'src',
+    String(importPath || '').replace(/^@\//, '')
+  );
+  const candidates = [
+    raw,
+    `${raw}.ts`,
+    `${raw}.tsx`,
+    `${raw}.js`,
+    `${raw}.mjs`,
+    `${raw}.cjs`,
+    path.join(raw, 'index.ts'),
+    path.join(raw, 'index.tsx'),
+    path.join(raw, 'index.js'),
+  ];
+  return candidates.find(candidate => fs.existsSync(candidate)) || raw;
+}
+
+async function loadLocalFormSchema(workspaceRoot, formCode) {
+  const schemaPath = path.join(
+    workspaceRoot,
+    'src',
+    'forms',
+    formCode,
+    'schema.ts'
+  );
+  if (!fs.existsSync(schemaPath)) return null;
+  const external = Array.from(
+    new Set([...builtinModules, ...builtinModules.map(name => `node:${name}`)])
+  );
+  const built = await esbuild.build({
+    entryPoints: [schemaPath],
+    bundle: true,
+    format: 'cjs',
+    platform: 'node',
+    target: ['node20'],
+    write: false,
+    logLevel: 'silent',
+    external,
+    plugins: [
+      {
+        name: 'openxiangda-form-schema-workspace-alias',
+        setup(build) {
+          build.onResolve({ filter: /^@\// }, args => ({
+            path: resolveWorkspaceAlias(workspaceRoot, args.path),
+          }));
+        },
+      },
+    ],
+  });
+  const code = built.outputFiles?.[0]?.text;
+  if (!code) {
+    throw new Error(`FORM_SCHEMA_BUILD_FAILED: ${formCode} 未生成 schema bundle`);
+  }
+  const schemaModule = { exports: {} };
+  const localRequire = createRequire(schemaPath);
+  const evaluate = new Function(
+    'module',
+    'exports',
+    'require',
+    '__filename',
+    '__dirname',
+    code
+  );
+  evaluate(
+    schemaModule,
+    schemaModule.exports,
+    localRequire,
+    schemaPath,
+    path.dirname(schemaPath)
+  );
+  const exported = schemaModule.exports?.default || schemaModule.exports;
+  return normalizeLocalFormSchema(exported, formCode);
+}
+
+function normalizeLocalFormSchema(schema, formCode) {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+    throw new Error(`FORM_SCHEMA_INVALID: ${formCode} 默认导出必须是对象`);
+  }
+  if (!schema.formMeta || typeof schema.formMeta !== 'object') {
+    throw new Error(`FORM_SCHEMA_INVALID: ${formCode}.formMeta 缺失`);
+  }
+  if (!Array.isArray(schema.fields) || schema.fields.length === 0) {
+    throw new Error(`FORM_SCHEMA_INVALID: ${formCode}.fields 不能为空`);
+  }
+  const seen = new Set();
+  const components = schema.fields.map((field, index) => {
+    const fieldId = String(field?.fieldId || '').trim();
+    const componentName = normalizeComponentName(field?.componentName);
+    if (!fieldId || !componentName) {
+      throw new Error(
+        `FORM_SCHEMA_INVALID: ${formCode}.fields[${index}] 缺少 fieldId/componentName`
+      );
+    }
+    if (seen.has(fieldId)) {
+      throw new Error(`FORM_SCHEMA_INVALID: ${formCode} fieldId 重复: ${fieldId}`);
+    }
+    seen.add(fieldId);
+    return {
+      componentName,
+      id: field.id || `${fieldId}_${index + 1}`,
+      title: field.label || fieldId,
+      hidden: false,
+      isLocked: false,
+      condition: true,
+      conditionGroup: '',
+      props: {
+        ...field,
+        componentName,
+        isFormComponent: true,
+        fieldId,
+        label: field.label || fieldId,
+        tips: field.tips || '',
+        value: field.value || '',
+        placeholder: field.placeholder || '',
+      },
+    };
+  });
+  const pageSchema = {
+    version: '2.0',
+    componentsTree: [
+      {
+        componentName: 'Page',
+        id: `${schema.formMeta.formUuid || formCode}_page`,
+        props: {},
+        children: components,
+      },
+    ],
+  };
+  return {
+    name: schema.formMeta.title || formCode,
+    schema: JSON.stringify(pageSchema),
+    packages: JSON.stringify({}),
+    formType: normalizeFormType(
+      schema.formMeta.formType || schema.template?.formType
+    ),
+    fieldCount: components.length,
+    sourcePath: `src/forms/${formCode}/schema.ts`,
+  };
+}
+
+function normalizeComponentName(value) {
+  const name = String(value || '').trim();
+  return name === 'TextAreaField' ? 'TextareaField' : name;
+}
+
+function normalizeFormType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return ['process', 'workflow', 'flow', 'flowform', 'processform'].includes(
+    normalized
+  )
+    ? 'process'
+    : 'receipt';
+}
+
+module.exports = {
+  loadLocalFormSchema,
+  normalizeLocalFormSchema,
+};

package/lib/git-remote-identity.js

@@ -0,0 +1,89 @@
+const crypto = require('crypto');
+
+function legacyRemoteIdentity(value) {
+  const remote = String(value || '').trim();
+  try {
+    const url = new URL(remote);
+    url.username = '';
+    url.password = '';
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+  } catch {
+    return remote
+      .replace(/^[^@/]+@([^:]+):/, '$1:')
+      .replace(/[?#].*$/, '');
+  }
+}
+
+function toggleDotGit(value) {
+  const normalized = String(value || '').replace(/\/+$/, '');
+  return /\.git$/i.test(normalized)
+    ? normalized.replace(/\.git$/i, '')
+    : `${normalized}.git`;
+}
+
+function canonicalRemoteIdentity(value) {
+  const legacy = legacyRemoteIdentity(value).replace(/\/+$/, '');
+  try {
+    const url = new URL(legacy);
+    const host = url.hostname.toLowerCase();
+    const port = url.port ? `:${url.port}` : '';
+    const pathname = url.pathname
+      .replace(/^\/+|\/+$/g, '')
+      .replace(/\.git$/i, '');
+    return `${host}${port}/${pathname}`.replace(/\/+$/, '');
+  } catch {
+    return legacy
+      .replace(/^([^:]+):/, '$1/')
+      .replace(/\.git$/i, '')
+      .replace(/\/+$/, '');
+  }
+}
+
+function remoteIdentityVariants(value) {
+  const legacy = legacyRemoteIdentity(value).replace(/\/+$/, '');
+  return Array.from(
+    new Set(
+      [
+        legacy,
+        toggleDotGit(legacy),
+        canonicalRemoteIdentity(legacy),
+      ].filter(Boolean)
+    )
+  );
+}
+
+function sha256(value) {
+  return `sha256:${crypto
+    .createHash('sha256')
+    .update(String(value))
+    .digest('hex')}`;
+}
+
+function remoteRepositoryHashes(value) {
+  return remoteIdentityVariants(value).map(identity =>
+    sha256(`remote:${identity}`)
+  );
+}
+
+function remoteUrlHashes(value) {
+  return remoteIdentityVariants(value).map(sha256);
+}
+
+function identitiesIntersect(left, right) {
+  const leftSet = new Set(
+    (Array.isArray(left) ? left : [left]).filter(Boolean)
+  );
+  return (Array.isArray(right) ? right : [right]).some(value =>
+    leftSet.has(value)
+  );
+}
+
+module.exports = {
+  identitiesIntersect,
+  legacyRemoteIdentity,
+  remoteIdentityVariants,
+  remoteRepositoryHashes,
+  remoteUrlHashes,
+};

package/lib/release-mainline.js

@@ -1,8 +1,11 @@
-const crypto = require('crypto');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
 const { readGitSourceBase } = require('./change-baseline');
+const {
+  identitiesIntersect,
+  remoteUrlHashes,
+} = require('./git-remote-identity');
 const { listRuntimeBuildInputChanges } = require('./runtime-lineage');
 
 const GIT_OUTPUT_LIMIT = 16 * 1024 * 1024;
@@ -68,6 +71,7 @@ function prepareReleaseSourceRevision(options = {}) {
     worktreeRoot: readGit(cwd, ['rev-parse', '--show-toplevel']).stdout,
     remoteName: mainline.remoteName,
     remoteUrlHash: mainline.remoteUrlHash,
+    remoteUrlHashAliases: mainline.remoteUrlHashAliases,
     mainBranch: mainline.branchName,
     mainTipCommit: mainline.tipCommit,
     mainlineSource: mainline.source,
@@ -82,7 +86,10 @@ function assertReleaseSourceRevisionStable(sourceRevision, options = {}) {
   const current = readGitSourceBase(cwd, 'HEAD');
   const dirtyPaths = listRuntimeBuildInputChanges(cwd);
   if (
-    expected.repo !== current.repo ||
+    !identitiesIntersect(
+      [expected.repo, ...(expected.repoAliases || [])],
+      [current.repo, ...(current.repoAliases || [])]
+    ) ||
     expected.baseCommit !== current.baseCommit ||
     expected.treeHash !== current.treeHash ||
     dirtyPaths.length > 0
@@ -109,7 +116,12 @@ function inspectReleaseSourceIntegration(sourceRevision, options = {}) {
   const cwd = path.resolve(options.cwd || process.cwd());
   const source = normalizeSourceRevision(sourceRevision);
   const currentRepository = readGitSourceBase(cwd, 'HEAD');
-  if (source.repo !== currentRepository.repo) {
+  if (
+    !identitiesIntersect(
+      [source.repo, ...(source.repoAliases || [])],
+      [currentRepository.repo, ...(currentRepository.repoAliases || [])]
+    )
+  ) {
     throw releaseMainlineError(
       'RELEASE_SOURCE_REPOSITORY_MISMATCH',
       '冻结的发布提交与当前 Git 仓库不一致，不能验证主分支回合状态'
@@ -120,7 +132,10 @@ function inspectReleaseSourceIntegration(sourceRevision, options = {}) {
   if (
     source.remoteName !== mainline.remoteName ||
     source.mainBranch !== mainline.branchName ||
-    source.remoteUrlHash !== mainline.remoteUrlHash
+    !identitiesIntersect(
+      [source.remoteUrlHash, ...(source.remoteUrlHashAliases || [])],
+      [mainline.remoteUrlHash, ...(mainline.remoteUrlHashAliases || [])]
+    )
   ) {
     throw releaseMainlineError(
       'RELEASE_MAINLINE_TARGET_CHANGED',
@@ -204,7 +219,8 @@ function resolveAuthoritativeMainline(options = {}) {
 }
 
 function resolveRemoteMainline({ cwd, remoteName }) {
-  const remoteUrlHash = readRemoteUrlHash(cwd, remoteName);
+  const remoteUrlHashAliases = readRemoteUrlHashes(cwd, remoteName);
+  const remoteUrlHash = remoteUrlHashAliases[0];
   const remoteHead = readGit(
     cwd,
     ['ls-remote', '--symref', remoteName, 'HEAD'],
@@ -217,6 +233,7 @@ function resolveRemoteMainline({ cwd, remoteName }) {
       return {
         remoteName,
         remoteUrlHash,
+        remoteUrlHashAliases,
         branchName: parsed.branchName,
         tipCommit: parsed.tipCommit,
         source: 'remote-head',
@@ -236,6 +253,7 @@ function resolveRemoteMainline({ cwd, remoteName }) {
     return {
       remoteName,
       remoteUrlHash,
+      remoteUrlHashAliases,
       ...candidates[0],
       source: 'remote-main-master-fallback',
     };
@@ -422,6 +440,25 @@ function normalizeSourceRevision(value) {
   const remoteName = normalizeOptionalName(value.remoteName, 'remote');
   const mainBranch = String(value.mainBranch || '').trim();
   const remoteUrlHash = String(value.remoteUrlHash || '').trim().toLowerCase();
+  const remoteUrlHashAliases = Array.from(
+    new Set(
+      [
+        remoteUrlHash,
+        ...(Array.isArray(value.remoteUrlHashAliases)
+          ? value.remoteUrlHashAliases
+          : []),
+      ]
+        .map(item => String(item || '').trim().toLowerCase())
+        .filter(item => /^sha256:[0-9a-f]{64}$/.test(item))
+    )
+  );
+  const repoAliases = Array.from(
+    new Set(
+      [repo, ...(Array.isArray(value.repoAliases) ? value.repoAliases : [])]
+        .map(item => String(item || '').trim().toLowerCase())
+        .filter(item => /^sha256:[0-9a-f]{64}$/.test(item))
+    )
+  );
   if (
     !/^sha256:[0-9a-f]{64}$/i.test(repo) ||
     !isObjectId(baseCommit) ||
@@ -439,15 +476,17 @@ function normalizeSourceRevision(value) {
     ...value,
     repo,
     repositoryId: repo,
+    repoAliases,
     baseCommit,
     treeHash,
     remoteName,
     remoteUrlHash,
+    remoteUrlHashAliases,
     mainBranch,
   };
 }
 
-function readRemoteUrlHash(cwd, remoteName) {
+function readRemoteUrlHashes(cwd, remoteName) {
   const result = readGit(cwd, ['remote', 'get-url', remoteName]);
   if (!result.stdout) {
     throw releaseMainlineError(
@@ -455,24 +494,7 @@ function readRemoteUrlHash(cwd, remoteName) {
       `无法读取权威远端地址: ${remoteName}`
     );
   }
-  const identity = normalizeRemoteUrlIdentity(result.stdout);
-  return `sha256:${crypto.createHash('sha256').update(identity).digest('hex')}`;
-}
-
-function normalizeRemoteUrlIdentity(value) {
-  const remote = String(value || '').trim();
-  try {
-    const url = new URL(remote);
-    url.username = '';
-    url.password = '';
-    url.search = '';
-    url.hash = '';
-    return url.toString();
-  } catch {
-    return remote
-      .replace(/^[^@/]+@([^:]+):/, '$1:')
-      .replace(/[?#].*$/, '');
-  }
+  return remoteUrlHashes(result.stdout);
 }
 
 function assertSafeDefaultBranch(remoteName, branchName) {

package/lib/release-plan.js

@@ -0,0 +1,294 @@
+const crypto = require('crypto');
+
+function uniqueSorted(values = []) {
+  return Array.from(
+    new Set(
+      values
+        .map(value => String(value || '').trim())
+        .filter(Boolean)
+    )
+  ).sort();
+}
+
+function normalizeReleaseTargets(targets = {}, runtimeMode = 'legacy') {
+  const logicalTargets = {
+    forms: uniqueSorted(targets.forms || []),
+    pages: uniqueSorted(targets.pages || []),
+    functions: uniqueSorted(targets.functions || []),
+    automations: uniqueSorted(targets.automations || []),
+    workflows: uniqueSorted(targets.workflows || []),
+    jsCodeNodes: uniqueSorted(targets.jsCodeNodes || []),
+    resources: Boolean(targets.resources),
+    runtime: Boolean(targets.runtime),
+    other: uniqueSorted(targets.other || []),
+  };
+  const activationTargets = {
+    ...logicalTargets,
+    pages:
+      runtimeMode === 'react-spa'
+        ? []
+        : logicalTargets.pages,
+    runtime:
+      runtimeMode === 'react-spa'
+        ? logicalTargets.runtime || logicalTargets.pages.length > 0
+        : logicalTargets.runtime,
+  };
+  return { logicalTargets, activationTargets };
+}
+
+function buildTargetedResourceReleaseCommands(
+  targets,
+  profileArg,
+  changeId
+) {
+  return buildTargetedResourceReleaseSteps(
+    targets,
+    profileArg,
+    changeId
+  ).map(step => step.command);
+}
+
+function commandFromArgs(args) {
+  return ['openxiangda', ...args]
+    .map(value => {
+      const text = String(value);
+      return /^[A-Za-z0-9_./,:@<>=+-]+$/.test(text)
+        ? text
+        : `'${text.replace(/'/g, `'\\''`)}'`;
+    })
+    .join(' ');
+}
+
+function createStep(id, args, options = {}) {
+  return {
+    id,
+    args,
+    command: commandFromArgs(args),
+    writes: options.writes !== false,
+    stagedKind: options.stagedKind || null,
+  };
+}
+
+function appendProfileAndChange(args, profileArg, changeId) {
+  args.push('--profile', profileArg);
+  if (changeId) args.push('--change', changeId);
+  return args;
+}
+
+function buildTargetedResourceReleaseSteps(
+  targets,
+  profileArg,
+  changeId
+) {
+  const steps = [];
+  const functions = targets.functions || [];
+  const automations = targets.automations || [];
+  if (functions.length > 0 || automations.length > 0) {
+    const resourceTypes = [
+      ...(functions.length > 0 ? ['function'] : []),
+      ...(automations.length > 0 ? ['automation'] : []),
+    ];
+    const qualify = resourceTypes.length > 1;
+    const selectors = [
+      ...functions.map(code => (qualify ? `function:${code}` : code)),
+      ...automations.map(code => (qualify ? `automation:${code}` : code)),
+    ];
+    steps.push(
+      createStep(
+        'backend-stage',
+        appendProfileAndChange(
+          [
+            'resource',
+            'publish',
+            resourceTypes.join(','),
+            '--only',
+            selectors.join(','),
+            '--stage-only',
+          ],
+          profileArg,
+          changeId
+        ),
+        { stagedKind: 'BackendRelease' }
+      )
+    );
+  }
+  const workflows = targets.workflows || [];
+  if (workflows.length > 0) {
+    steps.push(
+      createStep(
+        'workflow-publish',
+        appendProfileAndChange(
+          [
+            'resource',
+            'publish',
+            'workflow',
+            '--only',
+            workflows.join(','),
+          ],
+          profileArg,
+          changeId
+        )
+      )
+    );
+  }
+  return steps;
+}
+
+function buildWorkspaceReleaseCommands(
+  targetsInput,
+  runtimeMode,
+  profile,
+  changeId
+) {
+  return buildWorkspaceReleaseSteps(
+    targetsInput,
+    runtimeMode,
+    profile,
+    changeId
+  ).map(step => step.command);
+}
+
+function buildWorkspaceReleaseSteps(
+  targetsInput,
+  runtimeMode,
+  profile,
+  changeId
+) {
+  const profileArg = profile || '<profile>';
+  const { activationTargets: targets } = normalizeReleaseTargets(
+    targetsInput,
+    runtimeMode
+  );
+  const steps = [];
+  const hasResourceTargets =
+    Boolean(targets.resources) ||
+    targets.functions.length > 0 ||
+    targets.automations.length > 0 ||
+    targets.workflows.length > 0 ||
+    targets.jsCodeNodes.length > 0;
+  if (runtimeMode === 'react-spa') {
+    if (targets.forms.length > 0) {
+      steps.push(
+        createStep(
+          'form-stage',
+          appendProfileAndChange(
+            [
+              'resource',
+              'publish',
+              'form-setting',
+              '--only',
+              targets.forms.join(','),
+            ],
+            profileArg,
+            changeId
+          ),
+          { stagedKind: 'FormRelease' }
+        )
+      );
+    }
+    if (hasResourceTargets) {
+      steps.push(
+        ...buildTargetedResourceReleaseSteps(
+          targets,
+          profileArg,
+          changeId
+        )
+      );
+    }
+    if (targets.runtime) {
+      steps.push(
+        createStep(
+          'runtime-stage',
+          appendProfileAndChange(
+            ['runtime', 'deploy', '--no-activate'],
+            profileArg,
+            changeId
+          ),
+          { stagedKind: 'RuntimeRelease' }
+        )
+      );
+    }
+    if (
+      targets.forms.length > 0 ||
+      targets.functions.length > 0 ||
+      targets.automations.length > 0 ||
+      targets.runtime
+    ) {
+      steps.push(
+        createStep(
+          'app-finalize',
+          appendProfileAndChange(
+            [
+              'release',
+              'app-finalize',
+              '--staged-resources-json',
+              `.openxiangda/releases/${changeId || 'change'}/staged-resources.json`,
+            ],
+            profileArg,
+            changeId
+          )
+        )
+      );
+    }
+    return steps;
+  }
+
+  const onlyTargets = [
+    ...targets.forms.map(code => `forms/${code}`),
+    ...targets.pages.map(code => `pages/${code}`),
+  ];
+  if (onlyTargets.length > 0) {
+    steps.push(
+      createStep(
+        'workspace-publish',
+        appendProfileAndChange(
+          [
+            'workspace',
+            'publish',
+            '--only',
+            onlyTargets.join(','),
+            '--skip-resources',
+          ],
+          profileArg,
+          changeId
+        )
+      )
+    );
+  }
+  if (hasResourceTargets) {
+    steps.push(
+      ...buildTargetedResourceReleaseSteps(targets, profileArg, changeId)
+    );
+  }
+  return steps;
+}
+
+function releasePlanHash(value) {
+  return crypto
+    .createHash('sha256')
+    .update(canonicalJson(value))
+    .digest('hex');
+}
+
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(item => canonicalJson(item)).join(',')}]`;
+  }
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value)
+      .sort()
+      .map(key => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+module.exports = {
+  buildTargetedResourceReleaseCommands,
+  buildTargetedResourceReleaseSteps,
+  buildWorkspaceReleaseCommands,
+  buildWorkspaceReleaseSteps,
+  commandFromArgs,
+  normalizeReleaseTargets,
+  releasePlanHash,
+};