@sun-asterisk/sungen 3.2.3 → 3.2.5

package/src/dashboard/snapshot-builder.ts

@@ -44,6 +44,9 @@ const DEFAULT_BASE_LOCALE = 'vi';
 
 export interface DashboardTarget {
   name: string;
+  kind: 'screen' | 'flow' | 'api';
+  /** Derived convenience (`kind === 'flow'`) — kept for the flow-specific
+   *  branches that predate the api tier. */
   isFlow: boolean;
 }
 
@@ -85,6 +88,23 @@ export function buildDashboardSnapshot(options: BuildSnapshotOptions): Dashboard
 // Per-target build
 // ----------------------------------------------------------------------------
 
+/**
+ * True when this is a mobile project (`platform: mobile` in qa/capabilities.yaml).
+ * Mobile projects run per-OS (android/ios) — the dashboard surfaces those on a
+ * distinct platform axis (one FeatureSnapshot per OS) rather than as locale tabs.
+ * Mirrors `isMobileProject` in src/cli/commands/delivery.ts.
+ */
+function isMobileProject(cwd: string): boolean {
+  try {
+    const p = path.join(cwd, 'qa', 'capabilities.yaml');
+    if (!fs.existsSync(p)) return false;
+    const parsed = parseYaml(fs.readFileSync(p, 'utf-8')) as { platform?: string } | null;
+    return parsed?.platform === 'mobile';
+  } catch {
+    return false;
+  }
+}
+
 function buildOneScreen(
   cwd: string,
   target: DashboardTarget,
@@ -105,28 +125,49 @@ function buildOneScreen(
   const specMdFile = path.join(base, 'requirements', 'spec.md');
   const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : undefined;
 
+  const mobile = isMobileProject(cwd);
   const features: FeatureSnapshot[] = [];
   for (const featureBaseName of featureBaseNames) {
-    const fs2 = buildOneFeature(cwd, target, featureBaseName, env, specLink);
-    if (fs2) features.push(fs2);
+    features.push(...buildOneFeature(cwd, target, featureBaseName, env, specLink, mobile));
   }
   if (features.length === 0) return null;
 
   // Flat scenarios across all features (each scenario already carries its
   // own `featureBaseName`, so consumers that want to group can do so cheaply).
+  // For mobile, per-OS features flatten here so the Compare view can key each
+  // scenario by (tcId, platform) via its OS-precise testEnvironment.
   const scenarios = features.flatMap((f) => f.scenarios);
-  const label = target.isFlow ? `flow/${target.name}` : target.name;
-  const primary = features[0];
+  const label = target.kind === 'flow' ? `flow/${target.name}`
+    : target.kind === 'api' ? `api/${target.name}`
+    : target.name;
+
+  // Screen-level platform axis: 'mobile' when any feature is OS-tagged; the
+  // union of OSes that actually produced a result file this run.
+  const execSet = new Set<'android' | 'ios'>();
+  let anyPlatform = false;
+  for (const f of features) {
+    if (f.platform) anyPlatform = true;
+    for (const p of f.executedPlatforms ?? []) execSet.add(p);
+  }
+  const executedPlatforms = execSet.size > 0
+    ? (['android', 'ios'] as const).filter((p) => execSet.has(p))
+    : undefined;
+  // Representative feature for the back-compat top-level fields: prefer Android
+  // (deterministic, matches delivery's summary-row preference).
+  const primary = features.find((f) => f.platform === 'android') ?? features[0];
 
   return {
     name: label,
     isFlow: target.isFlow,
+    kind: target.kind,
+    platform: anyPlatform ? 'mobile' : undefined,
     featureName: primary.featureName,
     featurePath: primary.featurePath,
     specLink,
     summary: rollupScreenSummary(features),
     scenarios,
     features,
+    executedPlatforms,
   };
 }
 
@@ -141,14 +182,15 @@ function buildOneFeature(
   featureBaseName: string,
   env: EnvironmentInfo,
   specLink: string | undefined,
-): FeatureSnapshot | null {
+  mobile: boolean,
+): FeatureSnapshot[] {
   const base = qaDir(cwd, target);
   const genBase = generatedDir(cwd, target);
   const featureFile = path.join(base, 'features', `${featureBaseName}.feature`);
   const testDataFile = path.join(base, 'test-data', `${featureBaseName}.yaml`);
   const specFile = path.join(genBase, `${featureBaseName}.spec.ts`);
 
-  if (!fs.existsSync(featureFile)) return null;
+  if (!fs.existsSync(featureFile)) return [];
 
   const feature = parseFeatureMetadata(featureFile);
   const spec = fs.existsSync(specFile)
@@ -168,27 +210,16 @@ function buildOneFeature(
   // Discover locale variants by scanning <feature>-test-result*.json files.
   // Always includes base ('') as the first entry, even if its results file
   // is missing — UI still needs to render the feature.
-  // NOTE (mobile): for a `platform: mobile` project the "locale" variants are
-  // actually the per-OS runs (android / ios) — the dashboard reuses the locale
-  // switcher to surface them as tabs. The env column per tab is OS-precise (see
-  // resolvePlatformAppId below), but the top-level featurePath (base variant)
-  // defaults to the Android id. Delivery has a dedicated per-OS path; aligning the
-  // dashboard onto a distinct "platform" axis is a possible follow-up.
   const variants = discoverLocaleVariants(genBase, featureBaseName);
 
-  // Build per-locale ScreenSnapshot, then collect into FeatureSnapshot.locales[].
-  // Base variant is also used to populate the top-level (`scenarios`, `summary`)
-  // for back-compat with consumers that don't read the locales array.
-  const locales: LocaleSnapshot[] = [];
-  let baseBuilt: { scenarios: ScenarioSnapshot[]; summary: ScreenSummaryStats; featureName: string; featurePath?: string; specLink?: string } | null = null;
-
-  for (const variant of variants) {
+  // Build one per-variant ScreenSnapshot (test-data overlay + results + OS-precise
+  // env column). Reused by both the web/i18n (locale-axis) and mobile (platform-axis) paths.
+  const buildVariant = (variant: FeatureLocaleVariant) => {
     const testData = fs.existsSync(testDataFile)
       ? loadTestData(testDataFile, variant.locale || null)
       : {};
     const results = variant.resultsPath ? loadPlaywrightReport(variant.resultsPath) : null;
-
-    const built = buildScreenSnapshot({
+    return buildScreenSnapshot({
       screen: featureBaseName,
       isFlow: target.isFlow,
       featureName: feature.featureName,
@@ -203,17 +234,65 @@ function buildOneFeature(
       featureBaseName,
       selectorKeyMap,
     });
+  };
+  type Built = ReturnType<typeof buildVariant>;
+
+  // -- Mobile (platform axis): the per-OS runs (android / ios) are their own
+  //    FeatureSnapshot entries — one per OS, `platform` tagged — NOT locale tabs.
+  //    Locale overlays for a given OS (e.g. `android.ja`) nest inside that OS's
+  //    entry as `locales[]`. This mirrors the delivery per-OS deliverables. --
+  if (mobile) {
+    const osOf = (loc: string): 'android' | 'ios' | null =>
+      /^android(\.|$)/.test(loc) ? 'android' : /^ios(\.|$)/.test(loc) ? 'ios' : null;
+    const osVariants = variants.filter((v) => osOf(v.locale));
+    if (osVariants.length > 0) {
+      const executedPlatforms = (['android', 'ios'] as const).filter((os) =>
+        osVariants.some((v) => osOf(v.locale) === os && v.resultsPath)
+      );
+      const feats: FeatureSnapshot[] = [];
+      for (const os of ['android', 'ios'] as const) {
+        const group = osVariants.filter((v) => osOf(v.locale) === os);
+        if (group.length === 0) continue;
+        const localeSnaps: LocaleSnapshot[] = [];
+        let primaryBuilt: Built | null = null;
+        for (const v of group) {
+          const built = buildVariant(v);
+          localeSnaps.push({ locale: v.locale, displayCode: v.displayCode, summary: built.summary, scenarios: built.scenarios });
+          // Representative = the bare OS run (locale === os); else the first overlay.
+          if (v.locale === os || !primaryBuilt) primaryBuilt = built;
+        }
+        if (!primaryBuilt) continue;
+        feats.push({
+          featureBaseName,
+          featureName: primaryBuilt.featureName,
+          featurePath: primaryBuilt.featurePath,
+          specLink: primaryBuilt.specLink,
+          summary: primaryBuilt.summary,
+          scenarios: primaryBuilt.scenarios,
+          platform: os,
+          executedPlatforms,
+          locales: localeSnaps.length >= 2 ? localeSnaps : undefined,
+        });
+      }
+      if (feats.length > 0) return feats;
+    }
+    // Mobile project but no per-OS result files yet → fall through to the base
+    // (locale-axis) path so the test CASES still render.
+  }
+
+  // -- Web / i18n (locale axis): one FeatureSnapshot; variants become locales[]. --
+  const locales: LocaleSnapshot[] = [];
+  let baseBuilt: Built | { scenarios: ScenarioSnapshot[]; summary: ScreenSummaryStats; featureName: string; featurePath?: string; specLink?: string } | null = null;
 
+  for (const variant of variants) {
+    const built = buildVariant(variant);
     locales.push({
       locale: variant.locale,
       displayCode: variant.displayCode,
       summary: built.summary,
       scenarios: built.scenarios,
     });
-
-    if (variant.locale === '') {
-      baseBuilt = built;
-    }
+    if (variant.locale === '') baseBuilt = built;
   }
 
   // Guarantee a base entry — every feature in the dashboard must have
@@ -227,9 +306,9 @@ function buildOneFeature(
       specLink,
     };
   }
-  if (!baseBuilt) return null;
+  if (!baseBuilt) return [];
 
-  return {
+  return [{
     featureBaseName,
     featureName: baseBuilt.featureName,
     featurePath: baseBuilt.featurePath,
@@ -239,7 +318,7 @@ function buildOneFeature(
     // Only expose `locales` array when 2+ variants exist — single-locale
     // features stay slimmer and UI can skip the locale tab UI entirely.
     locales: locales.length >= 2 ? locales : undefined,
-  };
+  }];
 }
 
 /**
@@ -361,14 +440,24 @@ function bumpKey(record: Record<string, number>, key: string): void {
 // Path helpers (mirror delivery.ts to stay consistent)
 // ----------------------------------------------------------------------------
 
+/** qa/ subfolder for a unit kind (mirrors delivery.ts's qaParent). */
+function qaParent(kind: DashboardTarget['kind']): string {
+  return kind === 'flow' ? 'flows' : kind === 'api' ? 'api' : 'screens';
+}
+
 function qaDir(cwd: string, target: DashboardTarget): string {
-  return path.join(cwd, 'qa', target.isFlow ? 'flows' : 'screens', target.name);
+  return path.join(cwd, 'qa', qaParent(target.kind), target.name);
 }
 
 function generatedDir(cwd: string, target: DashboardTarget): string {
-  return target.isFlow
-    ? path.join(cwd, 'specs', 'generated', 'flows', target.name)
-    : path.join(cwd, 'specs', 'generated', target.name);
+  // Mirrors delivery.ts: screen → specs/generated/<name>, flow → …/flows/<name>,
+  // api → …/api/<name> (api flows carry name 'flows/<flow>', composing correctly).
+  const sub = target.kind === 'flow'
+    ? path.join('flows', target.name)
+    : target.kind === 'api'
+      ? path.join('api', target.name)
+      : target.name;
+  return path.join(cwd, 'specs', 'generated', sub);
 }
 
 // ----------------------------------------------------------------------------
@@ -378,17 +467,23 @@ function generatedDir(cwd: string, target: DashboardTarget): string {
 export function listDashboardTargets(cwd: string): DashboardTarget[] {
   const targets: DashboardTarget[] = [];
 
-  const screensDir = path.join(cwd, 'qa', 'screens');
-  if (fs.existsSync(screensDir)) {
-    for (const d of fs.readdirSync(screensDir, { withFileTypes: true })) {
-      if (d.isDirectory()) targets.push({ name: d.name, isFlow: false });
+  const scan = (kind: DashboardTarget['kind'], skip: (n: string) => boolean = () => false): void => {
+    const dir = path.join(cwd, 'qa', qaParent(kind));
+    if (!fs.existsSync(dir)) return;
+    for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (d.isDirectory() && !skip(d.name)) targets.push({ name: d.name, kind, isFlow: kind === 'flow' });
     }
-  }
-
-  const flowsDir = path.join(cwd, 'qa', 'flows');
-  if (fs.existsSync(flowsDir)) {
-    for (const d of fs.readdirSync(flowsDir, { withFileTypes: true })) {
-      if (d.isDirectory()) targets.push({ name: d.name, isFlow: true });
+  };
+  scan('screen');
+  scan('flow');
+  scan('api', (n) => n === 'flows');  // api areas: qa/api/<area> (the flows/ container is a nested tier)
+
+  // api flows: qa/api/flows/<flow> → name 'flows/<flow>', kind 'api'
+  // (paths compose to qa/api/flows/… + specs/generated/api/flows/…), mirroring delivery.ts.
+  const apiFlowsRoot = path.join(cwd, 'qa', 'api', 'flows');
+  if (fs.existsSync(apiFlowsRoot)) {
+    for (const d of fs.readdirSync(apiFlowsRoot, { withFileTypes: true })) {
+      if (d.isDirectory()) targets.push({ name: path.posix.join('flows', d.name), kind: 'api', isFlow: false });
     }
   }
 
@@ -396,10 +491,15 @@ export function listDashboardTargets(cwd: string): DashboardTarget[] {
 }
 
 export function resolveTargetType(cwd: string, name: string): DashboardTarget {
-  if (fs.existsSync(path.join(cwd, 'qa', 'flows', name))) {
-    return { name, isFlow: true };
-  }
-  return { name, isFlow: false };
+  if (fs.existsSync(path.join(cwd, 'qa', 'flows', name))) return { name, kind: 'flow', isFlow: true };
+  // Screen before api so `dashboard <name>` resolves the same unit as `delivery <name>`
+  // when a repo has both qa/screens/<name> and qa/api/<name> (delivery.ts precedence).
+  if (fs.existsSync(path.join(cwd, 'qa', 'screens', name))) return { name, kind: 'screen', isFlow: false };
+  if (fs.existsSync(path.join(cwd, 'qa', 'api', name))) return { name, kind: 'api', isFlow: false };
+  // `flows/<flow>` or a bare api-flow name → qa/api/flows/<flow>
+  const apiFlow = name.startsWith('flows/') ? name : path.posix.join('flows', name);
+  if (fs.existsSync(path.join(cwd, 'qa', 'api', apiFlow))) return { name: apiFlow, kind: 'api', isFlow: false };
+  return { name, kind: 'screen', isFlow: false };
 }
 
 // ----------------------------------------------------------------------------