@strapi/upgrade 0.0.0-experimental.e3e48deb89bd0a1b6cc69b698696566fa7854a95 → 0.0.0-experimental.e9122b401c96877b6707775c4f893660eab93ae3

package/resources/codemods/5.0.0/dependency-upgrade-react-router-dom.json.ts

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import semver from 'semver';
+
+import type { modules } from '../../../dist';
+
+const REACT_ROUTER_DEP_NAME = 'react-router-dom';
+const REACT_ROUTER_DEP_PATH = `dependencies.${REACT_ROUTER_DEP_NAME}`;
+
+const DEP_NEW_VERSION_RANGE = '^6.0.0';
+
+/**
+ * Specifically targets the root package.json and updates the react-router-dom dependency version.
+ *
+ * We first check if the react-router-dom dependency is listed in the package.json. If the dependency is
+ * found, we verify its version.
+ *
+ * If the detected version does not satisfy the new version range, we replace it with the new one.
+ *
+ * Conversely, if no react-router-dom dependency is listed, we add it with the new version range.
+ */
+const transform: modules.runner.json.JSONTransform = (file, params) => {
+  const { cwd, json } = params;
+
+  const rootPackageJsonPath = path.join(cwd, 'package.json');
+
+  if (file.path !== rootPackageJsonPath) {
+    return file.json;
+  }
+
+  const j = json(file.json);
+
+  if (j.has(REACT_ROUTER_DEP_PATH)) {
+    const currentVersion = j.get(REACT_ROUTER_DEP_PATH);
+
+    // If the current version is not a string, then something is wrong, abort
+    if (typeof currentVersion !== 'string') {
+      return j.root();
+    }
+
+    const currentSatisfiesNew = semver.satisfies(currentVersion, DEP_NEW_VERSION_RANGE);
+
+    // if the current version satisfies the new range, keep it as is and abort
+    if (currentSatisfiesNew) {
+      return j.root();
+    }
+
+    // else, update the version with the new one
+    j.set(REACT_ROUTER_DEP_PATH, DEP_NEW_VERSION_RANGE);
+  }
+
+  // If the dependency is not listed yet, add it
+  else {
+    j.set(REACT_ROUTER_DEP_PATH, DEP_NEW_VERSION_RANGE);
+  }
+
+  return j.root();
+};
+
+export default transform;

package/resources/codemods/5.0.0/dependency-upgrade-styled-components.json.ts

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import semver from 'semver';
+
+import type { modules } from '../../../dist';
+
+const DEP_NAME = 'styled-components';
+const DEP_PATH = `dependencies.${DEP_NAME}`;
+
+const DEP_NEW_VERSION_RANGE = '^6.0.0';
+
+const transform: modules.runner.json.JSONTransform = (file, params) => {
+  const { cwd, json } = params;
+
+  const rootPackageJsonPath = path.join(cwd, 'package.json');
+
+  if (file.path !== rootPackageJsonPath) {
+    return file.json;
+  }
+
+  const j = json(file.json);
+
+  if (j.has(DEP_PATH)) {
+    const currentVersion = j.get(DEP_PATH);
+
+    // If the current version is not a string, then something is wrong, abort
+    if (typeof currentVersion !== 'string') {
+      return j.root();
+    }
+
+    const currentSatisfiesNew = semver.satisfies(currentVersion, DEP_NEW_VERSION_RANGE);
+
+    // if the current version satisfies the new range, keep it as is and abort
+    if (currentSatisfiesNew) {
+      return j.root();
+    }
+
+    // else, update the version with the new one
+    j.set(DEP_PATH, DEP_NEW_VERSION_RANGE);
+  }
+
+  // If the dependency is not listed yet, add it
+  else {
+    j.set(DEP_PATH, DEP_NEW_VERSION_RANGE);
+  }
+
+  return j.root();
+};
+
+export default transform;

package/resources/codemods/5.0.0/entity-service-document-service.code.ts

