@strapi/admin 4.6.2 → 4.7.0-exp.3d6a31eb083e9d44afcf98f68c107fb7567e5720

package/server/bootstrap.js

@@ -78,6 +78,7 @@ module.exports = async () => {
   const userService = getService('user');
   const roleService = getService('role');
   const apiTokenService = getService('api-token');
+  const transferService = getService('transfer');
   const tokenService = getService('token');
 
   await roleService.createRolesIfNoneExist();
@@ -93,5 +94,6 @@ module.exports = async () => {
   await syncAPITokensPermissions();
 
   apiTokenService.checkSaltIsDefined();
+  transferService.token.checkSaltIsDefined();
   tokenService.checkSecretIsDefined();
 };

package/server/config/admin-actions.js

@@ -164,5 +164,53 @@ module.exports = {
       section: 'settings',
       category: 'project',
     },
+    {
+      uid: 'transfer.tokens.access',
+      displayName: 'Access the transfer tokens settings page',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'transfer tokens',
+    },
+    {
+      uid: 'transfer.tokens.create',
+      displayName: 'Create (generate)',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'general',
+    },
+    {
+      uid: 'transfer.tokens.read',
+      displayName: 'Read',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'general',
+    },
+    {
+      uid: 'transfer.tokens.update',
+      displayName: 'Update',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'general',
+    },
+    {
+      uid: 'transfer.tokens.regenerate',
+      displayName: 'Regenerate',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'general',
+    },
+    {
+      uid: 'transfer.tokens.delete',
+      displayName: 'Delete (revoke)',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'transfer tokens',
+      subCategory: 'general',
+    },
   ],
 };

package/server/content-types/index.js

@@ -6,4 +6,6 @@ module.exports = {
   role: { schema: require('./Role') },
   'api-token': { schema: require('./api-token') },
   'api-token-permission': { schema: require('./api-token-permission') },
+  'transfer-token': { schema: require('./transfer-token') },
+  'transfer-token-permission': { schema: require('./transfer-token-permission') },
 };

package/server/content-types/transfer-token-permission.js

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports = {
+  collectionName: 'strapi_transfer_token_permissions',
+  info: {
+    name: 'Transfer Token Permission',
+    description: '',
+    singularName: 'transfer-token-permission',
+    pluralName: 'transfer-token-permissions',
+    displayName: 'Transfer Token Permission',
+  },
+  options: {},
+  pluginOptions: {
+    'content-manager': {
+      visible: false,
+    },
+    'content-type-builder': {
+      visible: false,
+    },
+  },
+  attributes: {
+    action: {
+      type: 'string',
+      minLength: 1,
+      configurable: false,
+      required: true,
+    },
+    token: {
+      configurable: false,
+      type: 'relation',
+      relation: 'manyToOne',
+      inversedBy: 'permissions',
+      target: 'admin::transfer-token',
+    },
+  },
+};

package/server/content-types/transfer-token.js

@@ -0,0 +1,66 @@
+'use strict';
+
+module.exports = {
+  collectionName: 'strapi_transfer_tokens',
+  info: {
+    name: 'Transfer Token',
+    singularName: 'transfer-token',
+    pluralName: 'transfer-tokens',
+    displayName: 'Transfer Token',
+    description: '',
+  },
+  options: {},
+  pluginOptions: {
+    'content-manager': {
+      visible: false,
+    },
+    'content-type-builder': {
+      visible: false,
+    },
+  },
+  attributes: {
+    name: {
+      type: 'string',
+      minLength: 1,
+      configurable: false,
+      required: true,
+      unique: true,
+    },
+    description: {
+      type: 'string',
+      minLength: 1,
+      configurable: false,
+      required: false,
+      default: '',
+    },
+    accessKey: {
+      type: 'string',
+      minLength: 1,
+      configurable: false,
+      required: true,
+    },
+    lastUsedAt: {
+      type: 'datetime',
+      configurable: false,
+      required: false,
+    },
+    permissions: {
+      type: 'relation',
+      target: 'admin::transfer-token-permission',
+      relation: 'oneToMany',
+      mappedBy: 'token',
+      configurable: false,
+      required: false,
+    },
+    expiresAt: {
+      type: 'datetime',
+      configurable: false,
+      required: false,
+    },
+    lifespan: {
+      type: 'biginteger',
+      configurable: false,
+      required: false,
+    },
+  },
+};

