ember-codemod-v1-to-v2 0.6.3 → 0.7.1-alpha.1

package/README.md

@@ -102,7 +102,12 @@ To better meet your needs, consider cloning the repo and running the codemod loc
 
 ```sh
 cd <your/cloned/repo>
-./bin/ember-codemod-v1-to-v2.js --root=<your/project/path>
+
+# Compile TypeScript
+pnpm build
+
+# Run codemod
+./dist/bin/ember-codemod-v1-to-v2.js --root=<your/project/path>
 ```
 
 You can also look at another codemod called [`ember-addon-migrator`](https://github.com/NullVoxPopuli/ember-addon-migrator).

package/dist/bin/ember-codemod-v1-to-v2.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// eslint-disable-next-line n/shebang
+'use strict';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { runCodemod } from '../src/index.js';
+// Provide a title to the process in `ps`
+process.title = 'ember-codemod-v1-to-v2';
+// Set codemod options
+const argv = yargs(hideBin(process.argv))
+    .option('addon-location', {
+    describe: 'Location of the addon package',
+    type: 'string',
+})
+    .option('root', {
+    describe: 'Location of your Ember addon',
+    type: 'string',
+})
+    .option('test-app-location', {
+    describe: 'Location of the test-app package',
+    type: 'string',
+})
+    .option('test-app-name', {
+    describe: 'Name of the test-app package',
+    type: 'string',
+})
+    .parseSync();
+function castEmptyStringToUndefined(value) {
+    return value === '' ? undefined : value;
+}
+const codemodOptions = {
+    addonLocation: castEmptyStringToUndefined(argv['addon-location']),
+    projectRoot: argv['root'] ?? process.cwd(),
+    testAppLocation: castEmptyStringToUndefined(argv['test-app-location']),
+    testAppName: castEmptyStringToUndefined(argv['test-app-name']),
+};
+runCodemod(codemodOptions);

package/{src → dist/src}/index.js

@@ -1,5 +1,4 @@
 import { migrateEmberAddon } from './migration/index.js';
-
 export function runCodemod(codemodOptions) {
-  migrateEmberAddon(codemodOptions);
+    migrateEmberAddon(codemodOptions);
 }

package/dist/src/migration/ember-addon/index.js

@@ -0,0 +1,22 @@
+import { analyzeAddon, createFilesFromBlueprint, createOptions, moveAddonFiles, moveProjectRootFiles, moveTestAppFiles, updateAddonPackageJson, updateAddonTsConfigJson, updateTestAppPackageJson, updateTestAppTsConfigJson, } from './steps/index.js';
+export function migrateEmberAddon(codemodOptions) {
+    const options = createOptions(codemodOptions);
+    const { isV1Addon } = options.packages.addon;
+    // Guarantee idempotency
+    if (!isV1Addon) {
+        return;
+    }
+    // Prepare for migration
+    const context = analyzeAddon(options);
+    // Preserve code
+    moveAddonFiles(options);
+    moveTestAppFiles(options);
+    moveProjectRootFiles(options);
+    // Get the latest code from blueprint
+    createFilesFromBlueprint(context, options);
+    // Fine-tune individual files
+    updateAddonPackageJson(context, options);
+    updateAddonTsConfigJson(options);
+    updateTestAppPackageJson(options);
+    updateTestAppTsConfigJson(options);
+}

package/dist/src/migration/ember-addon/steps/analyze-addon.js

@@ -0,0 +1,70 @@
+import { findFiles, renamePathByDirectory } from '@codemod-utils/files';
+import { getVersion } from '../../../utils/blueprints.js';
+function getAppReexports(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('app/**/*.js', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'app',
+            to: '',
+        });
+    })
+        .sort();
+}
+function getProjectRootDevDependencies(options) {
+    return {
+        concurrently: getVersion('concurrently', options),
+    };
+}
+function getPublicAssets(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('public/**/*', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'public',
+            to: '',
+        });
+    })
+        .sort();
+}
+function getPublicEntrypoints(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('{addon,addon-test-support}/**/*.{js,ts}', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'addon',
+            to: '',
+        });
+    })
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'addon-test-support',
+            to: 'test-support',
+        });
+    })
+        .map((filePath) => {
+        return filePath.replace(/ts$/, 'js');
+    })
+        .sort();
+}
+export function analyzeAddon(options) {
+    return {
+        addon: {
+            appReexports: getAppReexports(options),
+            publicAssets: getPublicAssets(options),
+            publicEntrypoints: getPublicEntrypoints(options),
+        },
+        projectRoot: {
+            devDependencies: getProjectRootDevDependencies(options),
+        },
+    };
+}

