@fourlights/strapi-plugin-deep-populate 1.3.1 → 1.4.1

package/README.md

@@ -12,6 +12,7 @@ It does not impose a limit on the level of nesting and can cache the populate ob
 - Handles circular references and edge cases
 - Includes caching for improved performance
 - Honors `populateCreatorFields` setting
+- Supports optional allow/deny lists for specific relations or components during population
 
 ## Installation
 
@@ -72,7 +73,36 @@ The plugin caches populate objects to improve performance. Cache can be disabled
 
 The plugin automatically populates `createdBy` and `updatedBy` fields when `populateCreatorFields` is enabled in the content-type configuration.
 
-## How It Works
+### Allow / Deny Lists
+
+Sometimes you may want to restrict the nested population of certain relations or components. For example if you have a `Page` contentType where a deeply nested `Link` component has a relation to another `Page`.
+In those situations you can use the allow or deny lists to control where the plugin should stop resolving nested relations.
+
+```ts
+// config/plugins.js
+module.exports = ({ env }) => ({
+  'deep-populate': {
+    enabled: true,
+    config: {
+      useCache: true,
+      replaceWildcard: true,
+      
+      contentTypes: {
+        'api::page.page': {
+          deny: {
+            relations: ['api::page.page']  // prevent resolving nested pages when populating a page
+            // alternatively we could have denied the link component in this case
+            // components: ['shared.link']
+          }
+        }
+      }
+    }
+  }
+});
+```
+---
+
+## How The Plugin Works
 
 The plugin recursively:
 1. Traverses the content-type schema

package/dist/server/index.js

@@ -1,4 +1,6 @@
 "use strict";
+const isEmpty$1 = require("lodash/isEmpty");
+const isObject$4 = require("lodash/isObject");
 const ___default = require("lodash");
 const fp = require("lodash/fp");
 const require$$1 = require("crypto");
@@ -23,6 +25,8 @@ const get = require("lodash/get");
 const mergeWith = require("lodash/mergeWith");
 const set$2 = require("lodash/set");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const isEmpty__default = /* @__PURE__ */ _interopDefault(isEmpty$1);
+const isObject__default = /* @__PURE__ */ _interopDefault(isObject$4);
 const ___default__default = /* @__PURE__ */ _interopDefault(___default);
 const require$$1__default = /* @__PURE__ */ _interopDefault(require$$1);
 const require$$0__default = /* @__PURE__ */ _interopDefault(require$$0$1);
