@stratixlabs/core 1.7.1

package/scripts/detect-breaking-changes.js

@@ -0,0 +1,155 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function isLeaf(node) {
+  if (!node || typeof node !== 'object' || Array.isArray(node)) return false;
+  const keys = Object.keys(node);
+  return keys.includes('value') && keys.includes('type') && keys.includes('originalVariable');
+}
+
+function flattenTokens(obj, prefix, map) {
+  if (isLeaf(obj)) {
+    map[prefix] = {
+      value: obj.value,
+      type: obj.type,
+      originalVariable: obj.originalVariable,
+    };
+    return;
+  }
+  if (!obj || typeof obj !== 'object') return;
+  for (const key of Object.keys(obj)) {
+    const nextPrefix = prefix ? prefix + '.' + key : key;
+    flattenTokens(obj[key], nextPrefix, map);
+  }
+}
+
+function loadCurrentTokens() {
+  const cwd = process.cwd();
+  const tokensPath = path.join(cwd, 'tokens.json');
+  if (!fs.existsSync(tokensPath)) {
+    console.error('❌ tokens.json not found. Run "npm run build:tokens" first.');
+    process.exit(1);
+  }
+  const content = fs.readFileSync(tokensPath, 'utf8');
+  return JSON.parse(content);
+}
+
+function loadBaseTokens() {
+  try {
+    const baseRefEnv = process.env.TOKENS_BASE_REF || '';
+    const baseRef =
+      baseRefEnv.trim().length > 0
+        ? baseRefEnv.trim()
+        : 'origin/main';
+
+    execSync('git fetch origin --quiet', { stdio: 'ignore' });
+
+    let baseCommit = baseRef;
+    try {
+      const mergeBase = execSync(`git merge-base HEAD ${baseRef}`, { encoding: 'utf8' })
+        .toString()
+        .trim();
+      if (mergeBase) {
+        baseCommit = mergeBase;
+      }
+    } catch (error) {}
+
+    const output = execSync(`git show ${baseCommit}:tokens.json`, { encoding: 'utf8' });
+    return JSON.parse(output);
+  } catch (error) {
+    console.log('ℹ️ No base tokens.json found for breaking change detection; skipping.');
+    return null;
+  }
+}
+
+function main() {
+  const currentTokens = loadCurrentTokens();
+  const baseTokens = loadBaseTokens();
+
+  if (!baseTokens) {
+    console.log('ℹ️ Skipped breaking-change detection (no base tokens.json).');
+    return;
+  }
+
+  const currentMap = {};
+  const baseMap = {};
+
+  flattenTokens(currentTokens, '', currentMap);
+  flattenTokens(baseTokens, '', baseMap);
+
+  const removed = [];
+  const added = [];
+  const typeChanged = [];
+  const valueChanged = [];
+
+  for (const key of Object.keys(baseMap)) {
+    if (!Object.prototype.hasOwnProperty.call(currentMap, key)) {
+      removed.push({ path: key, from: baseMap[key] });
+    }
+  }
+
+  for (const key of Object.keys(currentMap)) {
+    if (!Object.prototype.hasOwnProperty.call(baseMap, key)) {
+      added.push({ path: key, to: currentMap[key] });
+    } else {
+      const before = baseMap[key];
+      const after = currentMap[key];
+      if (before.type !== after.type) {
+        typeChanged.push({ path: key, from: before.type, to: after.type });
+      } else if (before.value !== after.value) {
+        valueChanged.push({ path: key, from: before.value, to: after.value, type: after.type });
+      }
+    }
+  }
+
+  if (removed.length === 0 && typeChanged.length === 0 && valueChanged.length === 0) {
+    console.log('✅ No token changes detected compared to base tokens.json.');
+    return;
+  }
+
+  console.log('🔎 Token changes compared to base tokens.json:');
+
+  if (removed.length > 0) {
+    console.log('');
+    console.log(`Removed tokens (${removed.length}):`);
+    for (const item of removed) {
+      console.log(`  - ${item.path} [${item.from.type}] (value: ${item.from.value})`);
+    }
+  }
+
+  if (typeChanged.length > 0) {
+    console.log('');
+    console.log(`Tokens with type changes (${typeChanged.length}):`);
+    for (const item of typeChanged) {
+      console.log(`  - ${item.path}: ${item.from} → ${item.to}`);
+    }
+  }
+
+  if (valueChanged.length > 0) {
+    console.log('');
+    console.log(`Tokens with value changes (${valueChanged.length}):`);
+    for (const item of valueChanged) {
+      console.log(`  - ${item.path} [${item.type}]: ${item.from} → ${item.to}`);
+    }
+  }
+
+  const failOnValueChanges = process.env.TOKENS_FAIL_ON_VALUE_CHANGES === '1';
+
+  if (removed.length > 0 || typeChanged.length > 0 || (failOnValueChanges && valueChanged.length > 0)) {
+    console.error('');
+    console.error('❌ Breaking token changes detected.');
+    console.error('   Removed tokens and type changes require explicit review and a suitable release plan.');
+    if (failOnValueChanges && valueChanged.length > 0) {
+      console.error('   Value changes are configured to be treated as breaking by TOKENS_FAIL_ON_VALUE_CHANGES=1.');
+    }
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log('⚠️ No structural breaking changes detected, but some values changed.');
+  console.log('   Review the value changes above and rely on visual regression tests when needed.');
+}
+
+main();
+