@strapi/upgrade 0.0.0-experimental.fc1ac2acd58c8a5a858679956b6d102ac5ee4011 → 0.0.0-next.ce84fada19d58a7dfbdd553035e6558f8befcba4

package/resources/codemods/5.0.0/utils-public-interface.code.ts

@@ -0,0 +1,320 @@
+import { Transform, JSCodeshift, Collection } from 'jscodeshift';
+
+/*
+
+This codemod transforms @strapi/utils imports to change method calls to match the new public interface.
+It will also warn about removed functions to avoid breaking user code.
+
+ESM
+
+Before:
+
+import * as utils from '@strapi/utils';
+
+utils.nameToSlug();
+
+After:
+
+import { strings } from '@strapi/utils';
+
+strings.nameToSlug();
+
+---
+ESM
+
+Before:
+
+import { nameToSlug } from '@strapi/utils';
+
+nameToSlug();
+
+After:
+
+import { strings } from '@strapi/utils';
+
+strings.nameToSlug();
+
+---
+
+Common JS
+
+Before:
+
+const utils = require('@strapi/utils');
+
+utils.nameToSlug();
+
+After:
+
+const { strings } = require('@strapi/utils');
+
+strings.nameToSlug();
+
+---
+Common JS
+
+Before:
+
+const { nameToSlug } = require('@strapi/utils');
+
+nameToSlug();
+
+After:
+
+const { strings } = require('@strapi/utils');
+
+strings.nameToSlug();
+
+*/
+
+const changes = {
+  strings: {
+    nameToSlug: 'nameToSlug',
+    nameToCollectionName: 'nameToCollectionName',
+    stringEquals: 'isEqual',
+    isCamelCase: 'isCamelCase',
+    isKebabCase: 'isKebabCase',
+    toKebabCase: 'toKebabCase',
+    toRegressedEnumValue: 'toRegressedEnumValue',
+    startsWithANumber: 'startsWithANumber',
+    joinBy: 'joinBy',
+  },
+  arrays: {
+    stringIncludes: 'includesString',
+  },
+  objects: {
+    keysDeep: 'keysDeep',
+  },
+  dates: {
+    generateTimestampCode: 'timestampCode',
+  },
+  async: {
+    pipeAsync: 'pipe',
+    mapAsync: 'map',
+    reduceAsync: 'reduce',
+  },
+};
+
+const removed = [
+  'getCommonBeginning',
+  'templateConfiguration',
+  'removeUndefined',
+  'getConfigUrls',
+  'getAbsoluteAdminUrl',
+  'getAbsoluteServerUrl',
+  'forEachAsync',
+];
+
+const transformImports = (root: Collection, j: JSCodeshift) => {
+  root
+    .find(j.ImportDeclaration, {
+      source: { value: '@strapi/utils' },
+    })
+    .forEach((path) => {
+      if (!j.ImportDeclaration.check(path.value)) {
+        return;
+      }
+
+      path.value.specifiers.forEach((specifier) => {
+        if (!j.ImportSpecifier.check(specifier)) {
+          return false;
+        }
+
+        if (removed.includes(specifier.imported.name)) {
+          console.warn(
+            `Function "${specifier.imported.name}" was removed. You will have to remove it from your code.`
+          );
+
+          return false;
+        }
+      });
+
+      for (const primitive of Object.keys(changes)) {
+        const functions = Object.keys(changes[primitive]);
+
+        const specifiersToRefactor = path.value.specifiers.filter((specifier) => {
+          return j.ImportSpecifier.check(specifier) && functions.includes(specifier.imported.name);
+        });
+
+        if (specifiersToRefactor.length > 0) {
+          path.value.specifiers.unshift(j.importSpecifier(j.identifier(primitive)));
+
+          specifiersToRefactor.forEach((specifier) => {
+            const index = path.value.specifiers.indexOf(specifier);
+            path.value.specifiers.splice(index, 1);
+          });
+        }
+      }
+
+      if (path.value.specifiers?.length === 0) {
+        j(path).remove();
+      }
+    });
+
+  root.find(j.ImportNamespaceSpecifier).forEach((specifierPath) => {
+    if (specifierPath.parent.value.source.value === '@strapi/utils') {
+      for (const primitive of Object.keys(changes)) {
+        const functions = Object.keys(changes[primitive]);
+        functions.forEach((funcName) => {
+          root
+            .find(j.CallExpression, {
+              callee: {
+                type: 'MemberExpression',
+                property: {
+                  type: 'Identifier',
+                  name: funcName,
+                },
+                object: {
+                  type: 'Identifier',
+                  name: specifierPath.value.local.name,
+                },
+              },
+            })
+            .replaceWith((path) => {
+              return j.callExpression(
+                j.memberExpression(
+                  j.memberExpression(
+                    j.identifier(specifierPath.value.local.name),
+                    j.identifier(primitive)
+                  ),
+                  j.identifier(changes[primitive][funcName])
+                ),
+                path.value.arguments
+              );
+            });
+        });
+      }
+    }
+  });
+
+  root
+    .find(j.VariableDeclarator, {
+      init: {
+        callee: {
+          name: 'require',
+        },
+        arguments: [{ value: '@strapi/utils' }],
+      },
+    })
+    .forEach((path) => {
+      // destructured require
+
+      if (j.ObjectPattern.check(path.value.id)) {
+        const properties = path.value.id.properties;
+
+        properties?.forEach((property) => {
+          if (!j.ObjectProperty.check(property) || !j.Identifier.check(property.value)) {
+            return false;
+          }
+
+          if (removed.includes(property.value.name)) {
+            console.warn(
+              `Function "${property.value.name}" was removed. You will have to remove it from your code.`
+            );
+
+            return false;
+          }
+        });
+
+        for (const primitive of Object.keys(changes)) {
+          const functions = Object.keys(changes[primitive]);
+
+          const propertiesToRefactor = properties?.filter((property) => {
+            return (
+              j.ObjectProperty.check(property) &&
+              j.Identifier.check(property.value) &&
+              functions.includes(property.value.name)
+            );
+          });
+
+          if (propertiesToRefactor?.length > 0) {
+            const identifier = j.identifier(primitive);
+
+            properties?.unshift(
+              j.objectProperty.from({
+                key: identifier,
+                value: identifier,
+                shorthand: true,
+              })
+            );
+
+            propertiesToRefactor.forEach((property) => {
+              const index = properties?.indexOf(property);
+              properties?.splice(index, 1);
+            });
+          }
+        }
+
+        if (path.value.id.properties?.length === 0) {
+          j(path).remove();
+        }
+      }
+
+      // namespace require
+      if (path.value.id.type === 'Identifier') {
+        const identifier = path.value.id.name;
+
+        for (const primitive of Object.keys(changes)) {
+          const functions = Object.keys(changes[primitive]);
+          functions.forEach((funcName) => {
+            root
+              .find(j.CallExpression, {
+                callee: {
+                  type: 'MemberExpression',
+                  property: {
+                    type: 'Identifier',
+                    name: funcName,
+                  },
+                  object: {
+                    type: 'Identifier',
+                    name: identifier,
+                  },
+                },
+              })
+              .replaceWith((path) => {
+                return j.callExpression(
+                  j.memberExpression(
+                    j.memberExpression(j.identifier(identifier), j.identifier(primitive)),
+                    j.identifier(changes[primitive][funcName])
+                  ),
+                  path.value.arguments
+                );
+              });
+          });
+        }
+      }
+    });
+
+  for (const primitive of Object.keys(changes)) {
+    const functions = Object.keys(changes[primitive]);
+    functions.forEach((funcName) => {
+      root
+        .find(j.CallExpression, {
+          callee: {
+            type: 'Identifier',
+            name: funcName,
+          },
+        })
+        .replaceWith((path) => {
+          if (j.Identifier.check(path.value.callee)) {
+            path.value.callee.name = changes[primitive][funcName];
+            return j.memberExpression(j.identifier(primitive), path.value);
+          }
+        });
+    });
+  }
+};
+
+const transform: Transform = (file, api) => {
+  const j = api.jscodeshift;
+
+  const root = j(file.source);
+
+  transformImports(root, j);
+
+  return root.toSource();
+};
+
+export const parser = 'tsx';
+
+export default transform;

