openxiangda 1.0.172 → 1.0.174

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,
+};

package/lib/runtime-lineage.js

@@ -2,6 +2,7 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const { readGitSourceBase } = require('./change-baseline');
+const { identitiesIntersect } = require('./git-remote-identity');
 
 const MIN_ROLLBACK_REASON_LENGTH = 8;
 const PURE_RUNTIME_OUTPUT_PREFIXES = Object.freeze([
@@ -58,7 +59,13 @@ function prepareRuntimeDeployLineage(options = {}) {
 
   const legacyBootstrap = Boolean(parentReleaseId && !parentSourceRevision);
   if (parentSourceRevision) {
-    const sameRepository = parentSourceRevision.repo === sourceRevision.repo;
+    const sameRepository = identitiesIntersect(
+      [
+        parentSourceRevision.repo,
+        ...(parentSourceRevision.repoAliases || []),
+      ],
+      [sourceRevision.repo, ...(sourceRevision.repoAliases || [])]
+    );
     const descendsFromActive =
       sameRepository &&
       isGitAncestor(cwd, parentSourceRevision.baseCommit, sourceRevision.baseCommit);
@@ -73,7 +80,13 @@ function prepareRuntimeDeployLineage(options = {}) {
       );
     }
     return stripUndefinedValues({
-      sourceRevision,
+      sourceRevision: sameRepository
+        ? {
+            ...sourceRevision,
+            repo: parentSourceRevision.repo,
+            repositoryId: parentSourceRevision.repo,
+          }
+        : sourceRevision,
       parentReleaseId,
       parentSourceRevision,
       lineageBypassReason: rollback.enabled ? rollback.reason : undefined,
@@ -246,7 +259,14 @@ function normalizeRuntimeSourceRevision(value, options = {}) {
       '线上 Runtime source revision 缺少有效的 repo/baseCommit/treeHash'
     );
   }
-  return { repo, baseCommit, treeHash };
+  const repoAliases = Array.from(
+    new Set(
+      [repo, ...(Array.isArray(input.repoAliases) ? input.repoAliases : [])]
+        .map(item => String(item || '').trim().toLowerCase())
+        .filter(item => /^sha256:[0-9a-f]{64}$/.test(item))
+    )
+  );
+  return { repo, repoAliases, baseCommit, treeHash };
 }
 
 function normalizeAppSnapshot(value) {