package/dist/src/migration/ember-addon/steps/create-files-from-blueprint.js

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { processTemplate } from '@codemod-utils/blueprints';
+import { createFiles, findFiles } from '@codemod-utils/files';
+import { blueprintsRoot } from '../../../utils/blueprints.js';
+function getFilesToSkip(options) {
+    const { packageManager, packages } = options;
+    const files = new Set();
+    if (!packages.addon.hasTypeScript) {
+        files.add('__addonLocation__/unpublished-development-types/index.d.ts');
+        files.add('__testAppLocation__/types/global.d.ts');
+    }
+    if (!packageManager.isPnpm) {
+        files.add('pnpm-workspace.yaml');
+    }
+    return [...files];
+}
+function resolveBlueprintFilePath(blueprintFilePath, options) {
+    const { locations } = options;
+    return blueprintFilePath
+        .replace('__addonLocation__', locations.addon)
+        .replace('__gitignore__', '.gitignore')
+        .replace('__testAppLocation__', locations.testApp);
+}
+export function createFilesFromBlueprint(context, options) {
+    const filesToSkip = getFilesToSkip(options);
+    const cwd = join(blueprintsRoot, 'ember-addon');
+    const blueprintFilePaths = findFiles('**/*', {
+        ignoreList: filesToSkip,
+        projectRoot: cwd,
+    });
+    const fileMap = new Map(blueprintFilePaths.map((blueprintFilePath) => {
+        const filePath = resolveBlueprintFilePath(blueprintFilePath, options);
+        const blueprintFile = readFileSync(join(cwd, blueprintFilePath), 'utf8');
+        const file = processTemplate(blueprintFile, {
+            context,
+            options,
+        });
+        return [filePath, file];
+    }));
+    createFiles(fileMap, options);
+}

package/dist/src/migration/ember-addon/steps/create-options.js

@@ -0,0 +1,73 @@
+import { findFiles, unionize } from '@codemod-utils/files';
+import { readPackageJson, validatePackageJson } from '@codemod-utils/json';
+function analyzePackageJson(codemodOptions) {
+    const { projectRoot } = codemodOptions;
+    const packageJson = readPackageJson({ projectRoot });
+    validatePackageJson(packageJson);
+    const { dependencies, devDependencies, 'ember-addon': emberAddon, name, version, } = packageJson;
+    const projectDependencies = new Map([
+        ...Object.entries(dependencies ?? {}),
+        ...Object.entries(devDependencies ?? {}),
+    ]);
+    return {
+        dependencies: projectDependencies,
+        hasGlint: projectDependencies.has('@glint/core'),
+        hasTypeScript: projectDependencies.has('typescript'),
+        isV1Addon: Boolean(emberAddon),
+        name,
+        version,
+    };
+}
+function analyzePackageManager(codemodOptions) {
+    const { projectRoot } = codemodOptions;
+    const mapping = new Map([
+        ['package-lock.json', 'npm'],
+        ['pnpm-lock.yaml', 'pnpm'],
+        ['yarn.lock', 'yarn'],
+    ]);
+    const lockFiles = [...mapping.keys()];
+    const filePaths = findFiles(unionize(lockFiles), {
+        projectRoot,
+    });
+    if (filePaths.length !== 1) {
+        console.warn('WARNING: Package manager is unknown. Yarn will be assumed.');
+        return {
+            isNpm: false,
+            isPnpm: false,
+            isYarn: true,
+        };
+    }
+    const packageManager = mapping.get(filePaths[0]);
+    return {
+        isNpm: packageManager === 'npm',
+        isPnpm: packageManager === 'pnpm',
+        isYarn: packageManager === 'yarn',
+    };
+}
+function deriveAddonLocation(addonPackage) {
+    const hasScope = addonPackage.name.includes('/');
+    if (!hasScope) {
+        return addonPackage.name;
+    }
+    // eslint-disable-next-line no-unused-vars
+    const [_scope, packageName] = addonPackage.name.split('/');
+    return packageName;
+}
+export function createOptions(codemodOptions) {
+    const addonPackage = analyzePackageJson(codemodOptions);
+    const packageManager = analyzePackageManager(codemodOptions);
+    return {
+        locations: {
+            addon: codemodOptions.addonLocation ?? deriveAddonLocation(addonPackage),
+            testApp: codemodOptions.testAppLocation ?? 'test-app',
+        },
+        packageManager,
+        packages: {
+            addon: addonPackage,
+            testApp: {
+                name: codemodOptions.testAppName ?? 'test-app',
+            },
+        },
+        projectRoot: codemodOptions.projectRoot,
+    };
+}

