@cedarjs/codemods 0.0.4

package/dist/codemods/v2.x.x/updateResolverTypes/updateResolverTypes.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateResolverTypes_exports = {};
+__export(updateResolverTypes_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(updateResolverTypes_exports);
+var import_jscodeshift = require("jscodeshift");
+const isTypeReference = (typeAnnotation) => import_jscodeshift.TSTypeReference.check(typeAnnotation);
+const getTypeName = (node) => {
+  return import_jscodeshift.Identifier.check(node.typeName) ? node.typeName.name : null;
+};
+const isWrappedInPartial = (node) => {
+  const typeAnnotation = node.typeAnnotation;
+  return isTypeReference(typeAnnotation) && getTypeName(typeAnnotation) === "Partial";
+};
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  const findImportFromGqlTypes = (importName) => {
+    return ast.find(j.ImportDeclaration, {
+      source: { value: "types/graphql" }
+    }).find(j.ImportSpecifier, { imported: { name: importName } });
+  };
+  const addToGqlTypesImports = (importName) => {
+    ast.find(j.ImportDeclaration, {
+      source: { value: "types/graphql" }
+    }).forEach((importStatement) => {
+      importStatement.node.specifiers?.push(
+        j.importSpecifier(j.identifier(importName))
+      );
+    });
+  };
+  ast.find(j.TSTypeAnnotation).forEach((path) => {
+    const typeAnnotationNode = path.node;
+    if (
+      // If it's a MutationResolvers['x'] or QueryResolvers['x']
+      j.TSIndexedAccessType.check(typeAnnotationNode.typeAnnotation)
+    ) {
+      return;
+    }
+    if (!isWrappedInPartial(typeAnnotationNode) && isTypeReference(typeAnnotationNode.typeAnnotation)) {
+      const originalTypeName = getTypeName(typeAnnotationNode.typeAnnotation);
+      if (!originalTypeName || !originalTypeName.includes("Resolvers") || findImportFromGqlTypes(originalTypeName).length === 0 || // check if it was imported from types/graphql
+      originalTypeName.includes("RelationResolvers")) {
+        return;
+      }
+      const newTypeName = originalTypeName.replace(
+        "Resolvers",
+        "RelationResolvers"
+      );
+      console.log(`Converting ${originalTypeName} to ${newTypeName}....`);
+      path.replace(
+        j.tsTypeAnnotation(j.tsTypeReference(j.identifier(newTypeName)))
+      );
+      findImportFromGqlTypes(originalTypeName)?.remove();
+      addToGqlTypesImports(newTypeName);
+    }
+  });
+  return ast.toSource();
+}

package/dist/codemods/v2.x.x/updateResolverTypes/updateResolverTypes.yargs.js