package/resources/examples/console.log-to-console.info.code.ts

@@ -8,7 +8,7 @@ const transform: Transform = (file, api) => {
   // Extract the jscodeshift API
   const { j } = api;
   // Parse the file content
-  const root = j(file.source);
+  const root = j.withParser('tsx')(file.source);
 
   root
     // Find console.log calls expressions

package/resources/examples/disable-jsx-buttons.code.ts

@@ -0,0 +1,42 @@
+import type { Transform } from 'jscodeshift';
+import { relative } from 'node:path';
+
+const transform: Transform = (file, api) => {
+  const j = api.jscodeshift;
+  const root = j.withParser('JSX')(file.source);
+
+  const isReactFile = file.path.endsWith('.jsx') || file.path.endsWith('.tsx');
+
+  if (!isReactFile) {
+    return root.toSource();
+  }
+
+  const fileName = relative(process.cwd(), file.path);
+
+  console.log(`Found React file: ${fileName}`);
+
+  const buttons = root.findJSXElements('Button');
+
+  console.log(`Found ${buttons.length} buttons in ${fileName}`);
+
+  buttons.forEach((button) => {
+    const { openingElement } = button.node;
+    const isDisabled = openingElement.attributes.some(
+      (attribute) => j.JSXAttribute.check(attribute) && attribute.name.name === 'disabled'
+    );
+
+    console.log(`Is disabled? ${isDisabled}`);
+
+    if (!isDisabled) {
+      openingElement.attributes.push(
+        j.jsxAttribute(j.jsxIdentifier('disabled'), j.jsxExpressionContainer(j.literal(true)))
+      );
+
+      console.log('Added the disabled attribute');
+    }
+  });
+
+  return root.toSource();
+};
+
+export default transform;

package/resources/utils/change-import.ts

@@ -0,0 +1,118 @@
+import type { ImportDeclaration, JSCodeshift, Collection } from 'jscodeshift';
+
+export const changeImportSpecifier = (
+  root: Collection,
+  j: JSCodeshift,
+  options: {
+    oldDependency: string;
+    newDependency: string;
+    oldMethodName: string;
+    newMethodName?: string;
+  }
+): void => {
+  const { oldMethodName, newMethodName, oldDependency, newDependency } = options;
+  const methodNameToReplace = newMethodName ?? oldMethodName;
+
+  // Flag to check if the method was imported from the old dependency
+  let methodImportedFromOldDependency = false;
+  const methodAliases: string[] = [];
+
+  // Remove the method from the old dependency and check if it was imported
+  root
+    .find(j.ImportDeclaration)
+    .filter((path) => path.node.source.value === oldDependency)
+    .forEach((path) => {
+      const importDeclaration: ImportDeclaration = path.node;
+
+      // Check if the method is imported from the old dependency
+      const methodSpecifiers = importDeclaration.specifiers?.filter(
+        (specifier) =>
+          specifier.type === 'ImportSpecifier' && specifier.imported.name === oldMethodName
+      );
+
+      if (methodSpecifiers && methodSpecifiers.length > 0) {
+        methodImportedFromOldDependency = true;
+
+        // Collect all aliases for the method
+        methodSpecifiers.forEach((specifier) => {
+          if (specifier.local && specifier.local.name !== oldMethodName) {
+            methodAliases.push(specifier.local.name);
+          } else {
+            methodAliases.push(methodNameToReplace);
+          }
+        });
+
+        // Remove the method specifiers from the old import
+        const updatedSpecifiers = importDeclaration.specifiers?.filter(
+          (specifier) =>
+            specifier.type !== 'ImportSpecifier' || specifier.imported.name !== oldMethodName
+        );
+
+        if (updatedSpecifiers && updatedSpecifiers.length > 0) {
+          // Replace the import with the updated specifiers if there are other imports left
+          j(path).replaceWith(j.importDeclaration(updatedSpecifiers, j.literal(oldDependency)));
+        } else {
+          // Remove the entire import statement if the specified method was the only import
+          j(path).remove();
+        }
+      }
+    });
+
+  // Add new import dependency if the method was imported from the old dependency
+  if (methodImportedFromOldDependency) {
+    const dependencies = root
+      .find(j.ImportDeclaration)
+      .filter((path) => path.node.source.value === newDependency);
+
+    if (dependencies.length > 0) {
+      // we have to use a flag to prevent adding the method to multiple imports
+      let methodAdded = false;
+      dependencies.forEach((path) => {
+        const importDeclaration: ImportDeclaration = path.node;
+        if (!methodAdded) {
+          methodAliases.forEach((alias) => {
+            // Check if the methodNameToReplace or its alias is already imported
+            const specifiersArray = importDeclaration.specifiers || [];
+            const methodAlreadyExists = specifiersArray.some(
+              (specifier) =>
+                specifier.type === 'ImportSpecifier' &&
+                specifier.imported.name === methodNameToReplace && // Check if imported method matches
+                specifier.local?.name === alias // Check if local alias matches
+            );
+
+            if (!methodAlreadyExists) {
+              // If method does not exist, add it
+              const newSpecifier = j.importSpecifier(
+                j.identifier(methodNameToReplace),
+                j.identifier(alias)
+              );
+              path.get('specifiers').replace([...specifiersArray, newSpecifier]);
+              methodAdded = true;
+            }
+          });
+        }
+      });
+    } else {
+      const newSpecifiers = methodAliases.map((alias) =>
+        j.importSpecifier(j.identifier(methodNameToReplace), j.identifier(alias))
+      );
+
+      const newImportDeclaration = j.importDeclaration(newSpecifiers, j.literal(newDependency));
+
+      // Find the index of the first non-import declaration
+      const body = root.get().node.program.body;
+      const lastImportIndex = body.findIndex((node) => node.type !== 'ImportDeclaration');
+
+      if (lastImportIndex > -1) {
+        // Insert the new import declaration just before the first non-import node
+        body.splice(lastImportIndex, 0, newImportDeclaration);
+      } else {
+        // Check if 'use strict' exists at the beginning
+        const hasUseStrict =
+          body[0]?.type === 'ExpressionStatement' && body[0]?.expression?.value === 'use strict';
+        // Add the new import after 'use strict' if it exists, otherwise at the beginning
+        body.splice(hasUseStrict ? 1 : 0, 0, newImportDeclaration);
+      }
+    }
+  }
+};

package/resources/utils/replace-jsx.ts

@@ -0,0 +1,49 @@
+import type { JSCodeshift, Collection } from 'jscodeshift';
+
+export const replaceJSXElement = (
+  root: Collection,
+  j: JSCodeshift,
+  {
+    oldElementName,
+    newElementName,
+    oldDependency,
+  }: {
+    oldElementName: string;
+    newElementName: string;
+    oldDependency: string;
+  }
+) => {
+  // Find the import declaration for the old dependency
+  const importDeclaration = root.find(j.ImportDeclaration, {
+    source: { value: oldDependency },
+  });
+
+  if (importDeclaration.size() === 0) {
+    return;
+  }
+
+  // Get the local name of the imported element
+  const localName = importDeclaration
+    .find(j.ImportSpecifier, {
+      imported: { name: oldElementName },
+    })
+    .nodes()[0]?.local?.name;
+
+  if (!localName) {
+    return;
+  }
+
+  // Replace JSX elements
+  root.findJSXElements(localName).forEach((path) => {
+    const openingElement = path.node.openingElement;
+    const closingElement = path.node.closingElement;
+
+    if (j.JSXIdentifier.check(openingElement.name)) {
+      openingElement.name.name = newElementName;
+    }
+
+    if (closingElement && j.JSXIdentifier.check(closingElement.name)) {
+      closingElement.name.name = newElementName;
+    }
+  });
+};