package/dist/src/migration/ember-addon/steps/move-addon-files.js

@@ -0,0 +1,59 @@
+import { findFiles, mapFilePaths, moveFiles, removeFiles, } from '@codemod-utils/files';
+function moveAddonFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('addon/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'addon',
+        to: `${locations.addon}/src`,
+    });
+    moveFiles(filePathMap, options);
+}
+function moveAddonTestSupportFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('addon-test-support/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'addon-test-support',
+        to: `${locations.addon}/src/test-support`,
+    });
+    moveFiles(filePathMap, options);
+}
+function moveBlueprintsFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('blueprints/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'blueprints',
+        to: `${locations.addon}/blueprints`,
+    });
+    moveFiles(filePathMap, options);
+}
+function movePublicFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('public/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'public',
+        to: `${locations.addon}/public`,
+    });
+    moveFiles(filePathMap, options);
+}
+function removeAppFolder(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('app/**/*', {
+        projectRoot,
+    });
+    removeFiles(filePaths, options);
+}
+export function moveAddonFiles(options) {
+    moveAddonFolder(options);
+    moveAddonTestSupportFolder(options);
+    moveBlueprintsFolder(options);
+    movePublicFolder(options);
+    removeAppFolder(options);
+}

package/dist/src/migration/ember-addon/steps/move-project-root-files.js

@@ -0,0 +1,79 @@
+import { copyFiles, findFiles, mapFilePaths, moveFiles, removeFiles, unionize, } from '@codemod-utils/files';
+function copyToAddon(options) {
+    const { locations, projectRoot } = options;
+    const files = ['LICENSE.md', 'README.md'];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.addon,
+    });
+    copyFiles(filePathMap, options);
+}
+function moveToAddonAndTestApp(options) {
+    const { locations, packages, projectRoot } = options;
+    const files = new Set([
+        '.eslintignore',
+        '.eslintrc.cjs',
+        '.eslintrc.js',
+        '.gitignore',
+        '.prettierignore',
+        '.prettierrc.cjs',
+        '.prettierrc.js',
+        '.stylelintignore',
+        '.stylelintrc.cjs',
+        '.stylelintrc.js',
+        '.template-lintrc.cjs',
+        '.template-lintrc.js',
+        'package.json',
+    ]);
+    if (packages.addon.hasTypeScript) {
+        files.add('tsconfig.json');
+    }
+    const filePaths = findFiles(unionize([...files]), {
+        projectRoot,
+    });
+    let filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.addon,
+    });
+    copyFiles(filePathMap, options);
+    filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.testApp,
+    });
+    copyFiles(filePathMap, options);
+    removeFiles(filePaths, options);
+}
+function moveToTestApp(options) {
+    const { locations, projectRoot } = options;
+    const files = [
+        '.ember-cli',
+        '.watchmanconfig',
+        'ember-cli-build.js',
+        'testem.js',
+    ];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.testApp,
+    });
+    moveFiles(filePathMap, options);
+}
+function removeFromProjectRoot(options) {
+    const { projectRoot } = options;
+    const files = ['.npmignore', 'index.js'];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    removeFiles(filePaths, options);
+}
+export function moveProjectRootFiles(options) {
+    copyToAddon(options);
+    moveToAddonAndTestApp(options);
+    moveToTestApp(options);
+    removeFromProjectRoot(options);
+}

package/dist/src/migration/ember-addon/steps/move-test-app-files.js

