@strapi/strapi 4.12.7 → 4.13.0-alpha.0

package/lib/commands/actions/watch-admin/action.js

@@ -16,7 +16,7 @@ module.exports = async ({ browser }) => {
     serveAdminPanel: false,
   });
 
-  const plugins = await getEnabledPlugins(strapiInstance);
+  const plugins = await getEnabledPlugins(strapiInstance, { client: true });
 
   const { adminPath } = getConfigUrls(strapiInstance.config, true);
 

package/lib/commands/builders/admin.js

@@ -20,7 +20,7 @@ module.exports = async ({ buildDestDir, forceBuild = true, optimization, srcDir
     serveAdminPanel: false,
   });
 
-  const plugins = await getEnabledPlugins(strapiInstance);
+  const plugins = await getEnabledPlugins(strapiInstance, { client: true });
 
   const env = strapiInstance.config.get('environment');
   const { serverUrl, adminPath } = getConfigUrls(strapiInstance.config, true);

package/lib/commands/utils/data-transfer.js

@@ -291,7 +291,8 @@ const getDiffHandler = (engine, { force, action }) => {
         if (
           uid === 'admin::workflow' ||
           uid === 'admin::workflow-stage' ||
-          endPath?.startsWith('strapi_stage')
+          endPath?.startsWith('strapi_stage') ||
+          endPath?.startsWith('strapi_assignee')
         ) {
           workflowsStatus = diff.kind;
         }
@@ -369,6 +370,41 @@ const getAssetsBackupHandler = (engine, { force, action }) => {
   };
 };
 
+const shouldSkipStage = (opts, dataKind) => {
+  if (opts.exclude?.includes(dataKind)) {
+    return true;
+  }
+  if (opts.only) {
+    return !opts.only.includes(dataKind);
+  }
+
+  return false;
+};
+
+// Based on exclude/only from options, create the restore object to match
+const parseRestoreFromOptions = (opts) => {
+  const entitiesOptions = {
+    exclude: DEFAULT_IGNORED_CONTENT_TYPES,
+    include: undefined,
+  };
+
+  // if content is not included, send an empty array for include
+  if ((opts.only && !opts.only.includes('content')) || opts.exclude?.includes('content')) {
+    entitiesOptions.include = [];
+  }
+
+  const restoreConfig = {
+    entities: entitiesOptions,
+    assets: !shouldSkipStage(opts, 'files'),
+    configuration: {
+      webhooks: !shouldSkipStage(opts, 'config'),
+      coreStore: !shouldSkipStage(opts, 'config'),
+    },
+  };
+
+  return restoreConfig;
+};
+
 module.exports = {
   loadersFactory,
   buildTransferTable,
@@ -386,4 +422,6 @@ module.exports = {
   setSignalHandler,
   getDiffHandler,
   getAssetsBackupHandler,
+  shouldSkipStage,
+  parseRestoreFromOptions,
 };

package/lib/core/loaders/index.js

@@ -9,4 +9,5 @@ module.exports = {
   loadPlugins: require('./plugins'),
   loadAdmin: require('./admin'),
   loadSanitizers: require('./sanitizers'),
+  loadValidators: require('./validators'),
 };

package/lib/core/loaders/plugins/get-enabled-plugins.js

@@ -3,7 +3,7 @@
 const { dirname, join, resolve } = require('path');
 const { statSync, existsSync } = require('fs');
 const _ = require('lodash');
-const { get, has, pick, pickBy, defaultsDeep, map, prop, pipe } = require('lodash/fp');
+const { get, pickBy, defaultsDeep, map, prop, pipe } = require('lodash/fp');
 const { isKebabCase } = require('@strapi/utils');
 const getUserPluginsConfig = require('./get-user-plugins-config');
 
@@ -21,31 +21,58 @@ const validatePluginName = (pluginName) => {
   }
 };
 