@@ -45,8 +49,43 @@ const get__default = /* @__PURE__ */ _interopDefault(get);
 const mergeWith__default = /* @__PURE__ */ _interopDefault(mergeWith);
 const set__default = /* @__PURE__ */ _interopDefault(set$2);
 const config = {
-  default: ({ env: env2 }) => ({ useCache: true, replaceWildcard: true }),
+  default: ({ env: env2 }) => ({ useCache: true, replaceWildcard: true, contentTypes: {} }),
   validator: (config2) => {
+    if (!isObject__default.default(config2.contentTypes)) {
+      throw new Error("plugin::deep-populate config.contentTypes must be an object");
+    }
+    if (!isEmpty__default.default(config2.contentTypes)) {
+      for (const [uid, contentTypeConfig] of Object.entries(config2.contentTypes)) {
+        if (!isObject__default.default(contentTypeConfig)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid} must be an object`);
+        }
+        if (!contentTypeConfig.allow && !contentTypeConfig.deny) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid} must have an "allow" or "deny".`);
+        }
+        if (contentTypeConfig.allow && !isObject__default.default(contentTypeConfig.allow)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow must be an object`);
+        }
+        if (contentTypeConfig.deny && !isObject__default.default(contentTypeConfig.deny)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny must be an object`);
+        }
+        if (contentTypeConfig.allow) {
+          if (contentTypeConfig.allow.relations && !Array.isArray(contentTypeConfig.allow.relations)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow.relations must be an array`);
+          }
+          if (contentTypeConfig.allow.components && !Array.isArray(contentTypeConfig.allow.components)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow.components must be an array`);
+          }
+        }
+        if (contentTypeConfig.deny) {
+          if (contentTypeConfig.deny.relations && !Array.isArray(contentTypeConfig.deny.relations)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny.relations must be an array`);
+          }
+          if (contentTypeConfig.deny.components && !Array.isArray(contentTypeConfig.deny.components)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny.components must be an array`);
+          }
+        }
+      }
+    }
   }
 };
 const schema$1 = {
@@ -14573,7 +14612,7 @@ const register = async ({ strapi: strapi2 }) => {
   });
 };
 const getHash = (params) => {
-  return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}`;
+  return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}-${params.localizations ? "all" : "single"}`;
 };
 const cache = ({ strapi: strapi2 }) => ({
   async get(params) {
@@ -14636,18 +14675,26 @@ const hasValue = (value) => {
   return !(value === null || value === void 0 || Array.isArray(value) && value.length === 0 || typeof value === "object" && isEmpty(value));
 };
 async function _populateComponent({
+  schema: schema2,
   populate: populate2 = {},
   lookup,
   attrName,
   inDynamicZone = false,
+  __allow,
+  __deny,
   ...params
 }) {
   const componentLookup = lookup.length === 0 ? [attrName] : [...lookup, inDynamicZone ? "on" : "populate", attrName];
   const componentPopulate = populate2;
   set__default.default(componentPopulate, componentLookup, { populate: "*" });
+  if (__allow?.components && !__allow.components.includes(schema2)) return { populate: "*" };
+  if (__deny?.components?.includes(schema2)) return { populate: "*" };
   const nestedPopulate = await _populate({
+    schema: schema2,
     populate: componentPopulate,
     lookup: componentLookup,
+    __allow,
+    __deny,
     ...params
   });
   return isEmpty(nestedPopulate) ? true : { populate: nestedPopulate };
@@ -14680,9 +14727,7 @@ async function _populateRelation({
   contentType,
   relation,
   resolvedRelations,
-  omitEmpty,
-  locale: locale2,
-  status: status2
+  ...params
 }) {
   const isSingleRelation = !Array.isArray(relation);
   const relations = isSingleRelation ? [relation] : relation;
@@ -14694,9 +14739,7 @@ async function _populateRelation({
       documentId: relation2.documentId,
       schema: contentType,
       resolvedRelations,
-      omitEmpty,
-      locale: locale2,
-      status: status2
+      ...params
     });
     resolvedRelations.set(relation2.documentId, relationPopulate);
   }
@@ -14746,6 +14789,8 @@ async function _populate({
   lookup = [],
   resolvedRelations,
   omitEmpty,
+  __deny,
+  __allow,
   ...params
 }) {
   const newPopulate = {};
@@ -14771,9 +14816,33 @@ async function _populate({
   for (const [attrName, attr] of relations) {
     const value = _resolveValue({ document: document2, attrName, lookup });
     if (!hasValue(value)) {
-      if (!omitEmpty) newPopulate[attrName] = true;
+      if (omitEmpty !== true) newPopulate[attrName] = true;
       continue;
     }
+    if (params.localizations !== true && attrName === "localizations" && hasValue(value)) {
+      newPopulate[attrName] = true;
+      continue;
+    }
+    if (contentTypes.isRelationalAttribute(attr)) {
+      if (__allow?.relations && !__allow.relations.includes(attr.target)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+      if (__deny?.relations?.includes(attr.target)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+    }
+    if (contentTypes.isComponentAttribute(attr) && !contentTypes.isDynamicZoneAttribute(attr)) {
+      if (__allow?.components && !__allow.components.includes(attr.component)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+      if (__deny?.components?.includes(attr.component)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+    }
     resolveRelations.push([attrName, attr, value]);
   }
   relations = null;
@@ -14790,6 +14859,8 @@ async function _populate({
         attrName,
         resolvedRelations,
         omitEmpty,
+        __deny,
+        __allow,
         ...params
       });
     }
@@ -14800,7 +14871,10 @@ async function _populate({
         resolvedRelations,
         omitEmpty,
         locale: params.locale,
-        status: params.status
+        status: params.status,
+        localizations: params.localizations,
+        __deny,
+        __allow
       });
     }
     if (contentTypes.isComponentAttribute(attr) && !contentTypes.isDynamicZoneAttribute(attr)) {
@@ -14811,6 +14885,8 @@ async function _populate({
         attrName,
         resolvedRelations,
         omitEmpty,
+        __deny,
+        __allow,
         ...params
       });
     }
@@ -14821,8 +14897,20 @@ async function _populate({
   return newPopulate;
 }
 async function populate$1(params) {
+  const { contentTypes: contentTypes2 } = strapi.config.get("plugin::deep-populate");
+  const contentTypeConfig = has__default.default(contentTypes2, "*") ? get__default.default(contentTypes2, "*") : {};
+  if (has__default.default(contentTypes2, params.contentType)) {
+    mergeWith__default.default(contentTypeConfig, get__default.default(contentTypes2, params.contentType));
+  }
+  const { allow, deny } = contentTypeConfig;
   const resolvedRelations = /* @__PURE__ */ new Map();
-  const populated = await _populate({ ...params, schema: params.contentType, resolvedRelations });
+  const populated = await _populate({
+    ...params,
+    schema: params.contentType,
+    resolvedRelations,
+    __deny: deny,
+    __allow: allow
+  });
   return { populate: populated, dependencies: [...resolvedRelations.keys()] };
 }
 const populate = ({ strapi: strapi2 }) => ({

package/dist/server/index.mjs

@@ -1,5 +1,7 @@
+import isEmpty$1 from "lodash/isEmpty";
+import isObject$4 from "lodash/isObject";
 import ___default from "lodash";
-import { curry, isArray, isObject as isObject$4, isEmpty as isEmpty$1, cloneDeep, omit, isNil, trim as trim$1, isString, pipe as pipe$1, split as split$1, map as map$2, flatten, first, identity, constant, join, eq, clone as clone$3, get, pick, has as has$1, union, getOr, toPath, isBoolean as isBoolean$1 } from "lodash/fp";
+import { curry, isArray, isObject as isObject$5, isEmpty as isEmpty$2, cloneDeep, omit, isNil, trim as trim$1, isString, pipe as pipe$1, split as split$1, map as map$2, flatten, first, identity, constant, join, eq, clone as clone$3, get, pick, has as has$1, union, getOr, toPath, isBoolean as isBoolean$1 } from "lodash/fp";
 import require$$1 from "crypto";
 import require$$0$1 from "child_process";
 import has from "lodash/has";
@@ -22,8 +24,43 @@ import get$1 from "lodash/get";
 import mergeWith from "lodash/mergeWith";
 import set$2 from "lodash/set";
 const config = {
-  default: ({ env: env2 }) => ({ useCache: true, replaceWildcard: true }),
+  default: ({ env: env2 }) => ({ useCache: true, replaceWildcard: true, contentTypes: {} }),
   validator: (config2) => {
+    if (!isObject$4(config2.contentTypes)) {
+      throw new Error("plugin::deep-populate config.contentTypes must be an object");
+    }
+    if (!isEmpty$1(config2.contentTypes)) {
+      for (const [uid, contentTypeConfig] of Object.entries(config2.contentTypes)) {
+        if (!isObject$4(contentTypeConfig)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid} must be an object`);
+        }
+        if (!contentTypeConfig.allow && !contentTypeConfig.deny) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid} must have an "allow" or "deny".`);
+        }
+        if (contentTypeConfig.allow && !isObject$4(contentTypeConfig.allow)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow must be an object`);
+        }
+        if (contentTypeConfig.deny && !isObject$4(contentTypeConfig.deny)) {
+          throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny must be an object`);
+        }
+        if (contentTypeConfig.allow) {
+          if (contentTypeConfig.allow.relations && !Array.isArray(contentTypeConfig.allow.relations)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow.relations must be an array`);
+          }
+          if (contentTypeConfig.allow.components && !Array.isArray(contentTypeConfig.allow.components)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.allow.components must be an array`);
+          }
+        }
+        if (contentTypeConfig.deny) {
+          if (contentTypeConfig.deny.relations && !Array.isArray(contentTypeConfig.deny.relations)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny.relations must be an array`);
+          }
+          if (contentTypeConfig.deny.components && !Array.isArray(contentTypeConfig.deny.components)) {
+            throw new Error(`plugin::deep-populate config.contentTypes.${uid}.deny.components must be an array`);
+          }
+        }
+      }
+    }
   }
 };
 const schema$1 = {
@@ -13117,7 +13154,7 @@ const traverseEntity = async (visitor2, options, entity) => {
     const traverseOptions = { schema: targetSchema, path: path22, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
-  if (!isObject$4(entity) || isNil(schema2)) {
+  if (!isObject$5(entity) || isNil(schema2)) {
     return entity;
   }
   const copy = clone$3(entity);
@@ -13353,7 +13390,7 @@ const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schem
       return allowedElements;
     }
     for (const element of elements) {
-      if (!isObject$4(element) || !("__type" in element)) {
+      if (!isObject$5(element) || !("__type" in element)) {
         continue;
       }
       const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${element.__type}.${action}`);
@@ -13586,7 +13623,7 @@ const traverseFactory = () => {
     }
   };
 };
-const isObj$2 = (value) => isObject$4(value);
+const isObj$2 = (value) => isObject$5(value);
 const filters = traverseFactory().intercept(
   // Intercept filters arrays and apply the traversal to each one individually
   isArray,
@@ -13597,11 +13634,11 @@ const filters = traverseFactory().intercept(
         return recurse(visitor2, { ...options, path: newPath }, filter);
       })
       // todo: move that to the visitors
-    ).then((res) => res.filter((val) => !(isObject$4(val) && isEmpty$1(val))));
+    ).then((res) => res.filter((val) => !(isObject$5(val) && isEmpty$2(val))));
   }
 ).intercept(
   // Ignore non object filters and return the value as-is
-  (filters2) => !isObject$4(filters2),
+  (filters2) => !isObject$5(filters2),
   (_2, __, filters2) => {
     return filters2;
   }
@@ -13668,23 +13705,23 @@ const ORDERS = { asc: "asc", desc: "desc" };
 const ORDER_VALUES = Object.values(ORDERS);
 const isSortOrder = (value) => ORDER_VALUES.includes(value.toLowerCase());
 const isStringArray$2 = (value) => Array.isArray(value) && value.every(isString);
-const isObjectArray = (value) => Array.isArray(value) && value.every(isObject$4);
+const isObjectArray = (value) => Array.isArray(value) && value.every(isObject$5);
 const isNestedSorts = (value) => isString(value) && value.split(",").length > 1;
-const isObj$1 = (value) => isObject$4(value);
+const isObj$1 = (value) => isObject$5(value);
 const sort = traverseFactory().intercept(
   // String with chained sorts (foo,bar,foobar) => split, map(recurse), then recompose
   isNestedSorts,
   async (visitor2, options, sort2, { recurse }) => {
     return Promise.all(
       sort2.split(",").map(trim$1).map((nestedSort) => recurse(visitor2, options, nestedSort))
-    ).then((res) => res.filter((part) => !isEmpty$1(part)).join(","));
+    ).then((res) => res.filter((part) => !isEmpty$2(part)).join(","));
   }
 ).intercept(
   // Array of strings ['foo', 'foo,bar'] => map(recurse), then filter out empty items
   isStringArray$2,
   async (visitor2, options, sort2, { recurse }) => {
     return Promise.all(sort2.map((nestedSort) => recurse(visitor2, options, nestedSort))).then(
-      (res) => res.filter((nestedSort) => !isEmpty$1(nestedSort))
+      (res) => res.filter((nestedSort) => !isEmpty$2(nestedSort))
     );
   }
 ).intercept(
@@ -13692,7 +13729,7 @@ const sort = traverseFactory().intercept(
   isObjectArray,
   async (visitor2, options, sort2, { recurse }) => {
     return Promise.all(sort2.map((nestedSort) => recurse(visitor2, options, nestedSort))).then(
-      (res) => res.filter((nestedSort) => !isEmpty$1(nestedSort))
+      (res) => res.filter((nestedSort) => !isEmpty$2(nestedSort))
     );
   }
 ).parse(isString, () => {
@@ -13702,7 +13739,7 @@ const sort = traverseFactory().intercept(
       return void 0;
     }
     return parts.reduce((acc, part) => {
-      if (isEmpty$1(part)) {
+      if (isEmpty$2(part)) {
         return acc;
       }
       if (acc === "") {
@@ -13797,7 +13834,7 @@ const isPopulateString = (value) => {
   return isString(value) && !isWildcard(value);
 };
 const isStringArray$1 = (value) => isArray(value) && value.every(isString);
-const isObj = (value) => isObject$4(value);
+const isObj = (value) => isObject$5(value);
 const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2, options, populate2, { recurse }) => {
   const populateObject = pathsToObjectPopulate([populate2]);
   const traversedPopulate = await recurse(visitor2, options, populateObject);
@@ -13846,7 +13883,7 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
       if (root2 !== key) {
         return data;
       }
-      return isNil(value) || isEmpty$1(value) ? root2 : `${root2}.${value}`;
+      return isNil(value) || isEmpty$2(value) ? root2 : `${root2}.${value}`;
     },
     keys(data) {
       const v = first(tokenize(data));
@@ -13907,7 +13944,7 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
     }
     const parent = { key, path: path2, schema: schema2, attribute };
     if (isMorphToRelationalAttribute(attribute)) {
-      if (!isObject$4(value) || !("on" in value && isObject$4(value?.on))) {
+      if (!isObject$5(value) || !("on" in value && isObject$5(value?.on))) {
         return;
       }
       const newValue2 = await recurse(
@@ -13956,7 +13993,7 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
   }
 ).onDynamicZone(
   async ({ key, value, schema: schema2, visitor: visitor2, path: path2, attribute, getModel }, { set: set2, recurse }) => {
-    if (isNil(value) || !isObject$4(value)) {
+    if (isNil(value) || !isObject$5(value)) {
       return;
     }
     const parent = { key, path: path2, schema: schema2, attribute };
@@ -14069,7 +14106,7 @@ const defaultSanitizeFilters = curry((ctx, filters2) => {
     traverseQueryFilters(visitor$7, ctx),
     // Remove empty objects
     traverseQueryFilters(({ key, value }, { remove: remove2 }) => {
-      if (isObject$4(value) && isEmpty$1(value)) {
+      if (isObject$5(value) && isEmpty$2(value)) {
         remove2(key);
       }
     }, ctx)
@@ -14102,7 +14139,7 @@ const defaultSanitizeSort = curry((ctx, sort2) => {
       if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
         return;
       }
-      if (!isScalarAttribute(attribute) && isEmpty$1(value)) {
+      if (!isScalarAttribute(attribute) && isEmpty$2(value)) {
         remove2(key);
       }
     }, ctx)
@@ -14550,7 +14587,7 @@ const register = async ({ strapi: strapi2 }) => {
   });
 };
 const getHash = (params) => {
-  return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}`;
+  return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}-${params.localizations ? "all" : "single"}`;
 };
 const cache = ({ strapi: strapi2 }) => ({
   async get(params) {
@@ -14613,18 +14650,26 @@ const hasValue = (value) => {
   return !(value === null || value === void 0 || Array.isArray(value) && value.length === 0 || typeof value === "object" && isEmpty(value));
 };
 async function _populateComponent({
+  schema: schema2,
   populate: populate2 = {},
   lookup,
   attrName,
   inDynamicZone = false,
+  __allow,
+  __deny,
   ...params
 }) {
   const componentLookup = lookup.length === 0 ? [attrName] : [...lookup, inDynamicZone ? "on" : "populate", attrName];
   const componentPopulate = populate2;
   set$2(componentPopulate, componentLookup, { populate: "*" });
+  if (__allow?.components && !__allow.components.includes(schema2)) return { populate: "*" };
+  if (__deny?.components?.includes(schema2)) return { populate: "*" };
   const nestedPopulate = await _populate({
+    schema: schema2,
     populate: componentPopulate,
     lookup: componentLookup,
+    __allow,
+    __deny,
     ...params
   });
   return isEmpty(nestedPopulate) ? true : { populate: nestedPopulate };
@@ -14657,9 +14702,7 @@ async function _populateRelation({
   contentType,
   relation,
   resolvedRelations,
-  omitEmpty,
-  locale: locale2,
-  status: status2
+  ...params
 }) {
   const isSingleRelation = !Array.isArray(relation);
   const relations = isSingleRelation ? [relation] : relation;
@@ -14671,9 +14714,7 @@ async function _populateRelation({
       documentId: relation2.documentId,
       schema: contentType,
       resolvedRelations,
-      omitEmpty,
-      locale: locale2,
-      status: status2
+      ...params
     });
     resolvedRelations.set(relation2.documentId, relationPopulate);
   }
@@ -14723,6 +14764,8 @@ async function _populate({
   lookup = [],
   resolvedRelations,
   omitEmpty,
+  __deny,
+  __allow,
   ...params
 }) {
   const newPopulate = {};
@@ -14748,9 +14791,33 @@ async function _populate({
   for (const [attrName, attr] of relations) {
     const value = _resolveValue({ document: document2, attrName, lookup });
     if (!hasValue(value)) {
-      if (!omitEmpty) newPopulate[attrName] = true;
+      if (omitEmpty !== true) newPopulate[attrName] = true;
       continue;
     }
+    if (params.localizations !== true && attrName === "localizations" && hasValue(value)) {
+      newPopulate[attrName] = true;
+      continue;
+    }
+    if (contentTypes.isRelationalAttribute(attr)) {
+      if (__allow?.relations && !__allow.relations.includes(attr.target)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+      if (__deny?.relations?.includes(attr.target)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+    }
+    if (contentTypes.isComponentAttribute(attr) && !contentTypes.isDynamicZoneAttribute(attr)) {
+      if (__allow?.components && !__allow.components.includes(attr.component)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+      if (__deny?.components?.includes(attr.component)) {
+        newPopulate[attrName] = true;
+        continue;
+      }
+    }
     resolveRelations.push([attrName, attr, value]);
   }
   relations = null;
@@ -14767,6 +14834,8 @@ async function _populate({
         attrName,
         resolvedRelations,
         omitEmpty,
+        __deny,
+        __allow,
         ...params
       });
     }
@@ -14777,7 +14846,10 @@ async function _populate({
         resolvedRelations,
         omitEmpty,
         locale: params.locale,
-        status: params.status
+        status: params.status,
+        localizations: params.localizations,
+        __deny,
+        __allow
       });
     }
     if (contentTypes.isComponentAttribute(attr) && !contentTypes.isDynamicZoneAttribute(attr)) {
@@ -14788,6 +14860,8 @@ async function _populate({
         attrName,
         resolvedRelations,
         omitEmpty,
+        __deny,
+        __allow,
         ...params
       });
     }
@@ -14798,8 +14872,20 @@ async function _populate({
   return newPopulate;
 }
 async function populate$1(params) {
+  const { contentTypes: contentTypes2 } = strapi.config.get("plugin::deep-populate");
+  const contentTypeConfig = has(contentTypes2, "*") ? get$1(contentTypes2, "*") : {};
+  if (has(contentTypes2, params.contentType)) {
+    mergeWith(contentTypeConfig, get$1(contentTypes2, params.contentType));
+  }
+  const { allow, deny } = contentTypeConfig;
   const resolvedRelations = /* @__PURE__ */ new Map();
-  const populated = await _populate({ ...params, schema: params.contentType, resolvedRelations });
+  const populated = await _populate({
+    ...params,
+    schema: params.contentType,
+    resolvedRelations,
+    __deny: deny,
+    __allow: allow
+  });
   return { populate: populated, dependencies: [...resolvedRelations.keys()] };
 }
 const populate = ({ strapi: strapi2 }) => ({

package/dist/server/src/config/index.d.ts

@@ -1,10 +1,29 @@
+import type { UID } from "@strapi/strapi";
+export type ContentTypeConfigAllow = {
+    relations?: UID.ContentType[];
+    components?: UID.Component[];
+};
+export type ContentTypeConfigDeny = {
+    relations?: UID.ContentType[];
+    components?: UID.Component[];
+};
+type ContentTypeConfig = {
+    allow?: ContentTypeConfigAllow;
+    deny?: ContentTypeConfigDeny;
+};
+export type Config = {
+    useCache: boolean;
+    replaceWildcard: boolean;
+    contentTypes: Record<UID.ContentType | "*", ContentTypeConfig>;
+};
 declare const _default: {
     default: ({ env }: {
         env: any;
     }) => {
         useCache: boolean;
         replaceWildcard: boolean;
+        contentTypes: {};
     };
-    validator: (config: any) => void;
+    validator: (config: Config) => void;
 };
 export default _default;

package/dist/server/src/index.d.ts

@@ -5,8 +5,9 @@ declare const _default: {
         }) => {
             useCache: boolean;
             replaceWildcard: boolean;
+            contentTypes: {};
         };
-        validator: (config: any) => void;
+        validator: (config: import("./config").Config) => void;
     };
     contentTypes: {
         cache: {
@@ -72,6 +73,7 @@ declare const _default: {
                 contentType: import("@strapi/types/dist/uid").ContentType;
                 documentId: string;
                 omitEmpty?: boolean;
+                localizations?: boolean;
             } & {
                 populate?: import("@strapi/types/dist/modules/documents/params/populate").Any<import("@strapi/types/dist/uid").ContentType>;
             } & {

package/dist/server/src/services/index.d.ts

@@ -14,6 +14,7 @@ declare const _default: {
             contentType: import("@strapi/types/dist/uid").ContentType;
             documentId: string;
             omitEmpty?: boolean;
+            localizations?: boolean;
         } & {
             populate?: import("@strapi/types/dist/modules/documents/params/populate").Any<import("@strapi/types/dist/uid").ContentType>;
         } & {

package/dist/server/src/services/populate.d.ts

@@ -3,6 +3,7 @@ export type PopulateParams<TContentType extends UID.ContentType = UID.ContentTyp
     contentType: TContentType;
     documentId: string;
     omitEmpty?: boolean;
+    localizations?: boolean;
 };
 declare const _default: ({ strapi }: {
     strapi: Core.Strapi;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.3.1",
+  "version": "1.4.1",
   "keywords": [
     "strapi",
     "strapi-plugin",