package/server/controllers/api-token.js

@@ -2,8 +2,7 @@
 
 const { stringEquals } = require('@strapi/utils/lib');
 const { ApplicationError } = require('@strapi/utils').errors;
-const { trim } = require('lodash/fp');
-const has = require('lodash/has');
+const { trim, has } = require('lodash/fp');
 const { getService } = require('../utils');
 const {
   validateApiTokenCreationInput,
@@ -93,11 +92,11 @@ module.exports = {
      * - having a space at the end or start of the value.
      * - having only spaces as value;
      */
-    if (has(attributes, 'name')) {
+    if (has('name', attributes)) {
       attributes.name = trim(body.name);
     }
 
-    if (has(attributes, 'description') || attributes.description === null) {
+    if (has('description', attributes) || attributes.description === null) {
       attributes.description = trim(body.description);
     }
 
@@ -108,7 +107,7 @@ module.exports = {
       return ctx.notFound('API Token not found');
     }
 
-    if (has(attributes, 'name')) {
+    if (has('name', attributes)) {
       const nameAlreadyTaken = await apiTokenService.getByName(attributes.name);
 
       /**

package/server/controllers/index.js

@@ -7,6 +7,7 @@ module.exports = {
   authentication: require('./authentication'),
   permission: require('./permission'),
   role: require('./role'),
+  transfer: require('./transfer'),
   user: require('./user'),
   webhooks: require('./webhooks'),
   'content-api': require('./content-api'),

package/server/controllers/transfer/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { mapKeys } = require('lodash/fp');
+
+const runner = require('./runner');
+const token = require('./token');
+
+const prefixActionsName = (prefix, dict) => mapKeys((key) => `${prefix}-${key}`, dict);
+
+module.exports = {
+  ...prefixActionsName('runner', runner),
+  ...prefixActionsName('token', token),
+};

package/server/controllers/transfer/runner.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { remote } = require('@strapi/data-transfer/lib/strapi');
+const { UnauthorizedError } = require('@strapi/utils/lib/errors');
+
+const dataTransferAuthStrategy = require('../../strategies/data-transfer');
+
+/**
+ * @param {import('koa').Context} ctx
+ * @param {string} [scope]
+ */
+const verify = async (ctx, scope) => {
+  const { auth } = ctx.state;
+
+  if (!auth) {
+    throw new UnauthorizedError();
+  }
+
+  await dataTransferAuthStrategy.verify(auth, { scope });
+};
+
+module.exports = {
+  connect: remote.handlers.createTransferHandler({ verify }),
+};

package/server/controllers/transfer/token.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { trim, has } = require('lodash/fp');
+const {
+  errors: { ApplicationError },
+  stringEquals,
+} = require('@strapi/utils');
+
+const {
+  token: { validateTransferTokenCreationInput, validateTransferTokenUpdateInput },
+} = require('../../validation/transfer');
+const { getService } = require('../../utils');
+
+module.exports = {
+  async list(ctx) {
+    const transferService = getService('transfer');
+    const transferTokens = await transferService.token.list();
+
+    ctx.body = { data: transferTokens };
+  },
+
+  async getById(ctx) {
+    const { id } = ctx.params;
+    const tokenService = getService('transfer').token;
+
+    const transferToken = await tokenService.getById(id);
+
+    if (!transferToken) {
+      ctx.notFound('Transfer token not found');
+      return;
+    }
+
+    ctx.body = { data: transferToken };
+  },
+
+  async create(ctx) {
+    const { body } = ctx.request;
+    const { token: tokenService } = getService('transfer');
+
+    /**
+     * We trim fields to avoid having issues with either:
+     * - having a space at the end or start of the value
+     * - having only spaces as value (so that an empty field can be caught in validation)
+     */
+    const attributes = {
+      name: trim(body.name),
+      description: trim(body.description),
+      permissions: body.permissions,
+      lifespan: body.lifespan,
+    };
+
+    await validateTransferTokenCreationInput(attributes);
+
+    const alreadyExists = await tokenService.exists({ name: attributes.name });
+    if (alreadyExists) {
+      throw new ApplicationError('Name already taken');
+    }
+
+    const transferTokens = await tokenService.create(attributes);
+
+    ctx.created({ data: transferTokens });
+  },
+
+  async update(ctx) {
+    const { body } = ctx.request;
+    const { id } = ctx.params;
+    const { token: tokenService } = getService('transfer');
+
+    const attributes = body;
+    /**
+     * We trim fields to avoid having issues with either:
+     * - having a space at the end or start of the value
+     * - having only spaces as value (so that an empty field can be caught in validation)
+     */
+    if (has('name', attributes)) {
+      attributes.name = trim(body.name);
+    }
+
+    if (has('description', attributes) || attributes.description === null) {
+      attributes.description = trim(body.description);
+    }
+
+    await validateTransferTokenUpdateInput(attributes);
+
+    const apiTokenExists = await tokenService.getById(id);
+    if (!apiTokenExists) {
+      return ctx.notFound('Transfer token not found');
+    }
+
+    if (has('name', attributes)) {
+      const nameAlreadyTaken = await tokenService.getByName(attributes.name);
+
+      /**
+       * We cast the ids as string as the one coming from the ctx isn't cast
+       * as a Number in case it is supposed to be an integer. It remains
+       * as a string. This way we avoid issues with integers in the db.
+       */
+      if (!!nameAlreadyTaken && !stringEquals(nameAlreadyTaken.id, id)) {
+        throw new ApplicationError('Name already taken');
+      }
+    }
+
+    const apiToken = await tokenService.update(id, attributes);
+
+    ctx.body = { data: apiToken };
+  },
+
+  async revoke(ctx) {
+    const { id } = ctx.params;
+    const { token: tokenService } = getService('transfer');
+
+    const transferToken = await tokenService.revoke(id);
+
+    ctx.deleted({ data: transferToken });
+  },
+
+  async regenerate(ctx) {
+    const { id } = ctx.params;
+    const { token: tokenService } = getService('transfer');
+
+    const exists = await tokenService.getById(id);
+    if (!exists) {
+      ctx.notFound('Transfer token not found');
+      return;
+    }
+
+    const accessToken = await tokenService.regenerate(id);
+
+    ctx.created({ data: accessToken });
+  },
+};

package/server/register.js

@@ -1,9 +1,9 @@
 'use strict';
 
-// const { register: registerDataTransferRoute } = require('@strapi/data-transfer/lib/strapi');
-
 const registerAdminPanelRoute = require('./routes/serve-admin-panel');
+
 const adminAuthStrategy = require('./strategies/admin');
+
 const apiTokenAuthStrategy = require('./strategies/api-token');
 
 module.exports = ({ strapi }) => {
@@ -16,11 +16,4 @@ module.exports = ({ strapi }) => {
   if (strapi.config.serveAdminPanel) {
     registerAdminPanelRoute({ strapi });
   }
-
-  // if (
-  //   process.env.STRAPI_EXPERIMENTAL === 'true' &&
-  //   process.env.STRAPI_DISABLE_REMOTE_DATA_TRANSFER !== 'true'
-  // ) {
-  //   registerDataTransferRoute(strapi);
-  // }
 };

package/server/routes/index.js

@@ -8,6 +8,7 @@ const roles = require('./roles');
 const webhooks = require('./webhooks');
 const apiTokens = require('./api-tokens');
 const contentApi = require('./content-api');
+const transfer = require('./transfer');
 
 module.exports = [
   ...admin,
@@ -18,4 +19,5 @@ module.exports = [
   ...webhooks,
   ...apiTokens,
   ...contentApi,
+  ...transfer,
 ];

package/server/routes/transfer.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const dataTransferAuthStrategy = require('../strategies/data-transfer');
+
+module.exports = [
+  // Transfer route
+  {
+    method: 'GET',
+    path: '/transfer/runner/connect',
+    handler: 'transfer.runner-connect',
+    config: {
+      middlewares: [
+        (ctx, next) => {
+          if (process.env.STRAPI_DISABLE_REMOTE_DATA_TRANSFER === 'true') {
+            return ctx.notFound();
+          }
+
+          return next();
+        },
+      ],
+      // TODO: Allow not passing any scope <> Add a way to prevent assigning one by default
+      auth: { strategies: [dataTransferAuthStrategy], scope: ['push'] },
+    },
+  },
+  // Transfer Tokens
+  {
+    method: 'POST',
+    path: '/transfer/tokens',
+    handler: 'transfer.token-create',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        { name: 'admin::hasPermissions', config: { actions: ['admin::transfer.tokens.create'] } },
+      ],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/transfer/tokens',
+    handler: 'transfer.token-list',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        { name: 'admin::hasPermissions', config: { actions: ['admin::transfer.tokens.read'] } },
+      ],
+    },
+  },
+  {
+    method: 'DELETE',
+    path: '/transfer/tokens/:id',
+    handler: 'transfer.token-revoke',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        { name: 'admin::hasPermissions', config: { actions: ['admin::transfer.tokens.delete'] } },
+      ],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/transfer/tokens/:id',
+    handler: 'transfer.token-getById',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        { name: 'admin::hasPermissions', config: { actions: ['admin::transfer.tokens.read'] } },
+      ],
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/transfer/tokens/:id',
+    handler: 'transfer.token-update',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        { name: 'admin::hasPermissions', config: { actions: ['admin::transfer.tokens.update'] } },
+      ],
+    },
+  },
+  {
+    method: 'POST',
+    path: '/transfer/tokens/:id/regenerate',
+    handler: 'transfer.token-regenerate',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: { actions: ['admin::transfer.tokens.regenerate'] },
+        },
+      ],
+    },
+  },
+];