+/**
+ * @typedef {Object} PluginInstallDeclaration
+ * @property {boolean} enabled
+ * @property {string=} resolve
+ * @property {boolean=} isModule - whether the plugin is a node module or a local plugin
+ */
+
+/**
+ * @typedef {Object} DetailedDeclaration
+ * @property {boolean} enabled
+ * @property {string=} pathToPlugin
+ */
+
+/**
+ * @type {(declaration: PluginInstallDeclaration | boolean) => DetailedDeclaration}
+ */
 const toDetailedDeclaration = (declaration) => {
   if (typeof declaration === 'boolean') {
     return { enabled: declaration };
   }
 
-  const detailedDeclaration = pick(['enabled'], declaration);
-  if (has('resolve', declaration)) {
-    let pathToPlugin = '';
+  const detailedDeclaration = {
+    enabled: declaration.enabled,
+  };
 
-    try {
-      pathToPlugin = dirname(require.resolve(declaration.resolve));
-    } catch (e) {
-      pathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
+  if (declaration?.resolve) {
+    let pathToPlugin = '';
 
-      if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
-        throw new Error(`${declaration.resolve} couldn't be resolved`);
+    if (declaration.isModule) {
+      /**
+       * we only want the node_module here, not the package.json
+       */
+      pathToPlugin = join(declaration.resolve, '..');
+    } else {
+      try {
+        pathToPlugin = dirname(require.resolve(declaration.resolve));
+      } catch (e) {
+        pathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
+
+        if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
+          throw new Error(`${declaration.resolve} couldn't be resolved`);
+        }
       }
     }
 
     detailedDeclaration.pathToPlugin = pathToPlugin;
   }
+
   return detailedDeclaration;
 };
 
-const getEnabledPlugins = async (strapi) => {
+const getEnabledPlugins = async (strapi, { client } = { client: false }) => {
   const internalPlugins = {};
   for (const dep of INTERNAL_PLUGINS) {
     const packagePath = join(dep, 'package.json');
@@ -53,7 +80,7 @@ const getEnabledPlugins = async (strapi) => {
 
     validatePluginName(packageInfo.strapi.name);
     internalPlugins[packageInfo.strapi.name] = {
-      ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
+      ...toDetailedDeclaration({ enabled: true, resolve: packagePath, isModule: client }),
       info: packageInfo.strapi,
     };
   }
@@ -73,7 +100,7 @@ const getEnabledPlugins = async (strapi) => {
     if (isStrapiPlugin(packageInfo)) {
       validatePluginName(packageInfo.strapi.name);
       installedPlugins[packageInfo.strapi.name] = {
-        ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
+        ...toDetailedDeclaration({ enabled: true, resolve: packagePath, isModule: client }),
         info: {
           ...packageInfo.strapi,
           packageName: packageInfo.name,

package/lib/core/loaders/sanitizers.js

@@ -1,5 +1,5 @@
 'use strict';
 
 module.exports = (strapi) => {
-  strapi.container.get('sanitizers').set('content-api', { input: [], output: [] });
+  strapi.container.get('sanitizers').set('content-api', { input: [], output: [], query: [] });
 };

package/lib/core/loaders/validators.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (strapi) => {
+  strapi.container.get('validators').set('content-api', { input: [], query: [] });
+};

package/lib/core/registries/validators.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const _ = require('lodash');
+
+const validatorsRegistry = () => {
+  const validators = {};
+
+  return {
+    get(path) {
+      return _.get(validators, path, []);
+    },
+    add(path, sanitizer) {
+      this.get(path).push(sanitizer);
+      return this;
+    },
+    set(path, value = []) {
+      _.set(validators, path, value);
+      return this;
+    },
+    has(path) {
+      return _.has(validators, path);
+    },
+  };
+};
+
+module.exports = validatorsRegistry;

package/lib/core-api/controller/collection-type.js

@@ -19,7 +19,9 @@ const createCollectionTypeController = ({ contentType }) => {
      * @return {Object|Array}
      */
     async find(ctx) {
+      await this.validateQuery(ctx);
       const sanitizedQuery = await this.sanitizeQuery(ctx);
+
       const { results, pagination } = await strapi.service(uid).find(sanitizedQuery);
       const sanitizedResults = await this.sanitizeOutput(results, ctx);
       return this.transformResponse(sanitizedResults, { pagination });
@@ -32,9 +34,10 @@ const createCollectionTypeController = ({ contentType }) => {
      */
     async findOne(ctx) {
       const { id } = ctx.params;
-      const { query } = ctx;
+      await this.validateQuery(ctx);
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
 
-      const entity = await strapi.service(uid).findOne(id, query);
+      const entity = await strapi.service(uid).findOne(id, sanitizedQuery);
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
       return this.transformResponse(sanitizedEntity);
@@ -46,7 +49,8 @@ const createCollectionTypeController = ({ contentType }) => {
      * @return {Object}
      */
     async create(ctx) {
-      const { query } = ctx.request;
+      await this.validateQuery(ctx);
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
 
       const { data, files } = parseBody(ctx);
 
@@ -58,7 +62,7 @@ const createCollectionTypeController = ({ contentType }) => {
 
       const entity = await strapi
         .service(uid)
-        .create({ ...query, data: sanitizedInputData, files });
+        .create({ ...sanitizedQuery, data: sanitizedInputData, files });
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
       return this.transformResponse(sanitizedEntity);
@@ -71,7 +75,8 @@ const createCollectionTypeController = ({ contentType }) => {
      */
     async update(ctx) {
       const { id } = ctx.params;
-      const { query } = ctx.request;
+      await this.validateQuery(ctx);
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
 
       const { data, files } = parseBody(ctx);
 
@@ -83,7 +88,7 @@ const createCollectionTypeController = ({ contentType }) => {
 
       const entity = await strapi
         .service(uid)
-        .update(id, { ...query, data: sanitizedInputData, files });
+        .update(id, { ...sanitizedQuery, data: sanitizedInputData, files });
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
       return this.transformResponse(sanitizedEntity);
@@ -96,9 +101,10 @@ const createCollectionTypeController = ({ contentType }) => {
      */
     async delete(ctx) {
       const { id } = ctx.params;
-      const { query } = ctx;
+      await this.validateQuery(ctx);
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
 
-      const entity = await strapi.service(uid).delete(id, query);
+      const entity = await strapi.service(uid).delete(id, sanitizedQuery);
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
       return this.transformResponse(sanitizedEntity);

package/lib/core-api/controller/index.js

@@ -2,7 +2,7 @@
 
 const { getOr } = require('lodash/fp');
 
-const { contentTypes, sanitize } = require('@strapi/utils');
+const { contentTypes, sanitize, validate } = require('@strapi/utils');
 
 const { transformResponse } = require('./transform');
 const createSingleTypeController = require('./single-type');
@@ -24,17 +24,29 @@ const createController = ({ contentType }) => {
       return sanitize.contentAPI.output(data, contentType, { auth });
     },
 
-    sanitizeInput(data, ctx) {
+    async sanitizeInput(data, ctx) {
       const auth = getAuthFromKoaContext(ctx);
 
       return sanitize.contentAPI.input(data, contentType, { auth });
     },
 
-    sanitizeQuery(ctx) {
+    async sanitizeQuery(ctx) {
       const auth = getAuthFromKoaContext(ctx);
 
       return sanitize.contentAPI.query(ctx.query, contentType, { auth });
     },
+
+    async validateQuery(ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return validate.contentAPI.query(ctx.query, contentType, { auth });
+    },
+
+    async validateInput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return validate.contentAPI.input(data, contentType, { auth });
+    },
   };
 
   let ctrl;

package/lib/core-api/controller/single-type.js

@@ -18,7 +18,9 @@ const createSingleTypeController = ({ contentType }) => {
      * @return {Object|Array}
      */
     async find(ctx) {
+      await this.validateQuery(ctx);
       const sanitizedQuery = await this.sanitizeQuery(ctx);
+
       const entity = await strapi.service(uid).find(sanitizedQuery);
 
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);

package/lib/factories.d.ts

@@ -1,21 +1,18 @@
-import type { Common, CoreApi, Strapi } from '@strapi/strapi';
-
-type WithStrapiCallback<T> = <S extends { strapi: Strapi }>(params: S) => T;
+import type { Common, CoreApi } from '@strapi/strapi';
 
 export declare function createCoreRouter<T extends Common.UID.ContentType>(
   uid: T,
   cfg?: CoreApi.Router.RouterConfig<T>
 ): () => CoreApi.Router.Router;
 
-export declare function createCoreController<
-  T extends Common.UID.ContentType,
-  S extends Partial<CoreApi.Controller.Extendable<T>>
->(
+// TODO: Find a cleaner way to expose methods for customization
+export declare function createCoreController<T extends Common.UID.ContentType>(
   uid: T,
-  config?: WithStrapiCallback<S> | S
-): () => Required<S & CoreApi.Controller.ContentType<T>>;
+  config?: any
+): () => any;
 
-export declare function createCoreService<
-  T extends Common.UID.ContentType,
-  S extends Partial<CoreApi.Service.Extendable<T>>
->(uid: T, config?: WithStrapiCallback<S> | S): () => Required<S & CoreApi.Service.ContentType<T>>;
+// TODO: Find a cleaner way to expose methods for customization
+export declare function createCoreService<T extends Common.UID.ContentType>(
+  uid: T,
+  config?: any
+): () => any;

package/lib/factories.js

@@ -6,10 +6,20 @@ const { createController } = require('./core-api/controller');
 const { createService } = require('./core-api/service');
 const { createRoutes } = require('./core-api/routes');
 
+// Content type is proxied to allow for dynamic content type updates
+const getContentTypeProxy = (strapi, uid) => {
+  return new Proxy(strapi.contentType(uid), {
+    get(target, prop) {
+      const contentType = strapi.contentType(uid);
+      return contentType[prop];
+    },
+  });
+};
+
 const createCoreController = (uid, cfg = {}) => {
   return ({ strapi }) => {
     const baseController = createController({
-      contentType: strapi.contentType(uid),
+      contentType: getContentTypeProxy(strapi, uid),
     });
 
     const userCtrl = typeof cfg === 'function' ? cfg({ strapi }) : cfg;
@@ -28,7 +38,7 @@ const createCoreController = (uid, cfg = {}) => {
 const createCoreService = (uid, cfg = {}) => {
   return ({ strapi }) => {
     const baseService = createService({
-      contentType: strapi.contentType(uid),
+      contentType: getContentTypeProxy(strapi, uid),
     });
 
     const userService = typeof cfg === 'function' ? cfg({ strapi }) : cfg;

package/lib/services/entity-service/index.d.ts

@@ -1,100 +1 @@
-import type { Database, ID } from '@strapi/database';
-import { Strapi } from '../../';
-
-type EntityServiceAction =
-  | 'findMany'
-  | 'findPage'
-  | 'findWithRelationCountsPage'
-  | 'findWithRelationCounts'
-  | 'findOne'
-  | 'count'
-  | 'create'
-  | 'update'
-  | 'delete';
-
-type PaginationInfo = {
-  page: number;
-  pageSize: number;
-  pageCount: number;
-  total: number;
-};
-
-type Params<T> = {
-  fields?: (keyof T)[];
-  filters?: any;
-  _q?: string;
-  populate?: any;
-  sort?: any;
-  start?: number;
-  limit?: number;
-  page?: number;
-  pageSize?: number;
-  publicationState?: string;
-  data?: any;
-  files?: any;
-};
-
-export interface EntityService {
-  uploadFiles<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, entity, files);
-  wrapParams<K extends keyof AllTypes, T extends AllTypes[K]>(
-    params: Params<T>,
-    { uid: K, action: EntityServiceAction }
-  );
-
-  findMany<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    params: Params<T>
-  ): Promise<T[]>;
-  findPage<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    params: Params<T>
-  ): Promise<{
-    results: T[];
-    pagination: PaginationInfo;
-  }>;
-
-  findWithRelationCountsPage<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    params: Params<T>
-  ): Promise<{
-    results: T[];
-    pagination: PaginationInfo;
-  }>;
-
-  findWithRelationCounts<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    params: Params<T>
-  ): Promise<T[]>;
-
-  findOne<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    entityId: ID,
-    params: Params<T>
-  ): Promise<T>;
-
-  count<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, params: Params<T>): Promise<any>;
-  create<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, params: Params<T>): Promise<any>;
-  update<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    entityId: ID,
-    params: Params<T>
-  ): Promise<any>;
-  delete<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    entityId: ID,
-    params: Params<T>
-  ): Promise<any>;
-  clone<K extends keyof AllTypes, T extends AllTypes[K]>(
-    uid: K,
-    cloneId: ID,
-    params: Params<T>
-  ): Promise<any>;
-}
-
-export default function (opts: {
-  strapi: Strapi;
-  db: Database;
-  // TODO: define types
-  eventHub: any;
-  entityValidator: any;
-}): EntityService;
+export * from './types';

package/lib/services/entity-service/index.js

@@ -172,6 +172,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       data: entityData,
     });
 
+    // TODO: do all of this in a transaction to avoid a race condition where entity is created then deleted before we do findOne again
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
     if (files && Object.keys(files).length > 0) {
       await this.uploadFiles(uid, Object.assign(entityData, entity), files);