🔨 Initialiser now properly supports preset creation

Author: danieldelcore

.changeset/selfish-donkeys-deny.md

@@ -0,0 +1,5 @@
+---
+'@codeshift/cli': minor
+---
+
+CLI Init command now supports the ability to create a stub preset

packages/cli/src/errors.ts

@@ -1,3 +1,2 @@
-export class ValidationError extends Error {}
 export class NoTransformsExistError extends Error {}
 export class InvalidUserInputError extends Error {}

packages/cli/src/index.ts

@@ -3,19 +3,15 @@ import main from './main';
 import list from './list';
 import init from './init';
 import validate from './validate';
-import {
-  ValidationError,
-  NoTransformsExistError,
-  InvalidUserInputError,
-} from './errors';
+import { NoTransformsExistError, InvalidUserInputError } from './errors';
 
 import packageJson from '../package.json';
-import { Command, Option } from 'commander';
+import { Command, Option, CommanderError } from 'commander';
 
 const program = new Command();
 
 program
-  .command(`${packageJson.name} [path...]`, { isDefault: true })
+  .command(`codeshift/cli [path...]`, { isDefault: true })
   .version(packageJson.version, '-v, --version')
   .usage('[global options] <file-paths>...')
   .option(
@@ -103,24 +99,27 @@ Examples:
 
 program.exitOverride();
 
-program.parseAsync(process.argv).catch(e => {
-  if (e instanceof ValidationError) {
-    console.error(program.help());
-    console.error(chalk.red(e.message));
-    process.exit(1);
+try {
+  program.parse(process.argv);
+} catch (error) {
+  if (error instanceof CommanderError) {
+    console.log(error);
+
+    console.error(chalk.red(error.message));
+    process.exit(error.exitCode);
   }
 
-  if (e instanceof InvalidUserInputError) {
+  if (error instanceof InvalidUserInputError) {
     console.warn(program.help());
-    console.warn(chalk.red(e.message));
+    console.warn(chalk.red(error.message));
     process.exit(9);
   }
 
-  if (e instanceof NoTransformsExistError) {
-    console.warn(chalk.yellow(e.message));
+  if (error instanceof NoTransformsExistError) {
+    console.warn(chalk.yellow(error.message));
     process.exit(0);
   }
 
-  console.error(chalk.red(e));
+  console.error(chalk.red(error));
   process.exit(3);
-});
+}

packages/cli/src/init.ts

@@ -2,10 +2,17 @@ import { initDirectory } from '@codeshift/initializer';
 
 export default async function init(
   packageName: string,
-  version: string,
+  transform?: string,
+  preset?: string,
   targetPath: string = '.',
 ) {
-  initDirectory(packageName, version, targetPath);
+  if (transform) {
+    initDirectory(packageName, transform, 'version', targetPath);
+  }
+
+  if (preset) {
+    initDirectory(packageName, preset, 'preset', targetPath);
+  }
 
   console.log(
     `🚚 New codemod package created at: ${targetPath}/${packageName}`,

packages/initializer/src/index.ts

@@ -14,11 +14,11 @@ export function getPackageJson(packageName: string, version: string = '0.0.0') {
         build: 'tsc --build',
         test: 'jest',
       },
-      dependencies: {
-        '@codeshift/utils': `^${utilVersion}`,
-      },
+      dependencies: {},
       devDependencies: {
+        '@codeshift/utils': `^${utilVersion}`,
         '@codeshift/test-utils': '*',
+        '@types/node': '^16.11.0',
         '@types/jest': '^26.0.15',
         jest: '^26.6.0',
         jscodeshift: '^0.12.0',
@@ -32,46 +32,60 @@ export function getPackageJson(packageName: string, version: string = '0.0.0') {
   );
 }
 
-function getConfig(packageName: string, version: string) {
-  return `export default {
+function getConfig(packageName: string, transform?: string, preset?: string) {
+  return `module.exports = {
   maintainers: [],
   target: [],
   description: 'Codemods for ${packageName}',
-  transforms: {
-    '${version}': require('./${version}/transform'),
-  },
-  presets: {},
+  transforms: {${
+    transform
+      ? `'${transform}': require.resolve('./${transform}/transform'),`
+      : ''
+  }},
+  presets: {${
+    preset ? `'${preset}': require.resolve('./${preset}/transform'),` : ''
+  }},
 };
 `;
 }
 
-function updateConfig(path: string, packageName: string, version: string) {
+function updateConfig(
+  path: string,
+  packageName: string,
+  transformName: string,
+  type: 'version' | 'preset',
+) {
   const source = fs.readFileSync(path, 'utf8');
   const ast = recast.parse(source);
   const b = recast.types.builders;
+  const key = type === 'version' ? 'transforms' : 'presets';
 
   recast.visit(ast, {
     visitProperty(path) {
       // @ts-ignore
-      if (path.node.key.name !== 'transforms') return false;
+      if (path.node.key.name !== key) return false;
       // @ts-ignore
       const properties = path.node.value.properties;
       // @ts-ignore
       properties.forEach(property => {
-        if (semver.eq(property.key.value, version)) {
+        if (property.key.value === transformName) {
           throw new Error(
-            `Transform for ${packageName} version ${version} already exists`,
+            `Transform for ${packageName} ${transformName} already exists`,
           );
         }
       });
 
       properties.push(
         b.property(
           'init',
-          b.stringLiteral(version),
-          b.callExpression(b.identifier('require'), [
-            b.stringLiteral(`./${version}/transform`),
-          ]),
+          b.stringLiteral(transformName),
+          b.callExpression(
+            b.memberExpression(
+              b.identifier('require'),
+              b.identifier('resolve'),
+            ),
+            [b.stringLiteral(`./${transformName}/transform`)],
+          ),
         ),
       );
 
@@ -84,46 +98,51 @@ function updateConfig(path: string, packageName: string, version: string) {
 
 export function initDirectory(
   packageName: string,
-  version: string,
-  targetPath: string = './',
+  transform: string,
+  type: 'version' | 'preset',
+  path: string = './',
   isReduced: boolean = false,
 ) {
-  if (!semver.valid(version)) {
+  if (type === 'version' && !semver.valid(transform)) {
     throw new Error(
-      `Provided version ${version} is not a valid semver version`,
+      `Provided version ${transform} is not a valid semver version`,
     );
   }
 
-  const basePath = `${targetPath}/${packageName.replace('/', '__')}`;
-  const codemodPath = `${basePath}${!isReduced ? '/src/' : ''}/${version}`;
+  const basePath = `${path}/${packageName.replace('/', '__')}`;
+  const transformPath = `${basePath}${!isReduced ? '/src/' : ''}/${transform}`;
   const configPath = `${basePath}${
     !isReduced ? '/src' : ''
   }/codeshift.config.ts`;
 
-  if (fs.existsSync(codemodPath)) {
-    throw new Error(`Codemod for version "${version}" already exists`);
+  if (fs.existsSync(transformPath)) {
+    throw new Error(`Codemod for ${type} "${transform}" already exists`);
   }
 
   fs.copySync(`${__dirname}/../template${isReduced ? '/src' : ''}`, basePath);
-  fs.renameSync(`${basePath}${!isReduced ? '/src/' : ''}/codemod`, codemodPath);
+  fs.renameSync(
+    `${basePath}${!isReduced ? '/src/' : ''}/codemod`,
+    transformPath,
+  );
 
   const testFile = fs
-    .readFileSync(`${codemodPath}/transform.spec.ts`, 'utf8')
+    .readFileSync(`${transformPath}/transform.spec.ts`, 'utf8')
     .replace('<% packageName %>', packageName)
-    .replace('<% version %>', version);
+    .replace('<% seperator %>', type === 'version' ? '@' : '#')
+    .replace('<% transform %>', transform || '');
 
-  fs.writeFileSync(`${codemodPath}/transform.spec.ts`, testFile);
+  fs.writeFileSync(`${transformPath}/transform.spec.ts`, testFile);
 
   if (!isReduced) {
     fs.writeFileSync(`${basePath}/package.json`, getPackageJson(packageName));
   }
 
   if (!fs.existsSync(configPath)) {
-    fs.writeFileSync(configPath, getConfig(packageName, version));
+    fs.writeFileSync(configPath, getConfig(packageName, transform));
   } else {
     fs.writeFileSync(
       configPath,
-      updateConfig(configPath, packageName, version),
+      updateConfig(configPath, packageName, transform || '', type),
     );
   }
 }

packages/initializer/template/.npmignore

@@ -1,8 +1,5 @@
-node_modules
 src/
 **/__test__
 **/*.spec.(ts|js)
 .vscode
 jest.config.js
-tsconfig.json
-yarn-error.log

packages/initializer/template/jest.config.js

@@ -2,8 +2,8 @@ module.exports = {
   transform: {
     '^.+\\.ts$': 'ts-jest',
   },
-  moduleFileExtensions: ['ts', 'js'],
-  testRegex: '^.+\\.spec\\.(ts|js)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js'],
+  testRegex: '^.+\\.spec\\.(tsx|ts|js)$',
   globals: {
     'ts-jest': {
       tsconfig: 'tsconfig.json',

packages/initializer/template/src/codemod/transform.spec.ts

@@ -1,7 +1,7 @@
 import { applyTransform } from '@codeshift/test-utils';
 import * as transformer from './transform';
 
-describe('<% packageName %>@<% version %> transform', () => {
+describe('<% packageName %><% seperator %><% transform %> transform', () => {
   it('should transform correctly', () => {
     const result = applyTransform(
       transformer,

packages/initializer/template/tsconfig.json

@@ -3,6 +3,7 @@
   "compilerOptions": {
     "outDir": "dist",
     "esModuleInterop": true,
-    "allowJs": true
+    "allowJs": true,
+    "types": ["jest", "node"]
   }
 }

scripts/initialize.ts

@@ -1,15 +1,17 @@
 import { initDirectory } from '@codeshift/initializer';
 
-export function main(packageName: string, version: string) {
-  const path = `${__dirname}/../community`;
+const targetPath = `${__dirname}/../community`;
 
+export function main(packageName: string, transform?: string) {
   if (!packageName) throw new Error('Package name was not provided');
-  if (!version) throw new Error('Version was not provided');
+  if (!transform) throw new Error('Version was not provided');
 
-  initDirectory(packageName, version, path, true);
+  if (transform) {
+    initDirectory(packageName, transform, 'version', targetPath);
+  }
 
   console.log(
-    `🚚 New codemod package created at: community/${packageName}/${version}`,
+    `🚚 New codemod package created at: community/${packageName}/${transform}`,
   );
 }