@@ -0,0 +1,65 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findFiles, mapFilePaths, moveFiles } from '@codemod-utils/files';
+function moveTestsFolder(options) {
+    const { locations, projectRoot } = options;
+    let filePaths = findFiles('tests/dummy/**/*', {
+        projectRoot,
+    });
+    let filePathMap = mapFilePaths(filePaths, {
+        from: 'tests/dummy',
+        to: locations.testApp,
+    });
+    moveFiles(filePathMap, options);
+    filePaths = findFiles('tests/**/*', {
+        ignoreList: ['tests/dummy/**/*'],
+        projectRoot,
+    });
+    filePathMap = mapFilePaths(filePaths, {
+        from: 'tests',
+        to: `${locations.testApp}/tests`,
+    });
+    moveFiles(filePathMap, options);
+}
+function moveTypesFolder(options) {
+    const { locations, packages, projectRoot } = options;
+    if (!packages.addon.hasTypeScript) {
+        return;
+    }
+    let filePaths = findFiles('types/dummy/**/*', {
+        projectRoot,
+    });
+    let filePathMap = mapFilePaths(filePaths, {
+        from: 'types/dummy',
+        to: `${locations.testApp}/types/${packages.testApp.name}`,
+    });
+    moveFiles(filePathMap, options);
+    filePaths = findFiles('types/**/*', {
+        ignoreList: ['types/dummy/**/*'],
+        projectRoot,
+    });
+    filePathMap = mapFilePaths(filePaths, {
+        from: 'types',
+        to: `${locations.testApp}/types`,
+    });
+    moveFiles(filePathMap, options);
+}
+function renameDummy(options) {
+    const { locations, packages, projectRoot } = options;
+    // File extensions had been specified, partly to encode assumptions
+    // about Ember, and partly to avoid corrupting non-text files
+    const filePaths = findFiles(`${locations.testApp}/**/*.{d.ts,html,js,ts}`, {
+        projectRoot,
+    });
+    filePaths.forEach((filePath) => {
+        const oldPath = join(projectRoot, filePath);
+        const oldFile = readFileSync(oldPath, 'utf8');
+        const newFile = oldFile.replace(new RegExp('dummy', 'g'), packages.testApp.name);
+        writeFileSync(oldPath, newFile, 'utf8');
+    });
+}
+export function moveTestAppFiles(options) {
+    moveTestsFolder(options);
+    moveTypesFolder(options);
+    renameDummy(options);
+}

package/dist/src/migration/ember-addon/steps/update-addon-package-json.js

