@strapi/admin 4.10.0-beta.0 → 4.10.0

package/ee/server/services/review-workflows/stages.js

@@ -4,12 +4,15 @@ const {
   mapAsync,
   errors: { ApplicationError },
 } = require('@strapi/utils');
+const { map } = require('lodash/fp');
 
 const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
 const { getService } = require('../../utils');
+const { getContentTypeUIDsWithActivatedReviewWorkflows } = require('../../utils/review-workflows');
 
 module.exports = ({ strapi }) => {
   const workflowsService = getService('workflows', { strapi });
+  const metrics = getService('review-workflows-metrics', { strapi });
 
   return {
     find({ workflowId, populate }) {
@@ -20,31 +23,43 @@ module.exports = ({ strapi }) => {
       return strapi.entityService.findMany(STAGE_MODEL_UID, params);
     },
 
-    findById(id, { workflowId, populate }) {
+    findById(id, { populate } = {}) {
       const params = {
-        filters: { workflow: workflowId },
         populate,
       };
       return strapi.entityService.findOne(STAGE_MODEL_UID, id, params);
     },
 
-    createMany(stagesList, { fields }) {
-      const params = {
-        select: fields,
-      };
-      return Promise.all(
+    async createMany(stagesList, { fields }) {
+      const params = { select: fields };
+
+      const stages = await Promise.all(
         stagesList.map((stage) =>
           strapi.entityService.create(STAGE_MODEL_UID, { data: stage, ...params })
         )
       );
+
+      metrics.sendDidCreateStage();
+
+      return stages;
     },
 
-    update(stageId, stageData) {
-      return strapi.entityService.update(STAGE_MODEL_UID, stageId, { data: stageData });
+    async update(stageId, stageData) {
+      const stage = await strapi.entityService.update(STAGE_MODEL_UID, stageId, {
+        data: stageData,
+      });
+
+      metrics.sendDidEditStage();
+
+      return stage;
     },
 
-    delete(stageId) {
-      return strapi.entityService.delete(STAGE_MODEL_UID, stageId);
+    async delete(stageId) {
+      const stage = await strapi.entityService.delete(STAGE_MODEL_UID, stageId);
+
+      metrics.sendDidDeleteStage();
+
+      return stage;
     },
 
     count() {
@@ -58,12 +73,41 @@ module.exports = ({ strapi }) => {
 
       assertAtLeastOneStageRemain(workflow.stages, { created, deleted });
 
-      return strapi.db.transaction(async () => {
-        const newStages = await this.createMany(created, { fields: ['id'] });
-        const stagesIds = stages.map((stage) => stage.id ?? newStages.shift().id);
+      return strapi.db.transaction(async ({ trx }) => {
+        // Create the new stages
+        const createdStages = await this.createMany(created, { fields: ['id'] });
+        // Put all the newly created stages ids
+        const createdStagesIds = map('id', createdStages);
+        const stagesIds = stages.map((stage) => stage.id ?? createdStagesIds.shift());
+        const contentTypes = getContentTypeUIDsWithActivatedReviewWorkflows(strapi.contentTypes);
 
+        // Update the workflow stages
         await mapAsync(updated, (stage) => this.update(stage.id, stage));
-        await mapAsync(deleted, (stage) => this.delete(stage.id));
+
+        // Delete the stages that are not in the new stages list
+        await mapAsync(deleted, async (stage) => {
+          // Find the nearest stage in the workflow and newly created stages
+          // that is not deleted, prioritizing the previous stages
+          const nearestStage = findNearestMatchingStage(
+            [...workflow.stages, ...createdStages],
+            workflow.stages.findIndex((s) => s.id === stage.id),
+            (targetStage) => {
+              return !deleted.find((s) => s.id === targetStage.id);
+            }
+          );
+
+          // Assign the new stage to entities that had the deleted stage
+          await mapAsync(contentTypes, (contentTypeUID) => {
+            this.updateEntitiesStage(contentTypeUID, {
+              fromStageId: stage.id,
+              toStageId: nearestStage.id,
+              trx,
+            });
+          });
+
+          return this.delete(stage.id);
+        });
+
         return workflowsService.update(workflowId, {
           stages: stagesIds,
         });
@@ -78,11 +122,61 @@ module.exports = ({ strapi }) => {
      * @param {string} entityInfo.modelUID - the content-type of the entity
      * @param {number} stageId - The id of the stage to assign to the entity
      */
-    updateEntity(entityInfo, stageId) {
-      return strapi.entityService.update(entityInfo.modelUID, entityInfo.id, {
+    async updateEntity(entityInfo, stageId) {
+      const stage = await this.findById(stageId);
+
+      if (!stage) {
+        throw new ApplicationError(`Selected stage does not exist`);
+      }
+
+      const entity = await strapi.entityService.update(entityInfo.modelUID, entityInfo.id, {
         data: { [ENTITY_STAGE_ATTRIBUTE]: stageId },
         populate: [ENTITY_STAGE_ATTRIBUTE],
       });
+
+      metrics.sendDidChangeEntryStage();
+
+      return entity;
+    },
+
+    /**
+     * Updates the stage of all entities of a content type that are in a specific stage
+     * @param {string} contentTypeUID
+     * @param {number} fromStageId
+     * @param {number} toStageId
+     * @param {KnexTransaction} trx
+     * @returns
+     */
+    async updateEntitiesStage(contentTypeUID, { fromStageId, toStageId, trx = null }) {
+      const { attributes, tableName } = strapi.db.metadata.get(contentTypeUID);
+      const joinTable = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable;
+      const joinColumn = joinTable.joinColumn.name;
+      const invJoinColumn = joinTable.inverseJoinColumn.name;
+
+      const selectStatement = strapi.db
+        .getConnection()
+        .select({ [joinColumn]: 't1.id', [invJoinColumn]: toStageId })
+        .from(`${tableName} as t1`)
+        .leftJoin(`${joinTable.name} as t2`, `t1.id`, `t2.${joinColumn}`)
+        .where(`t2.${invJoinColumn}`, fromStageId)
+        .toSQL();
+
+      // Insert rows for all entries of the content type that do not have a
+      // default stage
+      const query = strapi.db
+        .getConnection(joinTable.name)
+        .insert(
+          strapi.db.connection.raw(
+            `(${joinColumn}, ${invJoinColumn})  ${selectStatement.sql}`,
+            selectStatement.bindings
+          )
+        );
+
+      if (trx) {
+        query.transacting(trx);
+      }
+
+      return query;
     },
   };
 };
@@ -146,3 +240,28 @@ function assertAtLeastOneStageRemain(workflowStages, diffStages) {
     throw new ApplicationError('At least one stage must remain in the workflow.');
   }
 }
+
+/**
+ * Find the id of the nearest object in an array that matches a condition.
+ * Used for searching for the nearest stage that is not deleted.
+ * Starts by searching the elements before the index, then the remaining elements in the array.
+ *
+ * @param {Array} stages
+ * @param {Number} startIndex the index to start searching from
+ * @param {Function} condition must evaluate to true for the object to be considered a match
+ * @returns {Object} stage
+ */
+function findNearestMatchingStage(stages, startIndex, condition) {
+  // Start by searching the elements before the startIndex
+  for (let i = startIndex; i >= 0; i -= 1) {
+    if (condition(stages[i])) {
+      return stages[i];
+    }
+  }
+
+  // If no matching element is found before the startIndex,
+  // search the remaining elements in the array
+  const remainingArray = stages.slice(startIndex + 1);
+  const nearestObject = remainingArray.filter(condition)[0];
+  return nearestObject;
+}

package/ee/server/utils/persisted-tables.js

@@ -1,49 +1,143 @@
 'use strict';
 
+const { differenceWith, isEqual } = require('lodash/fp');
+
 /**
- * Finds all tables in the database that start with a prefix
- * @param {string} prefix
- * @returns {Array}
+ * Transform table name to the object format
+ * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} table
+ * @returns Array<{ table: string; dependsOn?: Array<{ table: string;}> }>
  */
-const findTablesThatStartWithPrefix = async (prefix) => {
-  const tables = await strapi.db.dialect.schemaInspector.getTables();
-  return tables.filter((tableName) => tableName.startsWith(prefix));
+const transformTableName = (table) => {
+  if (typeof table === 'string') {
+    return { name: table };
+  }
+  return table;
 };
 
 /**
- * Get all reserved table names from the core store
- * @returns {Array}
+ * Finds all tables in the database matching the regular expression
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {RegExp} regex
+ * @returns {Promise<string[]>}
+ */
+async function findTables({ strapi }, regex) {
+  const tables = await strapi.db.dialect.schemaInspector.getTables();
+  return tables.filter((tableName) => regex.test(tableName));
+}
+
+/**
+ * Add tables name to the reserved tables in core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} tableNames
+ * @return {Promise<void>}
  */
-const getPersistedTables = async () =>
-  (await strapi.store.get({
+async function addPersistTables({ strapi }, tableNames) {
+  const persistedTables = await getPersistedTables({ strapi });
+  const tables = tableNames.map(transformTableName);
+
+  // Get new tables to be persisted, remove tables if they already were persisted
+  const notPersistedTableNames = differenceWith(isEqual, tables, persistedTables);
+  // Remove tables that are going to be changed
+  const tablesToPersist = differenceWith(
+    (t1, t2) => t1.name === t2.name,
+    persistedTables,
+    notPersistedTableNames
+  );
+
+  if (!notPersistedTableNames.length) {
+    return;
+  }
+
+  tablesToPersist.push(...notPersistedTableNames);
+  await strapi.store.set({
     type: 'core',
     key: 'persisted_tables',
-  })) ?? [];
+    value: tablesToPersist,
+  });
+}
 
 /**
- * Add all table names that start with a prefix to the reserved tables in
- * core store
- * @param {string} tableNamePrefix
+ * Remove tables name from the reserved tables in core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {Array<string>} tableNames
+ * @return {Promise<void>}
  */
+async function removePersistedTables({ strapi }, tableNames) {
+  const persistedTables = await getPersistedTables({ strapi });
 
-const persistTablesWithPrefix = async (tableNamePrefix) => {
-  const persistedTables = await getPersistedTables();
-  const tableNames = await findTablesThatStartWithPrefix(tableNamePrefix);
-  const notReservedTableNames = tableNames.filter((name) => !persistedTables.includes(name));
+  // Get new tables to be persisted, remove tables if they already were persisted
+  const newPersistedTables = differenceWith(
+    (t1, t2) => t1.name === t2,
+    persistedTables,
+    tableNames
+  );
 
-  if (!notReservedTableNames.length) {
+  if (newPersistedTables.length === persistedTables.length) {
     return;
   }
 
-  persistedTables.push(...notReservedTableNames);
   await strapi.store.set({
     type: 'core',
     key: 'persisted_tables',
-    value: persistedTables,
+    value: newPersistedTables,
   });
+}
+
+/**
+ * Get all reserved table names from the core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @returns {Promise<string[]>}
+ */
+
+async function getPersistedTables({ strapi }) {
+  const persistedTables = await strapi.store.get({
+    type: 'core',
+    key: 'persisted_tables',
+  });
+
+  return (persistedTables || []).map(transformTableName);
+}
+
+/**
+ * Add all table names that start with a prefix to the reserved tables in
+ * core store
+ * @param {string} tableNamePrefix
+ * @return {Promise<void>}
+ */
+
+const persistTablesWithPrefix = async (tableNamePrefix) => {
+  const tableNameRegex = new RegExp(`^${tableNamePrefix}.*`);
+  const tableNames = await findTables({ strapi }, tableNameRegex);
+
+  await addPersistTables({ strapi }, tableNames);
+};
+
+/**
+ * Remove all table names that end with a suffix from the reserved tables in core store
+ * @param {string} tableNameSuffix
+ * @return {Promise<void>}
+ */
+const removePersistedTablesWithSuffix = async (tableNameSuffix) => {
+  const tableNameRegex = new RegExp(`.*${tableNameSuffix}$`);
+  const tableNames = await findTables({ strapi }, tableNameRegex);
+  await removePersistedTables({ strapi }, tableNames);
+};
+
+/**
+ * Add tables to the reserved tables in core store
+ * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }} tables
+ */
+const persistTables = async (tables) => {
+  await addPersistTables({ strapi }, tables);
 };
 
 module.exports = {
   persistTablesWithPrefix,
-  findTablesThatStartWithPrefix,
+  removePersistedTablesWithSuffix,
+  persistTables,
+  findTables,
 };

package/ee/server/utils/review-workflows.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { get, keys, pickBy, pipe } = require('lodash/fp');
 const { WORKFLOW_MODEL_UID } = require('../constants/workflows');
 
 /**
@@ -19,7 +20,15 @@ function hasReviewWorkflow({ strapi }, contentType) {
 const getDefaultWorkflow = async ({ strapi }) =>
   strapi.query(WORKFLOW_MODEL_UID).findOne({ populate: ['stages'] });
 
+const getContentTypeUIDsWithActivatedReviewWorkflows = pipe([
+  // Pick only content-types with reviewWorkflows options set to true
+  pickBy(get('options.reviewWorkflows')),
+  // Get UIDs
+  keys,
+]);
+
 module.exports = {
   hasReviewWorkflow,
   getDefaultWorkflow,
+  getContentTypeUIDsWithActivatedReviewWorkflows,
 };

package/jest.config.front.js

@@ -1,11 +1,6 @@
 'use strict';
 
-const baseConfig = require('../../../jest.base-config.front');
-const pkg = require('./package.json');
-
 module.exports = {
-  ...baseConfig,
-  displayName: (pkg.strapi && pkg.strapi.name) || pkg.name,
-  roots: [__dirname],
+  preset: '../../../jest-preset.front.js',
   collectCoverageFrom: ['<rootDir>/packages/core/admin/admin/**/*.js'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/admin",
-  "version": "4.10.0-beta.0",
+  "version": "4.10.0",
   "description": "Strapi Admin",
   "repository": {
     "type": "git",
@@ -28,14 +28,16 @@
     "develop:webpack": "cross-env NODE_ENV=development webpack serve --config webpack.config.dev.js --progress profile",
     "prepublishOnly": "yarn build",
     "build": "rimraf build && node ./scripts/build.js",
-    "build:mesure": "rimraf build && cross-env MESURE_BUILD_SPEED=true node ./scripts/build.js",
+    "build:measure": "rimraf build && cross-env MEASURE_BUILD_SPEED=true node ./scripts/build.js",
     "test": "echo \"no tests yet\"",
-    "test:unit": "jest --verbose",
-    "test:front": "cross-env IS_EE=true jest --config ./jest.config.front.js",
-    "test:front:watch": "cross-env IS_EE=true jest --config ./jest.config.front.js --watchAll",
-    "test:front:ce": "cross-env IS_EE=false jest --config ./jest.config.front.js",
-    "test:front:watch:ce": "cross-env IS_EE=false jest --config ./jest.config.front.js --watchAll",
-    "test:front:ce:cov": "cross-env IS_EE=false jest --config ./jest.config.front.js --coverage"
+    "test:unit": "run -T jest",
+    "test:unit:watch": "run -T jest --watch",
+    "test:front": "run -T cross-env IS_EE=true jest --config ./jest.config.front.js",
+    "test:front:watch": "run -T cross-env IS_EE=true jest --config ./jest.config.front.js --watchAll",
+    "test:front:ce": "run -T cross-env IS_EE=false jest --config ./jest.config.front.js",
+    "test:front:watch:ce": "run -T cross-env IS_EE=false jest --config ./jest.config.front.js --watchAll",
+    "test:front:ce:cov": "run -T cross-env IS_EE=false jest --config ./jest.config.front.js --coverage",
+    "lint": "run -T eslint ."
   },
   "dependencies": {
     "@babel/core": "^7.20.12",
@@ -46,19 +48,20 @@
     "@casl/ability": "^5.4.3",
     "@fingerprintjs/fingerprintjs": "3.3.6",
     "@pmmmwh/react-refresh-webpack-plugin": "0.5.10",
-    "@strapi/babel-plugin-switch-ee-ce": "4.10.0-beta.0",
-    "@strapi/data-transfer": "4.10.0-beta.0",
+    "@strapi/babel-plugin-switch-ee-ce": "4.10.0",
+    "@strapi/data-transfer": "4.10.0",
     "@strapi/design-system": "1.6.6",
-    "@strapi/helper-plugin": "4.10.0-beta.0",
+    "@strapi/helper-plugin": "4.10.0",
     "@strapi/icons": "1.6.6",
-    "@strapi/permissions": "4.10.0-beta.0",
-    "@strapi/provider-audit-logs-local": "4.10.0-beta.0",
-    "@strapi/typescript-utils": "4.10.0-beta.0",
-    "@strapi/utils": "4.10.0-beta.0",
+    "@strapi/permissions": "4.10.0",
+    "@strapi/provider-audit-logs-local": "4.10.0",
+    "@strapi/typescript-utils": "4.10.0",
+    "@strapi/utils": "4.10.0",
     "axios": "1.3.4",
     "babel-loader": "^9.1.2",
     "babel-plugin-styled-components": "2.0.2",
     "bcryptjs": "2.4.3",
+    "browserslist": "^4.17.3",
     "browserslist-to-esbuild": "1.2.0",
     "chalk": "^4.1.2",
     "chokidar": "^3.5.1",
@@ -99,18 +102,17 @@
     "markdown-it-mark": "^3.0.1",
     "markdown-it-sub": "^1.0.0",
     "markdown-it-sup": "1.0.0",
-    "match-sorter": "^4.0.2",
     "mini-css-extract-plugin": "2.7.2",
     "node-schedule": "2.1.0",
     "p-map": "4.0.0",
     "passport-local": "1.0.0",
     "pluralize": "8.0.0",
     "prop-types": "^15.7.2",
-    "qs": "6.11.0",
+    "qs": "6.11.1",
     "react": "^17.0.2",
     "react-copy-to-clipboard": "^5.1.0",
     "react-dnd": "15.1.2",
-    "react-dnd-html5-backend": "15.1.2",
+    "react-dnd-html5-backend": "15.1.3",
     "react-dom": "^17.0.2",
     "react-error-boundary": "3.1.4",
     "react-fast-compare": "^3.2.0",
@@ -122,16 +124,16 @@
     "react-refresh": "0.14.0",
     "react-router-dom": "5.3.4",
     "react-select": "5.7.0",
-    "react-window": "1.8.7",
+    "react-window": "1.8.8",
     "redux": "^4.2.1",
     "reselect": "^4.1.7",
     "rimraf": "3.0.2",
-    "sanitize-html": "2.7.3",
+    "sanitize-html": "2.10.0",
     "semver": "7.3.8",
-    "sift": "16.0.0",
+    "sift": "16.0.1",
     "style-loader": "3.3.1",
     "styled-components": "5.3.3",
-    "typescript": "4.6.2",
+    "typescript": "5.0.4",
     "webpack": "^5.76.0",
     "webpack-cli": "^5.0.1",
     "webpack-dev-server": "^4.13.1",
@@ -166,5 +168,5 @@
       }
     }
   },
-  "gitHead": "1519ef0e56d27b738f24fc88223797651ad47aaf"
+  "gitHead": "9b5519778faaedfb837879f9c6f7e28fdfd6750d"
 }

package/server/controllers/transfer/runner.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { createTransferHandler } = require('@strapi/data-transfer').strapi.remote.handlers;
+const { createPushController, createPullController } =
+  require('@strapi/data-transfer').strapi.remote.handlers;
 const {
   errors: { UnauthorizedError },
 } = require('@strapi/utils');
@@ -22,5 +23,6 @@ const verify = async (ctx, scope) => {
 };
 
 module.exports = {
-  connect: createTransferHandler({ verify }),
+  push: createPushController({ verify }),
+  pull: createPullController({ verify }),
 };

package/server/middlewares/data-transfer.js

@@ -13,7 +13,10 @@ module.exports = () => async (ctx, next) => {
 
   if (!hasValidTokenSalt()) {
     return ctx.notImplemented(
-      'The server configuration for data transfer is invalid. Please contact your server administrator.'
+      'The server configuration for data transfer is invalid. Please contact your server administrator.',
+      {
+        code: 'INVALID_TOKEN_SALT',
+      }
     );
   }
 

package/server/routes/transfer.js

@@ -3,17 +3,26 @@
 const dataTransferAuthStrategy = require('../strategies/data-transfer');
 
 module.exports = [
-  // Transfer route
+  // Transfer Push
   {
     method: 'GET',
-    path: '/transfer/runner/connect',
-    handler: 'transfer.runner-connect',
+    path: '/transfer/runner/push',
+    handler: 'transfer.runner-push',
     config: {
       middlewares: ['admin::data-transfer'],
-      // TODO: Allow not passing any scope <> Add a way to prevent assigning one by default
       auth: { strategies: [dataTransferAuthStrategy], scope: ['push'] },
     },
   },
+  // Transfer Pull
+  {
+    method: 'GET',
+    path: '/transfer/runner/pull',
+    handler: 'transfer.runner-pull',
+    config: {
+      middlewares: ['admin::data-transfer'],
+      auth: { strategies: [dataTransferAuthStrategy], scope: ['pull'] },
+    },
+  },
   // Transfer Tokens
   {
     method: 'POST',

package/server/services/constants.js

@@ -24,6 +24,10 @@ module.exports = {
     DAYS_30: 30 * DAY_IN_MS,
     DAYS_90: 90 * DAY_IN_MS,
   },
+  TRANSFER_TOKEN_TYPE: {
+    PUSH: 'push',
+    PULL: 'pull',
+  },
   TRANSFER_TOKEN_LIFESPANS: {
     UNLIMITED: null,
     DAYS_7: 7 * DAY_IN_MS,

package/server/services/transfer/permission.js

@@ -3,7 +3,7 @@
 const permissions = require('@strapi/permissions');
 const { providerFactory } = require('@strapi/utils');
 
-const DEFAULT_TRANSFER_ACTIONS = ['push'];
+const DEFAULT_TRANSFER_ACTIONS = ['push', 'pull'];
 
 const providers = {
   action: providerFactory(),