package/server/services/api-token.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const crypto = require('crypto');
-const { isNil } = require('lodash/fp');
-const { omit, difference, isEmpty, map, isArray, uniq } = require('lodash/fp');
+const { omit, difference, isNil, isEmpty, map, isArray, uniq } = require('lodash/fp');
 const { ValidationError, NotFoundError } = require('@strapi/utils').errors;
 const constants = require('./constants');
 
@@ -78,7 +77,7 @@ const assertCustomTokenPermissionsValidity = (attributes) => {
 };
 
 /**
- * Assert that a token's permissions attribute is valid for its type
+ * Assert that a token's lifespan is valid
  *
  * @param {ApiToken} token
  */

package/server/services/constants.js

@@ -24,4 +24,10 @@ module.exports = {
     DAYS_30: 30 * DAY_IN_MS,
     DAYS_90: 90 * DAY_IN_MS,
   },
+  TRANSFER_TOKEN_LIFESPANS: {
+    UNLIMITED: null,
+    DAYS_7: 7 * DAY_IN_MS,
+    DAYS_30: 30 * DAY_IN_MS,
+    DAYS_90: 90 * DAY_IN_MS,
+  },
 };

package/server/services/index.js

@@ -13,5 +13,6 @@ module.exports = {
   auth: require('./auth'),
   action: require('./action'),
   'api-token': require('./api-token'),
+  transfer: require('./transfer'),
   'project-settings': require('./project-settings'),
 };

package/server/services/transfer/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  permission: require('./permission'),
+  token: require('./token'),
+};

package/server/services/transfer/permission.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const permissions = require('@strapi/permissions');
+const { providerFactory } = require('@strapi/utils');
+
+const DEFAULT_TRANSFER_ACTIONS = ['push'];
+
+const providers = {
+  action: providerFactory(),
+  condition: providerFactory(),
+};
+
+DEFAULT_TRANSFER_ACTIONS.forEach((action) => {
+  providers.action.register(action, { action });
+});
+
+const engine = permissions.engine.new({ providers });
+
+module.exports = {
+  engine,
+  providers,
+};