@@ -0,0 +1,138 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { convertToMap, convertToObject, readPackageJson, } from '@codemod-utils/json';
+import { getVersion } from '../../../utils/blueprints.js';
+function updateDependencies(packageJson, options) {
+    const dependencies = convertToMap(packageJson['dependencies']);
+    const packagesToDelete = [
+        '@embroider/macros',
+        'ember-auto-import',
+        'ember-cli-babel',
+        'ember-cli-htmlbars',
+    ];
+    packagesToDelete.forEach((packageName) => {
+        dependencies.delete(packageName);
+    });
+    const packagesToInstall = ['@embroider/addon-shim'];
+    packagesToInstall.sort().forEach((packageName) => {
+        const version = getVersion(packageName, options);
+        dependencies.set(packageName, version);
+    });
+    packageJson['dependencies'] = convertToObject(dependencies);
+}
+function updateDevDependencies(packageJson, options) {
+    const { packages } = options;
+    const devDependencies = convertToMap(packageJson['devDependencies']);
+    /*
+      For the time being, we'll take the approach of starting over and
+      adding back the development dependencies that are required. For
+      a more conservative approach, we could delete only the following:
+  
+        - @embroider/macros
+        - ember-auto-import
+        - ember-cli-babel
+        - ember-cli-htmlbars
+    */
+    devDependencies.clear();
+    const packagesToInstall = new Set([
+        '@babel/core',
+        '@babel/plugin-proposal-class-properties',
+        '@babel/plugin-proposal-decorators',
+        '@babel/runtime',
+        '@embroider/addon-dev',
+        '@rollup/plugin-babel',
+        'rollup',
+        'rollup-plugin-copy',
+    ]);
+    if (packages.addon.hasTypeScript) {
+        packagesToInstall.add('@babel/preset-typescript');
+        packagesToInstall.add('rollup-plugin-ts');
+        packagesToInstall.delete('@rollup/plugin-babel');
+    }
+    [...packagesToInstall].sort().forEach((packageName) => {
+        const version = getVersion(packageName, options);
+        devDependencies.set(packageName, version);
+    });
+    packageJson['devDependencies'] = convertToObject(devDependencies);
+}
+function updateOtherFields(packageJson, context, options) {
+    const { packages } = options;
+    const hasPublicAssets = context.addon.publicAssets.length > 0;
+    if (hasPublicAssets) {
+        const publicAssetMapping = context.addon.publicAssets.reduce((accumulator, filePath) => {
+            const from = `./public/${filePath}`;
+            const to = `/${packages.addon.name}/${filePath}`;
+            accumulator[from] = to;
+            return accumulator;
+        }, {});
+        packageJson['ember-addon'] = {
+            'app-js': {},
+            main: 'addon-main.cjs',
+            'public-assets': publicAssetMapping,
+            type: 'addon',
+            version: 2,
+        };
+    }
+    else {
+        packageJson['ember-addon'] = {
+            'app-js': {},
+            main: 'addon-main.cjs',
+            type: 'addon',
+            version: 2,
+        };
+    }
+    if (packages.addon.hasTypeScript) {
+        packageJson['exports'] = {
+            '.': './dist/index.js',
+            './*': {
+                /*
+                  This object has an order dependency. The `default` key must appear last.
+                */
+                types: './dist/*.d.ts',
+                default: './dist/*.js',
+            },
+            './addon-main.js': './addon-main.cjs',
+        };
+    }
+    else {
+        packageJson['exports'] = {
+            '.': './dist/index.js',
+            './*': './dist/*.js',
+            './addon-main.js': './addon-main.cjs',
+        };
+    }
+    if (hasPublicAssets) {
+        packageJson['files'] = ['addon-main.cjs', 'dist', 'public'];
+    }
+    else {
+        packageJson['files'] = ['addon-main.cjs', 'dist'];
+    }
+    if (packages.addon.hasTypeScript) {
+        packageJson['typesVersions'] = {
+            '*': {
+                '*': ['dist/*'],
+            },
+        };
+    }
+}
+function updateScripts(packageJson) {
+    const scripts = convertToMap(packageJson['scripts']);
+    scripts.set('build', 'rollup --config');
+    scripts.set('prepack', 'rollup --config');
+    scripts.set('start', 'rollup --config --watch');
+    scripts.set('test', "echo 'A v2 addon does not have tests, run tests in test-app'");
+    packageJson['scripts'] = convertToObject(scripts);
+}
+export function updateAddonPackageJson(context, options) {
+    const { locations, projectRoot } = options;
+    const packageJson = readPackageJson({
+        projectRoot: join(projectRoot, locations.addon),
+    });
+    updateDependencies(packageJson, options);
+    updateDevDependencies(packageJson, options);
+    updateScripts(packageJson);
+    updateOtherFields(packageJson, context, options);
+    const destination = join(projectRoot, locations.addon, 'package.json');
+    const file = JSON.stringify(packageJson, null, 2) + '\n';
+    writeFileSync(destination, file, 'utf8');
+}

package/dist/src/migration/ember-addon/steps/update-addon-tsconfig-json.js

@@ -0,0 +1,26 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { convertToMap, convertToObject } from '@codemod-utils/json';
+import { sanitizeJson } from '../../../utils/json.js';
+function updateCompilerOptions(tsConfigJson) {
+    const compilerOptions = convertToMap(tsConfigJson['compilerOptions']);
+    compilerOptions.delete('baseUrl');
+    compilerOptions.delete('paths');
+    tsConfigJson['compilerOptions'] = convertToObject(compilerOptions);
+}
+function updateInclude(tsConfigJson) {
+    tsConfigJson['include'] = ['src/**/*', 'unpublished-development-types/**/*'];
+}
+export function updateAddonTsConfigJson(options) {
+    const { locations, packages, projectRoot } = options;
+    if (!packages.addon.hasTypeScript) {
+        return;
+    }
+    const oldPath = join(projectRoot, locations.addon, 'tsconfig.json');
+    const oldFile = readFileSync(oldPath, 'utf8');
+    const tsConfigJson = JSON.parse(sanitizeJson(oldFile));
+    updateCompilerOptions(tsConfigJson);
+    updateInclude(tsConfigJson);
+    const newFile = JSON.stringify(tsConfigJson, null, 2) + '\n';
+    writeFileSync(oldPath, newFile, 'utf8');
+}