@fourlights/strapi-plugin-deep-populate 1.1.2 → 1.2.2

package/dist/server/index.mjs

@@ -1,5 +1,3 @@
-import { dset } from "dset/merge";
-import delve from "dlv";
 import { klona } from "klona/json";
 import require$$1 from "crypto";
 import require$$0$1 from "child_process";
@@ -13,6 +11,208 @@ import require$$0$6 from "stream";
 import require$$2$1 from "util";
 import require$$0$8 from "constants";
 import "node:stream";
+import delve from "dlv";
+import { dset } from "dset/merge";
+const config = {
+  default: ({ env: env2 }) => ({ cachePopulate: true, augmentPopulateStar: true }),
+  validator: (config2) => {
+  }
+};
+const schema$1 = {
+  kind: "collectionType",
+  collectionName: "caches",
+  info: {
+    singularName: "cache",
+    pluralName: "caches",
+    displayName: "Cache",
+    description: "Holds cached deep populate object"
+  },
+  options: {},
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    hash: {
+      type: "string",
+      configurable: false,
+      required: true
+    },
+    params: {
+      type: "json",
+      configurable: false,
+      required: true
+    },
+    populate: {
+      type: "json",
+      configurable: false
+    },
+    dependencies: { type: "string", configurable: false }
+  },
+  // experimental feature:
+  indexes: [
+    {
+      name: "caches_hash_idx",
+      columns: ["hash"],
+      type: "unique"
+    }
+  ]
+};
+const cache$1 = { schema: schema$1 };
+const contentTypes$1 = { cache: cache$1 };
+async function hasDeepPopulateCacheFullTextIndex(db, tableName, columnName) {
+  const knex = db.connection;
+  const client = db.dialect.client;
+  if (client === "sqlite") {
+    return (await db.dialect.schemaInspector.getTables()).includes(`${tableName}_fts`);
+  }
+  if (client === "mysql" || client === "mysql2") {
+    return (await db.dialect.schemaInspector.getIndexes(tableName)).find(
+      ({ name }) => name === `${tableName}_${columnName}_fulltext`
+    ) !== void 0;
+  }
+  if (client === "pg" || client === "postgres") {
+    const result = await knex.raw(
+      `SELECT * FROM pg_indexes WHERE tablename = '${tableName}' AND indexname = '${tableName}_${columnName}_gin'`
+    );
+    return result.rows.length > 0;
+  }
+  console.log(`Full-text index not supported for this database engine (${client})`);
+  return false;
+}
+async function addDeepPopulateCacheFullTextIndex(db, tableName, columnName) {
+  const knex = db.connection;
+  const hasTable = await knex.schema.hasTable(tableName);
+  if (!hasTable) return;
+  const hasColumn = await knex.schema.hasColumn(tableName, columnName);
+  if (!hasColumn) return;
+  const client = db.dialect.client;
+  if (client === "sqlite") {
+    await knex.raw(`CREATE VIRTUAL TABLE ${tableName}_fts USING fts3(${columnName})`);
+    await knex.raw(`INSERT INTO ${tableName}_fts (${columnName}) SELECT ${columnName} FROM ${tableName}`);
+  } else if (client === "mysql" || client === "mysql2") {
+    await knex.raw(`ALTER TABLE ${tableName} ADD FULLTEXT INDEX ${tableName}_${columnName}_fulltext (${columnName})`);
+  } else if (client === "pg" || client === "postgres") {
+    await knex.raw(
+      `CREATE INDEX ${tableName}_${columnName}_gin ON ${tableName} USING GIN (to_tsvector('english', ${columnName}))`
+    );
+  } else {
+    console.log(`Full-text index not supported for this database engine (${client})`);
+  }
+}
+async function removeDeepPopulateCacheFullTextIndex(db, tableName, columnName) {
+  const knex = db.connection;
+  const hasTable = await knex.schema.hasTable(tableName);
+  if (!hasTable) return;
+  const hasColumn = await knex.schema.hasColumn(tableName, columnName);
+  if (!hasColumn) return;
+  const client = db.dialect.client;
+  if (client === "sqlite") {
+    await knex.raw(`DROP TABLE ${tableName}_fts`);
+  } else if (client === "mysql" || client === "mysql2") {
+    await knex.raw(`ALTER TABLE ${tableName} DROP INDEX ${tableName}_${columnName}_fulltext`);
+  } else if (client === "pg" || client === "postgres") {
+    await knex.raw(`DROP INDEX ${tableName}_${columnName}_gin`);
+  } else {
+    console.log(`Full-text index not supported for this database engine (${client})`);
+  }
+}
+const register = async ({ strapi: strapi2 }) => {
+  strapi2.hook("strapi::content-types.afterSync").register(async () => {
+    const tableName = "caches";
+    const columnName = "dependencies";
+    const hasIndex = await hasDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+    if (strapi2.config.get("plugin::deep-populate").cachePopulate === true) {
+      if (!hasIndex) {
+        await addDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+      }
+    } else if (hasIndex) {
+      await removeDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+    }
+  });
+  strapi2.documents.use(async (context, next) => {
+    const { cachePopulate, augmentPopulateStar } = strapi2.config.get("plugin::deep-populate");
+    if (
+      // do nothing if not configured
+      !cachePopulate && !augmentPopulateStar || context.uid === "plugin::deep-populate.cache"
+    )
+      return await next();
+    const populateService = strapi2.plugin("deep-populate").service("populate");
+    const cacheService = strapi2.plugin("deep-populate").service("cache");
+    const { populate: populate2 } = context.params;
+    const returnDeeplyPopulated = augmentPopulateStar && populate2 === "*";
+    if (cachePopulate && context.action === "delete")
+      await cacheService.clear({ ...context.params, contentType: context.uid });
+    const originalFields = klona(context.fields);
+    if (returnDeeplyPopulated && ["findOne", "findFirst", "findMany"].includes(context.action))
+      context.fields = ["documentId", "status", "locale"];
+    const result = await next();
+    if (["create", "update"].includes(context.action)) {
+      const { documentId, status: status2, locale: locale2 } = result;
+      if (cachePopulate && context.action === "update")
+        await cacheService.clear({ ...context.params, contentType: context.uid });
+      if (cachePopulate || returnDeeplyPopulated) {
+        const deepPopulate = await populateService.get({ contentType: context.uid, documentId, status: status2, locale: locale2 });
+        if (returnDeeplyPopulated)
+          return await strapi2.documents(context.uid).findOne({ documentId, status: status2, locale: locale2, fields: originalFields, populate: deepPopulate });
+      }
+    }
+    if (returnDeeplyPopulated && ["findOne", "findFirst"].includes(context.action)) {
+      const { documentId, status: status2, locale: locale2 } = result;
+      const deepPopulate = await populateService.get({ contentType: context.uid, documentId, status: status2, locale: locale2 });
+      return await strapi2.documents(context.uid).findOne({ documentId, status: status2, locale: locale2, fields: originalFields, populate: deepPopulate });
+    }
+    if (returnDeeplyPopulated && context.action === "findMany") {
+      return await Promise.all(
+        result.map(async ({ documentId, status: status2, locale: locale2 }) => {
+          const deepPopulate = await populateService.get({ contentType: context.uid, documentId, status: status2, locale: locale2 });
+          return await strapi2.documents(context.uid).findOne({ documentId, status: status2, locale: locale2, fields: originalFields, populate: deepPopulate });
+        })
+      );
+    }
+    return result;
+  });
+};
+const getHash = (params) => {
+  return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}`;
+};
+const cache = ({ strapi: strapi2 }) => ({
+  async get(params) {
+    const entry = await strapi2.documents("plugin::deep-populate.cache").findFirst({ filters: { hash: { $eq: getHash(params) } } });
+    return entry ? entry.populate : null;
+  },
+  async set({ populate: populate2, dependencies, ...params }) {
+    return await strapi2.documents("plugin::deep-populate.cache").create({ data: { hash: getHash(params), params, populate: populate2, dependencies: dependencies.join(",") } });
+  },
+  async clear(params) {
+    const entry = await strapi2.documents("plugin::deep-populate.cache").findFirst({ filters: { hash: { $eq: getHash(params) } } });
+    let retval = null;
+    if (entry) {
+      retval = await strapi2.documents("plugin::deep-populate.cache").delete({ documentId: entry.documentId });
+    }
+    await this.refreshDependents(params.documentId);
+    return retval;
+  },
+  async refreshDependents(documentId) {
+    const entries = await strapi2.documents("plugin::deep-populate.cache").findMany({ filters: { dependencies: { $contains: documentId } }, fields: ["documentId", "params"] });
+    const deleted = await strapi2.db.query("plugin::deep-populate.cache").deleteMany({
+      where: {
+        documentId: { $in: entries.map((x) => x.documentId) }
+      }
+    });
+    if (deleted.count !== entries.length)
+      console.error(`Deleted count ${deleted.count} does not match entries count ${entries.length}`);
+    const batchSize = 5;
+    for (let i = 0; i < entries.length; i += batchSize) {
+      const batch = entries.slice(i, i + batchSize);
+      await Promise.all(batch.map((entry) => strapi2.service("plugin::deep-populate.populate").get(entry.params)));
+    }
+  }
+});
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -588,8 +788,8 @@ lodash.exports;
         return object2[key];
       });
     }
-    function cacheHas2(cache, key) {
-      return cache.has(key);
+    function cacheHas2(cache2, key) {
+      return cache2.has(key);
     }
     function charsStartIndex(strSymbols, chrSymbols) {
       var index2 = -1, length = strSymbols.length;
@@ -1404,8 +1604,8 @@ lodash.exports;
             if (!(seen ? cacheHas2(seen, computed) : includes2(result2, computed, comparator))) {
               othIndex = othLength;
               while (--othIndex) {
-                var cache = caches[othIndex];
-                if (!(cache ? cacheHas2(cache, computed) : includes2(arrays[othIndex], computed, comparator))) {
+                var cache2 = caches[othIndex];
+                if (!(cache2 ? cacheHas2(cache2, computed) : includes2(arrays[othIndex], computed, comparator))) {
                   continue outer;
                 }
               }
@@ -2979,12 +3179,12 @@ lodash.exports;
       }
       function memoizeCapped2(func) {
         var result2 = memoize2(func, function(key) {
-          if (cache.size === MAX_MEMOIZE_SIZE2) {
-            cache.clear();
+          if (cache2.size === MAX_MEMOIZE_SIZE2) {
+            cache2.clear();
           }
           return key;
         });
-        var cache = result2.cache;
+        var cache2 = result2.cache;
         return result2;
       }
       function mergeData(data, source) {
@@ -3938,12 +4138,12 @@ lodash.exports;
           throw new TypeError2(FUNC_ERROR_TEXT2);
         }
         var memoized = function() {
-          var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-          if (cache.has(key)) {
-            return cache.get(key);
+          var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+          if (cache2.has(key)) {
+            return cache2.get(key);
           }
           var result2 = func.apply(this, args);
-          memoized.cache = cache.set(key, result2) || cache;
+          memoized.cache = cache2.set(key, result2) || cache2;
           return result2;
         };
         memoized.cache = new (memoize2.Cache || MapCache2)();
@@ -9205,7 +9405,7 @@ function baseConvert(util2, name, func, options) {
     throw new TypeError();
   }
   options || (options = {});
-  var config = {
+  var config2 = {
     "cap": "cap" in options ? options.cap : true,
     "curry": "curry" in options ? options.curry : true,
     "fixed": "fixed" in options ? options.fixed : true,
@@ -9241,7 +9441,7 @@ function baseConvert(util2, name, func, options) {
     "iteratee": function(iteratee) {
       return function() {
         var func2 = arguments[0], arity = arguments[1], result = iteratee(func2, arity), length = result.length;
-        if (config.cap && typeof arity == "number") {
+        if (config2.cap && typeof arity == "number") {
           arity = arity > 2 ? arity - 2 : 1;
           return length && length <= arity ? result : baseAry(result, arity);
         }
@@ -9291,7 +9491,7 @@ function baseConvert(util2, name, func, options) {
     }
   };
   function castCap(name2, func2) {
-    if (config.cap) {
+    if (config2.cap) {
       var indexes = mapping.iterateeRearg[name2];
       if (indexes) {
         return iterateeRearg(func2, indexes);
@@ -9304,17 +9504,17 @@ function baseConvert(util2, name, func, options) {
     return func2;
   }
   function castCurry(name2, func2, n) {
-    return forceCurry || config.curry && n > 1 ? curry(func2, n) : func2;
+    return forceCurry || config2.curry && n > 1 ? curry(func2, n) : func2;
   }
   function castFixed(name2, func2, n) {
-    if (config.fixed && (forceFixed || !mapping.skipFixed[name2])) {
+    if (config2.fixed && (forceFixed || !mapping.skipFixed[name2])) {
       var data = mapping.methodSpread[name2], start = data && data.start;
       return start === void 0 ? ary(func2, n) : flatSpread(func2, start);
     }
     return func2;
   }
   function castRearg(name2, func2, n) {
-    return config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name2]) ? rearg(func2, mapping.methodRearg[name2] || mapping.aryRearg[n]) : func2;
+    return config2.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name2]) ? rearg(func2, mapping.methodRearg[name2] || mapping.aryRearg[n]) : func2;
   }
   function cloneByPath(object2, path2) {
     path2 = toPath(path2);
@@ -9359,7 +9559,7 @@ function baseConvert(util2, name, func, options) {
       while (length--) {
         args[length] = arguments[length];
       }
-      var index2 = config.rearg ? 0 : length - 1;
+      var index2 = config2.rearg ? 0 : length - 1;
       args[index2] = transform2(args[index2]);
       return func2.apply(void 0, args);
     };
@@ -9368,7 +9568,7 @@ function baseConvert(util2, name, func, options) {
     var result, realName = mapping.aliasToReal[name2] || name2, wrapped = func2, wrapper = wrappers[realName];
     if (wrapper) {
       wrapped = wrapper(func2);
-    } else if (config.immutable) {
+    } else if (config2.immutable) {
       if (mapping.mutate.array[realName]) {
         wrapped = wrapImmutable(func2, cloneArray);
       } else if (mapping.mutate.object[realName]) {
@@ -10660,12 +10860,12 @@ function memoize$1(func, resolver) {
     throw new TypeError(FUNC_ERROR_TEXT);
   }
   var memoized = function() {
-    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-    if (cache.has(key)) {
-      return cache.get(key);
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+    if (cache2.has(key)) {
+      return cache2.get(key);
     }
     var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result) || cache;
+    memoized.cache = cache2.set(key, result) || cache2;
     return result;
   };
   memoized.cache = new (memoize$1.Cache || MapCache$2)();
@@ -10677,12 +10877,12 @@ var memoize = memoize_1;
 var MAX_MEMOIZE_SIZE = 500;
 function memoizeCapped$1(func) {
   var result = memoize(func, function(key) {
-    if (cache.size === MAX_MEMOIZE_SIZE) {
-      cache.clear();
+    if (cache2.size === MAX_MEMOIZE_SIZE) {
+      cache2.clear();
     }
     return key;
   });
-  var cache = result.cache;
+  var cache2 = result.cache;
   return result;
 }
 var _memoizeCapped = memoizeCapped$1;
@@ -11184,8 +11384,8 @@ function arraySome$1(array2, predicate) {
   return false;
 }
 var _arraySome = arraySome$1;
-function cacheHas$1(cache, key) {
-  return cache.has(key);
+function cacheHas$1(cache2, key) {
+  return cache2.has(key);
 }
 var _cacheHas = cacheHas$1;
 var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
@@ -11810,7 +12010,7 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   }
   return target;
 }
-function createValidation(config) {
+function createValidation(config2) {
   function validate(_ref, cb) {
     let {
       value,
@@ -11825,7 +12025,7 @@ function createValidation(config) {
       test,
       params,
       message
-    } = config;
+    } = config2;
     let {
       parent,
       context
@@ -11880,7 +12080,7 @@ function createValidation(config) {
     else if (!result) cb(createError());
     else cb(null, result);
   }
-  validate.OPTIONS = config;
+  validate.OPTIONS = config2;
   return validate;
 }
 let trim = (part) => part.substr(0, part.length - 1).substr(1);
@@ -24570,7 +24770,7 @@ const isPopulateString = (value) => {
 };
 const isStringArray$1 = (value) => fp.isArray(value) && value.every(fp.isString);
 const isObj = (value) => fp.isObject(value);
-const populate$1 = traverseFactory().intercept(isPopulateString, async (visitor2, options, populate2, { recurse }) => {
+const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2, options, populate2, { recurse }) => {
   const populateObject = pathsToObjectPopulate([populate2]);
   const traversedPopulate = await recurse(visitor2, options, populateObject);
   const [result] = objectPopulateToPaths(traversedPopulate);
@@ -24738,7 +24938,7 @@ const populate$1 = traverseFactory().intercept(isPopulateString, async (visitor2
     }
   }
 );
-const traverseQueryPopulate = fp.curry(populate$1.traverse);
+const traverseQueryPopulate = fp.curry(populate$2.traverse);
 const objectPopulateToPaths = (input) => {
   const paths = [];
   function traverse(currentObj, parentPath) {
@@ -25058,54 +25258,40 @@ const hasValue = (value) => {
   return !(value === null || value === void 0 || Array.isArray(value) && value.length === 0 || typeof value === "object" && isEmpty(value));
 };
 async function _populateComponent({
-  mainUid,
-  mainDocumentId,
-  schema: schema2,
   populate: populate2 = {},
   lookup,
+  attrName,
   inDynamicZone = false,
-  resolvedRelations,
-  omitEmpty
+  ...params
 }) {
-  const attrName = lookup.pop();
   const componentLookup = lookup.length === 0 ? [attrName] : [...lookup, inDynamicZone ? "on" : "populate", attrName];
-  const componentPopulate = klona(populate2);
+  const componentPopulate = populate2;
   dset(componentPopulate, componentLookup, { populate: "*" });
   const nestedPopulate = await _populate({
-    mainUid,
-    mainDocumentId,
-    schema: schema2,
     populate: componentPopulate,
     lookup: componentLookup,
-    resolvedRelations,
-    omitEmpty
+    ...params
   });
   return isEmpty(nestedPopulate) ? true : { populate: nestedPopulate };
 }
 async function _populateDynamicZone({
-  mainUid,
-  mainDocumentId,
   components,
-  populate: populate2,
   lookup,
-  resolvedRelations,
-  omitEmpty
+  attrName,
+  ...params
 }) {
-  const resolvedPopulate = await components.reduce(async (prev, cur) => {
-    const curPopulate = await _populateComponent({
-      mainUid,
-      mainDocumentId,
-      schema: cur,
-      populate: populate2,
-      lookup: [...lookup, cur],
+  const dynamicZoneLookup = [...lookup, attrName];
+  const resolvedPopulate = {};
+  for (const component of components) {
+    const componentPopulate = await _populateComponent({
+      schema: component,
+      lookup: dynamicZoneLookup,
+      attrName: component,
       inDynamicZone: true,
-      resolvedRelations,
-      omitEmpty
+      ...params
     });
-    const newPop = await prev;
-    dset(newPop, [cur], curPopulate);
-    return newPop;
-  }, Promise.resolve({}));
+    dset(resolvedPopulate, [component], componentPopulate);
+  }
   if (isEmpty(resolvedPopulate)) return void 0;
   return { on: resolvedPopulate };
 }
@@ -25116,18 +25302,23 @@ async function _populateRelation({
   contentType,
   relation,
   resolvedRelations,
-  omitEmpty
+  omitEmpty,
+  locale: locale2,
+  status: status2
 }) {
   const isSingleRelation = !Array.isArray(relation);
   const relations = isSingleRelation ? [relation] : relation;
-  for (const relation2 of relations.filter(({ documentId }) => !resolvedRelations.has(documentId))) {
+  const nonResolvedRelations = relations.filter(({ documentId }) => !resolvedRelations.has(documentId));
+  for (const relation2 of nonResolvedRelations) {
     resolvedRelations.set(relation2.documentId, {});
     const relationPopulate = await _populate({
-      mainUid: contentType,
-      mainDocumentId: relation2.documentId,
+      contentType,
+      documentId: relation2.documentId,
       schema: contentType,
       resolvedRelations,
-      omitEmpty
+      omitEmpty,
+      locale: locale2,
+      status: status2
     });
     resolvedRelations.set(relation2.documentId, relationPopulate);
   }
@@ -25157,7 +25348,7 @@ const _resolveValue = ({ document: document2, lookup, attrName }) => {
     const childLookup = lookup[populateIdx + 1];
     const parentValue2 = delve(document2, parentLookup);
     const childValue = (Array.isArray(parentValue2) ? parentValue2 : [parentValue2]).map(
-      (v) => _resolveValue({ document: parentValue2, lookup: childLookup, attrName })
+      (v) => _resolveValue({ document: v, lookup: childLookup, attrName })
     );
     return childValue.find((v) => hasValue(v));
   }
@@ -25168,18 +25359,18 @@ const _resolveValue = ({ document: document2, lookup, attrName }) => {
   return parentValue?.[attrName];
 };
 async function _populate({
-  mainUid,
-  mainDocumentId,
+  contentType,
   schema: schema2,
   populate: populate2 = {},
   lookup = [],
-  resolvedRelations = /* @__PURE__ */ new Map(),
-  omitEmpty = true
+  resolvedRelations,
+  omitEmpty,
+  ...params
 }) {
   const newPopulate = {};
-  const model = strapi.getModel(schema2);
-  const relations = getRelations(model);
-  const currentPopulate = klona(populate2);
+  let relations = getRelations(strapi.getModel(schema2));
+  let currentPopulate = klona(populate2);
+  resolvedRelations.set(params.documentId, true);
   for (const [attrName] of relations) {
     if (lookup.length > 0) {
       const parent = delve(currentPopulate, lookup);
@@ -25190,47 +25381,56 @@ async function _populate({
       dset(currentPopulate, attrName, { populate: "*" });
     }
   }
-  const document2 = await strapi.documents(mainUid).findOne({
-    documentId: mainDocumentId,
+  let document2 = await strapi.documents(contentType).findOne({
+    ...params,
     populate: currentPopulate ? currentPopulate : "*"
   });
+  currentPopulate = null;
+  const resolveRelations = [];
   for (const [attrName, attr] of relations) {
     const value = _resolveValue({ document: document2, attrName, lookup });
     if (!hasValue(value)) {
       if (!omitEmpty) newPopulate[attrName] = true;
       continue;
     }
+    resolveRelations.push([attrName, attr, value]);
+  }
+  relations = null;
+  document2 = null;
+  for (const [attrName, attr, value] of resolveRelations) {
     if (contentTypes.isDynamicZoneAttribute(attr)) {
       const relComponents = value.map(
         (dataComponent) => attr.components.find((schemaComponent) => schemaComponent === dataComponent.__component)
       );
       newPopulate[attrName] = await _populateDynamicZone({
-        mainUid,
-        mainDocumentId,
+        contentType,
         components: relComponents,
-        lookup: [...lookup, attrName],
+        lookup,
+        attrName,
         resolvedRelations,
-        omitEmpty
+        omitEmpty,
+        ...params
       });
     }
     if (contentTypes.isRelationalAttribute(attr)) {
-      const { target: relContentType } = attr;
-      resolvedRelations.set(mainDocumentId, true);
       newPopulate[attrName] = await _populateRelation({
-        contentType: relContentType,
+        contentType: attr.target,
         relation: value,
         resolvedRelations,
-        omitEmpty
+        omitEmpty,
+        locale: params.locale,
+        status: params.status
       });
     }
     if (contentTypes.isComponentAttribute(attr) && !contentTypes.isDynamicZoneAttribute(attr)) {
       newPopulate[attrName] = await _populateComponent({
-        mainUid,
-        mainDocumentId,
+        contentType,
         schema: attr.component,
-        lookup: [...lookup, attrName],
+        lookup,
+        attrName,
         resolvedRelations,
-        omitEmpty
+        omitEmpty,
+        ...params
       });
     }
     if (contentTypes.isMediaAttribute(attr)) {
@@ -25239,43 +25439,31 @@ async function _populate({
   }
   return newPopulate;
 }
+async function populate$1(params) {
+  const resolvedRelations = /* @__PURE__ */ new Map();
+  const populated = await _populate({ ...params, schema: params.contentType, resolvedRelations });
+  return { populate: populated, dependencies: [...resolvedRelations.keys()] };
+}
 const populate = ({ strapi: strapi2 }) => ({
-  async get({
-    contentType,
-    documentId,
-    omitEmpty = false
-  }) {
-    return await _populate({ mainUid: contentType, mainDocumentId: documentId, schema: contentType, omitEmpty });
-  },
-  documents(contentType) {
-    strapi2.documents(contentType);
-    const { findOne, ...wrapped } = strapi2.documents(contentType);
-    const wrappedFindOne = async (params) => {
-      const { documentId, populate: originalPopulate } = params;
-      const deepPopulate = await _populate({
-        mainUid: contentType,
-        mainDocumentId: documentId,
-        schema: contentType,
-        omitEmpty: originalPopulate !== "*"
-      });
-      if (originalPopulate && originalPopulate !== "*") {
-        strapi2.log.warn(
-          `passed "populate" will be merged with deepPopulate, which could result in unexpected behavior.`
-        );
-        if (typeof originalPopulate === "object")
-          Object.keys(originalPopulate).map((k) => dset(deepPopulate, k, originalPopulate[k]));
-        if (Array.isArray(originalPopulate)) originalPopulate.map((k) => dset(deepPopulate, k, true));
-      }
-      return await findOne({ ...params, populate: deepPopulate });
-    };
-    return { ...wrapped, findOne: wrappedFindOne };
+  async get(params) {
+    const { cachePopulate } = strapi2.config.get("plugin::deep-populate");
+    if (!cachePopulate) return (await populate$1(params)).populate;
+    const cachedEntry = await strapi2.service("plugin::deep-populate.cache").get(params);
+    if (cachedEntry) return cachedEntry;
+    const resolved = await populate$1(params);
+    await strapi2.service("plugin::deep-populate.cache").set({ ...params, ...resolved });
+    return resolved;
   }
 });
 const services = {
-  populate
+  populate,
+  cache
 };
 const index = {
-  services
+  config,
+  contentTypes: contentTypes$1,
+  services,
+  register
 };
 export {
   index as default