@@ -0,0 +1,62 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateResolverTypes_yargs_exports = {};
+__export(updateResolverTypes_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(updateResolverTypes_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "update-resolver-types";
+const description = '(v2.x.x->v3.x.x) Wraps types for "relation" resolvers in the bottom of service files';
+const handler = () => {
+  (0, import_tasuku.default)("Update Resolver Types", async ({ setOutput }) => {
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "updateResolverTypes.js"),
+      // Target services written in TS only
+      targetPaths: import_fast_glob.default.sync("**/*.ts", {
+        cwd: (0, import_project_config.getPaths)().api.services,
+        ignore: ["**/node_modules/**", "**/*.test.ts", "**/*.scenarios.ts"],
+        absolute: true
+      })
+    });
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v4.2.x/updateClerkGetCurrentUser/updateClerkGetCurrentUser.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateClerkGetCurrentUser_exports = {};
+__export(updateClerkGetCurrentUser_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(updateClerkGetCurrentUser_exports);
+const newReturn = `userWithoutPrivateMetadata`;
+const destructureStatement = `const { privateMetadata, ...${newReturn} } = decoded`;
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  const parseJWTStatement = ast.find(j.VariableDeclaration, {
+    declarations: [
+      {
+        type: "VariableDeclarator",
+        init: {
+          type: "CallExpression",
+          callee: {
+            name: "parseJWT"
+          }
+        }
+      }
+    ]
+  });
+  parseJWTStatement.insertAfter(destructureStatement);
+  ast.find(j.ReturnStatement, {
+    argument: {
+      type: "ObjectExpression",
+      properties: [
+        {
+          type: "SpreadElement",
+          argument: {
+            name: "decoded"
+          }
+        }
+      ]
+    }
+  }).replaceWith((path) => {
+    if (path.value.argument?.type !== "ObjectExpression") {
+      return path.value;
+    }
+    const properties = path.value.argument.properties.filter((property) => {
+      return !(property.type === "SpreadElement" && property.argument.type === "Identifier" && property.argument.name === "decoded");
+    });
+    const spreadElement = j.spreadProperty(j.identifier(newReturn));
+    properties.push(spreadElement);
+    return j.returnStatement(j.objectExpression(properties));
+  });
+  return ast.toSource({
+    trailingComma: true,
+    quote: "single",
+    lineTerminator: "\n"
+  });
+}

package/dist/codemods/v4.2.x/updateClerkGetCurrentUser/updateClerkGetCurrentUser.yargs.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateClerkGetCurrentUser_yargs_exports = {};
+__export(updateClerkGetCurrentUser_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(updateClerkGetCurrentUser_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_isTSProject = __toESM(require("../../../lib/isTSProject"));
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "update-clerk-get-current-user";
+const description = "(v4.1.x->v4.2.x) For Clerk users; updates the getCurrentUser function";
+const handler = () => {
+  (0, import_tasuku.default)("Update getCurrentUser", async ({ setOutput }) => {
+    const authFile = import_isTSProject.default ? "auth.ts" : "auth.js";
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "updateClerkGetCurrentUser.js"),
+      targetPaths: [import_path.default.join((0, import_project_config.getPaths)().api.base, "src", "lib", authFile)]
+    });
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v4.x.x/useArmor/useArmor.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useArmor_exports = {};
+__export(useArmor_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(useArmor_exports);
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  ast.find(j.CallExpression, { callee: { name: "createGraphQLHandler" } }).forEach((path) => {
+    const depthLimitOptionsProp = j(path.node).find(j.ObjectProperty, {
+      key: {
+        name: "depthLimitOptions"
+      }
+    });
+    if (depthLimitOptionsProp.length > 0) {
+      console.info(`Updating createGraphQLHandler config in ${file.path} ...`);
+      const maxDepthProp = depthLimitOptionsProp.find(j.ObjectProperty, {
+        key: {
+          name: "maxDepth"
+        }
+      });
+      const depthLimitOption = maxDepthProp.find(j.Literal);
+      if (depthLimitOption.length > 0) {
+        const depthLimitOptionValue = depthLimitOption.at(0).get().value.value;
+        depthLimitOptionsProp.replaceWith([
+          j.identifier(
+            `armorConfig: { maxDepth: { n: ${depthLimitOptionValue || 11} } }`
+          )
+        ]);
+        console.info(
+          `useArmor configured to use existing maxDepth of ${depthLimitOptionValue || 11}.`
+        );
+      }
+    } else {
+      console.info(
+        `No mods needed to createGraphQLHandler config in ${file.path}. Skipping...`
+      );
+    }
+  });
+  return ast.toSource({
+    trailingComma: true,
+    quote: "single",
+    lineTerminator: "\n"
+  });
+}

package/dist/codemods/v4.x.x/useArmor/useArmor.yargs.js

@@ -0,0 +1,62 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useArmor_yargs_exports = {};
+__export(useArmor_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(useArmor_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_isTSProject = __toESM(require("../../../lib/isTSProject"));
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "use-armor";
+const description = "(v4.x.x->v4.x.x) Updates createGraphQLHandler config to use GraphQL Armor config as needed";
+const handler = () => {
+  (0, import_tasuku.default)("Use Armor", async ({ setOutput }) => {
+    const graphqlHandlerFile = import_isTSProject.default ? "graphql.ts" : "graphql.js";
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "useArmor.js"),
+      targetPaths: [
+        import_path.default.join((0, import_project_config.getPaths)().api.base, "src", "functions", graphqlHandlerFile)
+      ]
+    });
+    setOutput(
+      "Updating createGraphQLHandler for useArmor config is done! Run `yarn rw lint --fix` to prettify your code"
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v5.x.x/cellQueryResult/cellQueryResult.js

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cellQueryResult_exports = {};
+__export(cellQueryResult_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(cellQueryResult_exports);
+const cellFunctionsToCheck = ["Success", "Failure", "Loading", "Empty"];
+const nonSpreadVariables = [
+  "previousData",
+  "variables",
+  "networkStatus",
+  "client",
+  "called",
+  "refetch",
+  "fetchMore",
+  "startPolling",
+  "stopPolling",
+  "subscribeToMore",
+  "updateQuery"
+];
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  cellFunctionsToCheck.forEach((variableName) => {
+    const foundCellFunctions = ast.findVariableDeclarators(variableName);
+    if (foundCellFunctions.size() === 1) {
+      const foundFunction = foundCellFunctions.paths()[0];
+      if (foundFunction.value.init?.type === "ArrowFunctionExpression" || foundFunction.value.init?.type === "FunctionExpression") {
+        const firstParameter = foundFunction.value.init.params.at(0);
+        if (!firstParameter) {
+        } else {
+          if (firstParameter.type === "ObjectPattern") {
+            const previouslySpreadPropertiesInUse = firstParameter.properties.filter((property) => {
+              if (property.type === "SpreadProperty" || property.type === "SpreadPropertyPattern" || property.type === "RestProperty" || property.key.type !== "Identifier") {
+                return false;
+              }
+              return nonSpreadVariables.includes(property.key.name);
+            });
+            if (previouslySpreadPropertiesInUse.length > 0) {
+              firstParameter.properties.push(
+                j.property(
+                  "init",
+                  j.identifier("queryResult"),
+                  // Previously spead properties are now found within 'queryResult'
+                  j.objectPattern(
+                    // For every previously spead property in use add a destructuring
+                    previouslySpreadPropertiesInUse.map((usedProperty) => {
+                      if (!("key" in usedProperty) || !("value" in usedProperty) || usedProperty.key.type !== "Identifier" || usedProperty.value.type !== "Identifier") {
+                        throw new Error(
+                          "Unable to process a parameter within the cell function"
+                        );
+                      }
+                      const prop = j.property(
+                        "init",
+                        j.identifier(usedProperty.key.name),
+                        j.identifier(usedProperty.value.name)
+                      );
+                      prop.shorthand = usedProperty.shorthand;
+                      return prop;
+                    })
+                  )
+                )
+              );
+              firstParameter.properties = firstParameter.properties.filter(
+                (property) => {
+                  if (!("key" in property) || property.key.type !== "Identifier") {
+                    throw new Error("Unable to process a parameter");
+                  }
+                  return !nonSpreadVariables.includes(property.key.name);
+                }
+              );
+            }
+          } else {
+            console.warn(
+              `The first parameter to '${variableName}' was not an object and we could not process this.`
+            );
+          }
+        }
+      } else {
+        console.warn(
+          `'${variableName}' is not a function and we could not process this.`
+        );
+      }
+    } else {
+      console.warn(`Could not find a unique '${variableName}' variable`);
+    }
+  });
+  return ast.toSource({
+    trailingComma: true,
+    quote: "single",
+    lineTerminator: "\n"
+  });
+}

package/dist/codemods/v5.x.x/cellQueryResult/cellQueryResult.yargs.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cellQueryResult_yargs_exports = {};
+__export(cellQueryResult_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(cellQueryResult_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_cells = require("../../../lib/cells");
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "cell-query-result";
+const description = "(v4.x.x->v5.x.x) Updates cells to use the `queryResult` property";
+const handler = () => {
+  (0, import_tasuku.default)("cellQueryResult", async ({ setOutput }) => {
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "cellQueryResult.js"),
+      targetPaths: (0, import_cells.findCells)()
+    });
+    setOutput(
+      "Updates to your cells are complete! Please run `yarn rw lint --fix` to prettify your code"
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v5.x.x/detectEmptyCells/detectEmptyCells.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detectEmptyCells_exports = {};
+__export(detectEmptyCells_exports, {
+  detectEmptyCells: () => detectEmptyCells
+});
+module.exports = __toCommonJS(detectEmptyCells_exports);
+var import_cells = require("../../../lib/cells");
+async function detectEmptyCells(taskContext) {
+  const warnings = [];
+  const cellPaths = (0, import_cells.findCells)();
+  const susceptibleCells = cellPaths.filter((cellPath) => {
+    const fileContents = (0, import_cells.fileToAst)(cellPath);
+    const cellQuery = (0, import_cells.getCellGqlQuery)(fileContents);
+    if (!cellQuery) {
+      return false;
+    }
+    let fields;
+    try {
+      fields = (0, import_cells.parseGqlQueryToAst)(cellQuery)[0].fields;
+    } catch {
+      warnings.push(cellPath);
+      return;
+    }
+    return fields.length > 1;
+  });
+  if (susceptibleCells.length === 0 && warnings.length === 0) {
+    taskContext.setOutput(
+      "None of your project's Cells are susceptible to the new `isDataEmpty` behavior."
+    );
+    return;
+  }
+  const message = [];
+  if (susceptibleCells.length > 0) {
+    message.push(
+      [
+        "You have Cells that are susceptible to the new `isDataEmpty` behavior:",
+        "",
+        susceptibleCells.map((c) => `\u2022 ${c}`).join("\n"),
+        ""
+      ].join("\n")
+    );
+  }
+  if (warnings.length > 0) {
+    message.push(
+      [
+        [
+          message.length > 0 && "\u2192",
+          `The following Cell(s) could not be parsed:`
+        ].filter(Boolean).join(" "),
+        "",
+        warnings.map((c) => `\u2022 ${c}`).join("\n"),
+        "",
+        "You'll have to audit them manually.",
+        ""
+      ].join("\n")
+    );
+  }
+  message.push(
+    [
+      "The new behavior is documented in detail on the forums: https://community.redwoodjs.com/t/redwood-v5-0-0-rc-is-now-available/4715.",
+      "It's most likely what you want, but consider whether it affects you.",
+      "If you'd like to revert to the old behavior, you can override the `isDataEmpty` function."
+    ].join("\n")
+  );
+  const taskContextMethod = warnings.length > 0 ? "setWarning" : "setOutput";
+  taskContext[taskContextMethod](message.join("\n"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectEmptyCells
+});