Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

fix(scripts): merge staged codemods into a pre-existing version folder (#4719)

Cindy Zhange37aae77cfd0
diff --git a/scripts/promote-codemod-next.mjs b/scripts/promote-codemod-next.mjs
index 685da04464..20fd4f82cf 100755
--- a/scripts/promote-codemod-next.mjs
+++ b/scripts/promote-codemod-next.mjs
@@ -4,6 +4,17 @@
* Promote staged codemods from transforms/next into the just-bumped release
* version folder. Run after `changeset version`, when package.json contains
* the actual version this release will publish.
+ *
+ * The target version folder MAY already exist and already contain codemods —
+ * e.g. a codemod PR that merged earlier in the release cycle seeded
+ * `transforms/vX.Y.Z/` directly, and later feature PRs staged additional
+ * codemods under `transforms/next/`. In that case promotion MERGES the staged
+ * codemods into the existing folder rather than failing:
+ * - transform modules are moved in (a same-named transform is a real
+ * conflict and still errors);
+ * - `__tests__/` contents are merged (a same-named test file still errors);
+ * - the two `index.mjs` manifests are merged into one (existing entries
+ * first, then the newly-staged ones, de-duplicated by transform name).
*/
import fs from 'node:fs';
@@ -13,6 +24,8 @@ import {fileURLToPath} from 'node:url';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const DEFAULT_ROOT = path.resolve(__dirname, '..');
const README = 'README.md';
+const INDEX = 'index.mjs';
+const TESTS = '__tests__';
function readJson(file) {
return JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -44,10 +57,132 @@ function copyRecursive(src, dest) {
fs.copyFileSync(src, dest, fs.constants.COPYFILE_EXCL);
}
+/**
+ * Merge one directory (e.g. `__tests__`) into an existing target directory.
+ * Files are copied in; a same-named file is a genuine conflict and throws.
+ * Sub-directories recurse with the same rule.
+ */
+function mergeDirInto(src, dest, root) {
+ fs.mkdirSync(dest, {recursive: true});
+ for (const entry of fs.readdirSync(src, {withFileTypes: true})) {
+ const from = path.join(src, entry.name);
+ const to = path.join(dest, entry.name);
+ if (entry.isDirectory()) {
+ mergeDirInto(from, to, root);
+ } else {
+ if (fs.existsSync(to)) {
+ throw new Error(
+ `codemod-next: refusing to overwrite existing ${path.relative(root, to)}`,
+ );
+ }
+ fs.copyFileSync(from, to, fs.constants.COPYFILE_EXCL);
+ }
+ }
+}
+
function removeRecursive(src) {
fs.rmSync(src, {recursive: true, force: true});
}
+/**
+ * Merge two codemod `index.mjs` manifests into one.
+ *
+ * Both files follow the same shape: a block of `import ... from './x.mjs';`
+ * statements followed by `export default [ {name, transform, meta}, ... ];`.
+ * The merged manifest keeps the existing (target) imports and entries first,
+ * then appends the staged (next) ones, skipping any whose transform `name`
+ * is already present so a re-run or overlap can't duplicate an entry.
+ */
+function mergeIndexManifests(existingSrc, stagedSrc) {
+ const takeImports = src => {
+ const lines = src.split('\n');
+ const start = lines.findIndex(l => l.startsWith('import '));
+ const exp = lines.findIndex(l => l.startsWith('export default'));
+ if (start === -1 || exp === -1) {
+ throw new Error(
+ 'codemod-next: could not parse an index.mjs manifest (missing import block or `export default`).',
+ );
+ }
+ return lines.slice(start, exp).join('\n').replace(/\n+$/, '');
+ };
+
+ const takeEntries = src => {
+ const open = src.indexOf('export default [');
+ const close = src.lastIndexOf('];');
+ if (open === -1 || close === -1) {
+ throw new Error(
+ 'codemod-next: could not parse an index.mjs manifest (missing `export default [ ... ];`).',
+ );
+ }
+ const body = src.slice(open + 'export default ['.length, close);
+ // Split top-level `{ ... }` objects.
+ const entries = [];
+ let depth = 0;
+ let buf = '';
+ for (const ch of body) {
+ if (ch === '{') {
+ if (depth === 0) buf = '';
+ depth++;
+ buf += ch;
+ } else if (ch === '}') {
+ depth--;
+ buf += ch;
+ if (depth === 0) entries.push(buf.trim());
+ } else if (depth > 0) {
+ buf += ch;
+ }
+ }
+ return entries;
+ };
+
+ const nameOf = entry => {
+ const m = entry.match(/name:\s*['"]([^'"]+)['"]/);
+ return m ? m[1] : null;
+ };
+
+ const header = existingSrc.slice(0, existingSrc.indexOf('import '));
+ const existingImports = takeImports(existingSrc);
+ const stagedImports = takeImports(stagedSrc);
+ const existingEntries = takeEntries(existingSrc);
+ const stagedEntries = takeEntries(stagedSrc);
+
+ const seen = new Set(existingEntries.map(nameOf).filter(Boolean));
+ const mergedEntries = [...existingEntries];
+ for (const entry of stagedEntries) {
+ const name = nameOf(entry);
+ if (name && seen.has(name)) continue;
+ if (name) seen.add(name);
+ mergedEntries.push(entry);
+ }
+
+ // Keep every staged import line. If a staged entry was skipped as a
+ // duplicate its import may go unused, but lint auto-fixes unused imports and
+ // this keeps the merge deterministic and easy to review.
+ const importBlock = `${existingImports}\n${stagedImports}`;
+
+ const entriesText = mergedEntries.map(e => ` ${e},`).join('\n');
+ return `${header}${importBlock}\n\nexport default [\n${entriesText}\n];\n`;
+}
+
+async function formatWithPrettier(root, files) {
+ let prettier;
+ try {
+ prettier = (await import('prettier')).default ?? (await import('prettier'));
+ } catch {
+ return; // prettier unavailable — leave files as-is (format-changelogs step / lint will catch)
+ }
+ for (const file of files) {
+ if (!fs.existsSync(file)) continue;
+ const source = fs.readFileSync(file, 'utf8');
+ const config = (await prettier.resolveConfig(file)) ?? {};
+ const formatted = await prettier.format(source, {
+ ...config,
+ filepath: file,
+ });
+ fs.writeFileSync(file, formatted);
+ }
+}
+
function ensureRegistryEntry(registryPath, version) {
const text = fs.readFileSync(registryPath, 'utf8');
const entry = ` ['${version}', () => import('./transforms/v${version}/index.mjs')],`;
@@ -64,7 +199,7 @@ function ensureRegistryEntry(registryPath, version) {
return true;
}
-export function promoteCodemodNext({root = DEFAULT_ROOT} = {}) {
+export async function promoteCodemodNext({root = DEFAULT_ROOT} = {}) {
const corePackage = path.join(root, 'packages/core/package.json');
const transformsDir = path.join(
root,
@@ -92,20 +227,54 @@ export function promoteCodemodNext({root = DEFAULT_ROOT} = {}) {
);
}
- if (!entries.some(entry => entry.name === 'index.mjs')) {
+ if (!entries.some(entry => entry.name === INDEX)) {
throw new Error(
'codemod-next: staged codemods must include next/index.mjs so the promoted version folder is registry-loadable.',
);
}
const versionDir = path.join(transformsDir, `v${version}`);
- if (!fs.existsSync(versionDir)) fs.mkdirSync(versionDir, {recursive: true});
+ const versionFolderPreexisted = fs.existsSync(versionDir);
+ if (!versionFolderPreexisted) fs.mkdirSync(versionDir, {recursive: true});
+ const existingIndexPath = path.join(versionDir, INDEX);
+ const mergingIntoExistingIndex =
+ versionFolderPreexisted && fs.existsSync(existingIndexPath);
/** @type {Array<{from: string, to: string}>} */
const promoted = [];
+ const filesToFormat = [];
for (const entry of entries) {
const src = path.join(nextDir, entry.name);
const dest = path.join(versionDir, entry.name);
+
+ // index.mjs: merge manifests when the target folder already has one.
+ if (entry.name === INDEX && mergingIntoExistingIndex) {
+ const merged = mergeIndexManifests(
+ fs.readFileSync(existingIndexPath, 'utf8'),
+ fs.readFileSync(src, 'utf8'),
+ );
+ fs.writeFileSync(existingIndexPath, merged);
+ filesToFormat.push(existingIndexPath);
+ removeRecursive(src);
+ promoted.push({
+ from: path.relative(root, src),
+ to: path.relative(root, dest),
+ });
+ continue;
+ }
+
+ // __tests__ (or any directory): merge contents into an existing dir.
+ if (entry.isDirectory() && fs.existsSync(dest)) {
+ mergeDirInto(src, dest, root);
+ removeRecursive(src);
+ promoted.push({
+ from: path.relative(root, src),
+ to: path.relative(root, dest),
+ });
+ continue;
+ }
+
+ // Default: move the file/dir in; a same-named target is a real conflict.
if (fs.existsSync(dest)) {
throw new Error(
`codemod-next: refusing to overwrite existing ${path.relative(root, dest)}`,
@@ -119,12 +288,38 @@ export function promoteCodemodNext({root = DEFAULT_ROOT} = {}) {
});
}
+ // Re-seed next/ with an empty manifest so the folder stays valid + reusable.
+ writeText(
+ path.join(nextDir, INDEX),
+ [
+ '// Copyright (c) Meta Platforms, Inc. and affiliates.',
+ '',
+ '/**',
+ ' * @file next transform manifest',
+ ' *',
+ ' * Staged codemods for the next release. The Version Packages PR promotes',
+ ' * this file into the resolved version folder.',
+ ' */',
+ '',
+ 'export default [];',
+ ].join('\n'),
+ );
+ filesToFormat.push(path.join(nextDir, INDEX));
+
const registryUpdated = ensureRegistryEntry(registryPath, version);
- return {version, promoted, registryUpdated};
+
+ await formatWithPrettier(root, filesToFormat);
+
+ return {
+ version,
+ promoted,
+ registryUpdated,
+ mergedIntoExisting: mergingIntoExistingIndex,
+ };
}
-function main() {
- const result = promoteCodemodNext();
+async function main() {
+ const result = await promoteCodemodNext();
if (result.message) {
console.log(result.message);
return;
@@ -138,7 +333,7 @@ function main() {
);
}
console.log(
- `codemod-next: promoted ${result.promoted.length} entr${result.promoted.length === 1 ? 'y' : 'ies'} into v${result.version}.`,
+ `codemod-next: promoted ${result.promoted.length} entr${result.promoted.length === 1 ? 'y' : 'ies'} into v${result.version}${result.mergedIntoExisting ? ' (merged into existing folder)' : ''}.`,
);
}
diff --git a/scripts/promote-codemod-next.test.mjs b/scripts/promote-codemod-next.test.mjs
index d96fed5116..b311f292a1 100644
--- a/scripts/promote-codemod-next.test.mjs
+++ b/scripts/promote-codemod-next.test.mjs
@@ -37,31 +37,40 @@ function scaffold({version = '0.4.0'} = {}) {
return {root: tmpDir, transforms};
}
+/** Minimal, well-formed staged index.mjs for one transform. */
+function stagedIndex(name, importName) {
+ return (
+ `// Copyright (c) Meta Platforms, Inc. and affiliates.\n\n` +
+ `import ${importName}, {meta as ${importName}Meta} from './${name}.mjs';\n\n` +
+ `export default [\n {name: '${name}', transform: ${importName}, meta: ${importName}Meta},\n];\n`
+ );
+}
+
describe('promoteCodemodNext', () => {
- it('does nothing when only the next README exists', () => {
+ it('does nothing when only the next README exists', async () => {
const {root, transforms} = scaffold();
fs.writeFileSync(path.join(transforms, 'next', 'README.md'), '# Next\n');
- const result = promoteCodemodNext({root});
+ const result = await promoteCodemodNext({root});
expect(result.promoted).toEqual([]);
expect(result.registryUpdated).toBe(false);
expect(result.message).toContain('no staged codemods');
});
- it('promotes staged files into the current package version and registers it', () => {
+ it('promotes staged files into the current package version and registers it', async () => {
const {root, transforms} = scaffold({version: '0.4.0'});
fs.writeFileSync(path.join(transforms, 'next', 'README.md'), '# Next\n');
fs.writeFileSync(
path.join(transforms, 'next', 'index.mjs'),
- 'export default [];\n',
+ stagedIndex('rename-thing', 'renameThing'),
);
fs.writeFileSync(
path.join(transforms, 'next', 'rename-thing.mjs'),
- 'export default function transform() {}\n',
+ 'export default function transform() {}\nexport const meta = {};\n',
);
- const result = promoteCodemodNext({root});
+ const result = await promoteCodemodNext({root});
expect(result.version).toBe('0.4.0');
expect(result.promoted.map(entry => entry.to).sort()).toEqual([
@@ -69,12 +78,13 @@ describe('promoteCodemodNext', () => {
'packages/cli/assets/codemods/transforms/v0.4.0/rename-thing.mjs',
]);
expect(result.registryUpdated).toBe(true);
+ // next/ keeps its README and is re-seeded with an empty manifest.
expect(fs.existsSync(path.join(transforms, 'next', 'README.md'))).toBe(
true,
);
- expect(fs.existsSync(path.join(transforms, 'next', 'index.mjs'))).toBe(
- false,
- );
+ expect(
+ fs.readFileSync(path.join(transforms, 'next', 'index.mjs'), 'utf8'),
+ ).toContain('export default [];');
expect(fs.existsSync(path.join(transforms, 'v0.4.0', 'index.mjs'))).toBe(
true,
);
@@ -86,28 +96,124 @@ describe('promoteCodemodNext', () => {
).toContain("['0.4.0', () => import('./transforms/v0.4.0/index.mjs')]");
});
- it('requires a next index manifest when staged transforms exist', () => {
+ it('requires a next index manifest when staged transforms exist', async () => {
const {root, transforms} = scaffold();
fs.writeFileSync(
path.join(transforms, 'next', 'rename-thing.mjs'),
'export default function transform() {}\n',
);
- expect(() => promoteCodemodNext({root})).toThrow(/next\/index\.mjs/);
+ await expect(promoteCodemodNext({root})).rejects.toThrow(
+ /next\/index\.mjs/,
+ );
});
- it('refuses to overwrite an existing version-folder file', () => {
- const {root, transforms} = scaffold({version: '0.4.0'});
+ it('merges staged codemods into a pre-existing version folder (seeded by an earlier codemod PR)', async () => {
+ const {root, transforms} = scaffold({version: '0.3.0'});
+ // Pre-existing v0.3.0 folder from a codemod PR that merged earlier.
+ const vdir = path.join(transforms, 'v0.3.0');
+ fs.mkdirSync(path.join(vdir, '__tests__'), {recursive: true});
+ fs.writeFileSync(
+ path.join(vdir, 'existing-codemod.mjs'),
+ 'export default function transform() {}\nexport const meta = {};\n',
+ );
+ fs.writeFileSync(
+ path.join(vdir, 'index.mjs'),
+ stagedIndex('existing-codemod', 'existingCodemod'),
+ );
+ fs.writeFileSync(
+ path.join(vdir, '__tests__', 'existing-codemod.test.mjs'),
+ 'export default {};\n',
+ );
+ // Newly staged codemod in next/.
+ fs.mkdirSync(path.join(transforms, 'next', '__tests__'), {recursive: true});
+ fs.writeFileSync(path.join(transforms, 'next', 'README.md'), '# Next\n');
+ fs.writeFileSync(
+ path.join(transforms, 'next', 'new-codemod.mjs'),
+ 'export default function transform() {}\nexport const meta = {};\n',
+ );
+ fs.writeFileSync(
+ path.join(transforms, 'next', 'index.mjs'),
+ stagedIndex('new-codemod', 'newCodemod'),
+ );
+ fs.writeFileSync(
+ path.join(transforms, 'next', '__tests__', 'new-codemod.test.mjs'),
+ 'export default {};\n',
+ );
+
+ const result = await promoteCodemodNext({root});
+ expect(result.mergedIntoExisting).toBe(true);
+
+ // Both transforms + both tests now live in v0.3.0.
+ expect(fs.existsSync(path.join(vdir, 'existing-codemod.mjs'))).toBe(true);
+ expect(fs.existsSync(path.join(vdir, 'new-codemod.mjs'))).toBe(true);
+ expect(
+ fs.existsSync(path.join(vdir, '__tests__', 'existing-codemod.test.mjs')),
+ ).toBe(true);
+ expect(
+ fs.existsSync(path.join(vdir, '__tests__', 'new-codemod.test.mjs')),
+ ).toBe(true);
+
+ // Merged manifest lists BOTH transforms (existing first, then new).
+ const merged = fs.readFileSync(path.join(vdir, 'index.mjs'), 'utf8');
+ expect(merged).toMatch(/name: ['"]existing-codemod['"]/);
+ expect(merged).toMatch(/name: ['"]new-codemod['"]/);
+ expect(merged.search(/['"]existing-codemod['"]/)).toBeLessThan(
+ merged.search(/['"]new-codemod['"]/),
+ );
+
+ // next/ drained (README kept, manifest reset, staged files gone).
+ expect(
+ fs.existsSync(path.join(transforms, 'next', 'new-codemod.mjs')),
+ ).toBe(false);
+ expect(fs.existsSync(path.join(transforms, 'next', 'README.md'))).toBe(
+ true,
+ );
+
+ // registry already had 0.3.0 — not double-added.
+ expect(result.registryUpdated).toBe(false);
+ });
+
+ it('de-duplicates a staged transform whose name already exists in the version folder', async () => {
+ const {root, transforms} = scaffold({version: '0.3.0'});
+ const vdir = path.join(transforms, 'v0.3.0');
+ fs.mkdirSync(vdir, {recursive: true});
+ fs.writeFileSync(
+ path.join(vdir, 'index.mjs'),
+ stagedIndex('shared-name', 'sharedA'),
+ );
+ fs.writeFileSync(path.join(transforms, 'next', 'README.md'), '# Next\n');
fs.writeFileSync(
path.join(transforms, 'next', 'index.mjs'),
- 'export default [];\n',
+ stagedIndex('shared-name', 'sharedB'),
);
+
+ const result = await promoteCodemodNext({root});
+ const merged = fs.readFileSync(path.join(vdir, 'index.mjs'), 'utf8');
+ // Only ONE entry for the shared name.
+ expect(merged.match(/name: ['"]shared-name['"]/g)).toHaveLength(1);
+ expect(result.mergedIntoExisting).toBe(true);
+ });
+
+ it('still refuses to overwrite a same-named transform file in the version folder', async () => {
+ const {root, transforms} = scaffold({version: '0.4.0'});
fs.mkdirSync(path.join(transforms, 'v0.4.0'), {recursive: true});
fs.writeFileSync(
- path.join(transforms, 'v0.4.0', 'index.mjs'),
- 'export default [];\n',
+ path.join(transforms, 'v0.4.0', 'collide.mjs'),
+ 'export default function transform() {}\n',
+ );
+ fs.writeFileSync(path.join(transforms, 'next', 'README.md'), '# Next\n');
+ fs.writeFileSync(
+ path.join(transforms, 'next', 'index.mjs'),
+ stagedIndex('collide', 'collide'),
+ );
+ fs.writeFileSync(
+ path.join(transforms, 'next', 'collide.mjs'),
+ 'export default function transform() {}\n',
);
- expect(() => promoteCodemodNext({root})).toThrow(/refusing to overwrite/);
+ await expect(promoteCodemodNext({root})).rejects.toThrow(
+ /refusing to overwrite/,
+ );
});
});