Gist for Transform your codebase using codemods

builder_example.js

// create a function call that looks like
// "myfunc(someVar, 'bar')"
const callExpr = j.callExpression(j.identifier("myFunc"), [
  j.indentifier("someVar"),
  j.literal("bar"),
]);

callexpression.js

def("CallExpression")
  .bases("Expression")
  .build("callee", "arguments")
  .field("callee", def("Expression"))
  // See comment for NewExpression above.
  .field("arguments", [def("Expression")]);

closest_example.js

// find all member expressions of the `obj` object
ast
  .find(j.MemberExpression, {
    object: {
      name: "obj",
    },
  })
  .closest(j.CallExpression);
// returns method calls like `obj.foo()`
// but not the property access like `obj.bar`

find_computed_value.js

// the jscodeshift api has been assigned to j previously

const ast = j(source);

// find all MemberExpressions on object `obj.`
ast
  .find(j.MemberExpression, {
    object: {
      name: "obj",
    },
  })
  .filter((path) => {
    const { name } = path.value.property;
    // filter all accessed properties that starts with `get`
    return /^get[A-Z].*/.test(name);
  });

find_smoosh.js

// the jscodeshift api has been assigned to j previously

const ast = j(source);

ast.find(j.MemberExpression, {
  object: {
    name: "library",
  },
  property: {
    name: "smoosh",
  },
});

find_variable_declarator.js

ast.findVariableDeclarators("foo");

///same as running this
ast.find(jscodeshift.VariableDeclarator, { id: { name: "foo" } });

ignore.sh

$ jscodeshift -t some-codemod.js --ignore-config ignore_config.txt /path/to/the/codebase

ignore_config.txt

vendor
node_modules
*config*.js

insert_example.js

ast
  .find(j.CallExpression)
  .closest(j.ExpressionStatement)
  .insertAfter([
    j.expressionStatement(j.callExpression(j.identifier("asd"), [])),
  ]);

insert_with_function.js

// insert a track() call after every function call
// passing in their numeric index in the code
const createTracker = (path, index) => {
  return j.expressionStatement(
    j.callExpression(j.identifier("track"), [j.literal(index)])
  );
};

ast
  .find(j.CallExpression)
  .closest(j.ExpressionStatement)
  .insertAfter(createTracker);

invalid_build.js

ast.findVariableDeclarators("foo").insertAfter(j.indentifier("bar"));
// this alters code from
//	 const foo = 'asd';
// to
//	 const foo = 'ast, bar;
// which is invalid!

jscodeshift.sh

$ npm i jscodeshift -g

$ jscodeshift -t some-codemod.js /path/to/the/codebase

remove_example.js

ast.findVariableDeclarators("foo").remove();

ast
  .find(j.CallExpression, {
    callee: {
      object: { name: "console" },
      property: { name: "log" },
    },
  })
  .remove();

renameto_example.js

jscodeshift(source).findVariableDeclarators("foo").renameTo("bar");

replacewith_example.js

// replace variable name 'lorem' to 'ipsum' at every code occurrence
ast.find(j.Identifier, { name: "lorem" }).replaceWith(j.identifier("ipsum"));

// replace console.log() to another logging target,
// while keeping the passed arguments
ast
  .find(j.CallExpression, {
    callee: {
      object: { name: "console" },
      property: { name: "log" },
    },
  })
  .replaceWith((path) => [
    j.callExpression(j.identifier("mylogger"), path.value.arguments),
  ]);

transform_module.js

module.exports = function (file, api, options) {
  const { source, path } = file;
  // `source` is the source code in file at `path`

  const { jscodeshift, stats } = api;
  // use `jscodeshift` to access the API
  // `stats` is a function to collect statistics
  // during --dry runs

  // do some magic here...

  // return the changed source as string
  return source;
};