@@ -0,0 +1,437 @@
+import type { Transform, JSCodeshift, ASTPath, ObjectExpression } from 'jscodeshift';
+
+/*
+This codemod transforms entity service calls to match the new document service interface.
+It supports all kind of argument parsing, including spread elements & deeply nested objects.
+
+Here is a list of scenarios this was tested against
+
+const uid = "api::xxx.xxx";
+const entityId = 1;
+
+Case: basic call
+
+strapi.entityService.findOne(uid, entityId, {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  publicationState: "preview",
+});
+
+
+Case: using a variable declared somewhere else
+
+const objectParam_2 = {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  publicationState: "preview",
+};
+
+strapi.entityService.findOne(uid, entityId, objectParam_2);
+
+Case: using a variable declared somewhere else with a spread element
+
+const objectParam_3 = {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  publicationState: "preview",
+};
+
+strapi.entityService.findOne(uid, entityId, {
+  ...objectParam_3,
+});
+
+
+Case: using a variable declared somewhere else with a spread element and overwritten properties
+
+const objectParam_4_1 = {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  publicationState: "preview",
+};
+
+const objectParam_4 = {
+  publicationState: "live",
+  ...objectParam_4_1,
+};
+
+strapi.entityService.findOne(uid, entityId, {
+  ...objectParam_4,
+});
+
+Case: using a variable declared somewhere else with a spread array element while that need its 1st element to be moved
+
+const objectParam_5 = [
+  uid,
+  entityId,
+  {
+    fields: ["id", "name", "description"],
+    populate: ["author", "comments"],
+    publicationState: "preview",
+  },
+];
+
+strapi.entityService.findOne(...objectParam_5);
+
+Case: using a variable declared somewhere else with a partial spread array
+
+const objectParam_6 = [
+  entityId,
+  {
+    fields: ["id", "name", "description"],
+    populate: ["author", "comments"],
+    publicationState: "preview",
+  },
+];
+
+strapi.entityService.findOne(uid, ...objectParam_6);
+
+Case: using a variable declared somewhere else with a partial & nested spread arrays
+
+const objectParam_7_1 = [
+  {
+    fields: ["id", "name", "description"],
+    populate: ["author", "comments"],
+    publicationState: "preview",
+  },
+];
+
+const objectParam_7 = [entityId, ...objectParam_7_1];
+
+strapi.entityService.findOne(uid, ...objectParam_7);
+
+Case: using a variable declared somewhere else with a partial & nested spread arrays & objects
+
+const objectParam_8_1 = {
+  publicationState: "preview",
+};
+
+const objectParam_8 = [
+  entityId,
+  {
+    fields: ["id", "name", "description"],
+    populate: ["author", "comments"],
+    ...objectParam_8_1,
+  },
+];
+
+strapi.entityService.findOne(uid, ...objectParam_8);
+
+
+Case: some sort of mix of all the above
+
+const objectParam_9_1 = {
+  publicationState: "preview",
+};
+
+const objectParam_9 = {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  ...objectParam_9_1,
+};
+
+strapi.entityService.findOne(uid, ...[entityId, [objectParam_9]]);
+
+Case:  even more complex
+
+const objectParam_10_1 = {
+  publicationState: "preview",
+};
+
+const objectParam_10_2 = [uid, ...[12], ...[objectParam_10_1]];
+const objectParam_10 = [...objectParam_10_2];
+
+strapi.entityService.findOne(...[...objectParam_10]);
+
+Case: find, create, update, delete with entityId as first argument
+
+strapi.entityService.findMany(uid, {
+  fields: ["id", "name", "description"],
+  populate: ["author", "comments"],
+  publicationState: "preview",
+});
+
+strapi.entityService.create(uid, {
+  data: {
+    name: "John Doe",
+    age: 30,
+  },
+});
+
+strapi.entityService.update(uid, entityId, {
+  data: {
+    name: "John Doe",
+    age: 30,
+  },
+});
+
+strapi.entityService.delete(uid, entityId);
+strapi.entityService.findOne(uid, entityId);
+
+*/
+
+const movedFunctions = ['findOne', 'findMany', 'count', 'create', 'update', 'delete'];
+
+const functionsWithEntityId = ['findOne', 'update', 'delete'];
+
+const transformDeclaration = (path: ASTPath<any>, name: any, j: JSCodeshift) => {
+  const declaration = findClosestDeclaration(path, name, j);
+
+  if (!declaration) {
+    return;
+  }
+
+  transformElement(path, declaration.init, j);
+};
+
+const transformElement = (path: ASTPath<any>, element: any, j: JSCodeshift) => {
+  switch (true) {
+    case j.ObjectExpression.check(element): {
+      transformObjectParam(path, element, j);
+      break;
+    }
+
+    case j.Identifier.check(element): {
+      transformDeclaration(path, element.name, j);
+      break;
+    }
+
+    case j.SpreadElement.check(element): {
+      transformElement(path, element.argument, j);
+      break;
+    }
+
+    case j.ArrayExpression.check(element): {
+      element.elements.forEach((element) => {
+        transformElement(path, element, j);
+      });
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+};
+
+const transformObjectParam = (path: ASTPath<any>, expression: ObjectExpression, j: JSCodeshift) => {
+  expression.properties.forEach((prop) => {
+    switch (true) {
+      case j.ObjectProperty.check(prop): {
+        if (!j.Identifier.check(prop.key) && !j.Literal.check(prop.key)) {
+          return;
+        }
+
+        if (j.Identifier.check(prop.key) && prop.key.name !== 'publicationState') {
+          return;
+        }
+
+        if (j.Literal.check(prop.key) && prop.key.value !== 'publicationState') {
+          return;
+        }
+
+        if (j.Identifier.check(prop.key) && prop.key.name === 'publicationState') {
+          if (!prop.computed && !prop.shorthand) {
+            prop.key.name = 'status';
+          }
+
+          if (prop.shorthand && !prop.computed) {
+            prop.shorthand = false;
+            prop.key = j.identifier('status');
+            prop.value = j.identifier('publicationState');
+          }
+        } else if (j.Literal.check(prop.key) && prop.key.value === 'publicationState') {
+          prop.key.value = 'status';
+        }
+
+        switch (true) {
+          case j.Literal.check(prop.value): {
+            prop.value = prop.value.value === 'live' ? j.literal('published') : j.literal('draft');
+
+            break;
+          }
+          case j.Identifier.check(prop.value): {
+            const declaration = findClosestDeclaration(path, prop.value.name, j);
+
+            if (!declaration) {
+              return;
+            }
+
+            if (j.Literal.check(declaration.init)) {
+              declaration.init =
+                declaration.init.value === 'live' ? j.literal('published') : j.literal('draft');
+            }
+
+            break;
+          }
+          default: {
+            break;
+          }
+        }
+
+        break;
+      }
+      case j.SpreadElement.check(prop): {
+        transformElement(path, prop.argument, j);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  });
+};
+
+const findClosestDeclaration = (path: ASTPath<any>, name: string, j) => {
+  // find Identifier declaration
+  const scope = path.scope.lookup(name);
+
+  if (!scope) {
+    return;
+  }
+
+  return j(scope.path)
+    .find(j.VariableDeclarator, { id: { type: 'Identifier', name } })
+    .nodes()[0];
+};
+
+const transform: Transform = (file, api) => {
+  const j = api.jscodeshift;
+
+  const root = j(file.source);
+
+  root
+    .find(j.CallExpression, {
+      callee: {
+        type: 'MemberExpression',
+        object: {
+          type: 'MemberExpression',
+          object: {
+            type: 'Identifier',
+            name: 'strapi',
+          },
+          property: {
+            type: 'Identifier',
+            name: 'entityService',
+          },
+        },
+        property: {
+          type: 'Identifier',
+          name: (name) => movedFunctions.includes(name),
+        },
+      },
+    })
+    .replaceWith((path) => {
+      if (!j.MemberExpression.check(path.value.callee)) {
+        return;
+      }
+
+      const args = path.value.arguments;
+
+      if (args.length === 0) {
+        // we don't know how to transform this
+        return;
+      }
+
+      type Args = typeof path.value.arguments;
+
+      function resolveArgs(args: Args): Args {
+        return args.flatMap((arg: Args[number]) => {
+          switch (true) {
+            case j.Identifier.check(arg):
+            case j.Literal.check(arg): {
+              return arg;
+            }
+            case j.SpreadElement.check(arg): {
+              switch (true) {
+                case j.Identifier.check(arg.argument): {
+                  const identifier = arg.argument;
+
+                  const declaration = findClosestDeclaration(path, identifier.name, j);
+
+                  if (!declaration) {
+                    return arg;
+                  }
+
+                  switch (true) {
+                    case j.ArrayExpression.check(declaration.init): {
+                      return resolveArgs(declaration.init.elements);
+                    }
+                    default:
+                      return arg;
+                  }
+                }
+                case j.ArrayExpression.check(arg.argument): {
+                  return resolveArgs(arg.argument.elements as Args);
+                }
+                default: {
+                  return arg;
+                }
+              }
+            }
+            default: {
+              return arg;
+            }
+          }
+        });
+      }
+
+      const resolvedArgs = resolveArgs(args);
+
+      const [docUID, ...rest] = resolvedArgs;
+
+      // function with entityId as first argument
+      if (
+        j.Identifier.check(path.value.callee.property) &&
+        functionsWithEntityId.includes(path.value.callee.property.name)
+      ) {
+        rest.splice(0, 1);
+
+        // in case no extra params are passed in the function e.g delete(uid, entityId)
+        if (rest.length === 0) {
+          rest.push(
+            j.objectExpression.from({
+              properties: [],
+            })
+          );
+        }
+
+        const params = rest[0];
+
+        const placeholder = j.objectProperty(j.identifier('documentId'), j.literal('__TODO__'));
+
+        // add documentId to params with a placeholder
+        if (j.ObjectExpression.check(params)) {
+          params.properties.unshift(placeholder);
+        } else if (j.Identifier.check(params)) {
+          const declaration = findClosestDeclaration(path, params.name, j);
+
+          if (!declaration) {
+            return;
+          }
+
+          if (j.ObjectExpression.check(declaration.init)) {
+            declaration.init.properties.unshift(placeholder);
+          }
+        }
+      }
+
+      path.value.arguments.forEach((arg) => {
+        transformElement(path, arg, j);
+      });
+
+      return j.callExpression(
+        j.memberExpression(
+          j.callExpression(j.memberExpression(j.identifier('strapi'), j.identifier('documents')), [
+            docUID,
+          ]),
+          path.value.callee.property
+        ),
+        rest
+      );
+    });
+
+  return root.toSource();
+};
+
+export const parser = 'tsx';
+
+export default transform;

package/resources/codemods/5.0.0/nocontent-migrate-to-emptystatelayout.code.ts

@@ -0,0 +1,30 @@
+import type { Transform } from 'jscodeshift';
+import { changeImportSpecifier } from '../../utils/change-import';
+import { replaceJSXElement } from '../../utils/replace-jsx';
+
+/**
+ * change NoContent import from '@strapi/helper-plugin' to EmptyStateLayout from '@strapi/design-system'
+ * And replace all uses of NoContent with EmptyStateLayout
+ */
+const transform: Transform = (file, api) => {
+  const { j } = api;
+
+  const root = j.withParser('tsx')(file.source);
+
+  replaceJSXElement(root, j, {
+    oldElementName: 'NoContent',
+    newElementName: 'EmptyStateLayout',
+    oldDependency: '@strapi/helper-plugin',
+  });
+
+  changeImportSpecifier(root, j, {
+    oldMethodName: 'NoContent',
+    newMethodName: 'EmptyStateLayout',
+    oldDependency: '@strapi/helper-plugin',
+    newDependency: '@strapi/design-system',
+  });
+
+  return root.toSource();
+};
+
+export default transform;

package/resources/codemods/5.0.0/s3-keys-wrapped-in-credentials.code.ts

@@ -59,7 +59,7 @@ const transform: Transform = (file, api) => {
   }
 
   const { j } = api;
-  const root = j(file.source);
+  const root = j.withParser('tsx')(file.source);
 
   root
     .find(j.ArrowFunctionExpression)

package/resources/codemods/5.0.0/sqlite3-to-better-sqlite3.json.ts

@@ -17,18 +17,21 @@ const transform: modules.runner.json.JSONTransform = (file, params) => {
 
   const j = json(file.json);
 
+  let removed = false;
+
   const targetProperties = ['sqlite3', '@vscode/sqlite3'];
 
   targetProperties.forEach((targetProperty) => {
     const oldSqliteDependency = `dependencies.${targetProperty}`;
     if (j.has(oldSqliteDependency)) {
       j.remove(oldSqliteDependency);
+      removed = true;
     }
   });
 
-  if (!j.has('dependencies.better-sqlite3')) {
+  if (removed && !j.has('dependencies.better-sqlite3')) {
     // TODO check this version when releasing V5
-    j.set('dependencies.better-sqlite3', '9.0.0');
+    j.set('dependencies.better-sqlite3', '9.4.3');
   }
 
   return j.root();