@fourlights/strapi-plugin-deep-populate 1.2.4 → 1.3.0

package/dist/server/index.mjs

@@ -1,4 +1,3 @@
-import { klona } from "klona/json";
 import require$$1 from "crypto";
 import require$$0$1 from "child_process";
 import require$$0$2 from "os";
@@ -11,16 +10,17 @@ import require$$0$6 from "stream";
 import require$$2$1 from "util";
 import require$$0$8 from "constants";
 import "node:stream";
+import { klona } from "klona/json";
 import delve from "dlv";
 import { dset } from "dset/merge";
 const config = {
-  default: ({ env: env2 }) => ({ cachePopulate: true, augmentPopulateStar: true }),
+  default: ({ env: env2 }) => ({ useCache: true, replaceWildcard: true }),
   validator: (config2) => {
   }
 };
 const schema$1 = {
   kind: "collectionType",
-  collectionName: "caches",
+  collectionName: "populate_cache",
   info: {
     singularName: "cache",
     pluralName: "caches",
@@ -64,161 +64,6 @@ const schema$1 = {
 };
 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);
-    const hasTable = await strapi2.db.connection.schema.hasTable(tableName);
-    const hasColumn = hasTable && await strapi2.db.connection.schema.hasColumn(tableName, columnName);
-    const cacheIsEnabled = strapi2.config.get("plugin::deep-populate").cachePopulate === true;
-    const shouldCreateIndex = cacheIsEnabled && hasTable && hasColumn && !hasIndex;
-    const shouldRemoveIndex = hasIndex && (!cacheIsEnabled || !hasTable || !hasColumn);
-    if (shouldCreateIndex) await addDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
-    if (shouldRemoveIndex) 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 }) {
-    const documentService = strapi2.documents("plugin::deep-populate.cache");
-    const hash = getHash(params);
-    const entry = await documentService.findFirst({ filters: { hash: { $eq: hash } } });
-    return entry ? await documentService.update({
-      documentId: entry.documentId,
-      data: { populate: populate2, dependencies: dependencies.join(",") }
-    }) : await documentService.create({ data: { hash, 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;
@@ -24336,7 +24181,7 @@ const createVisitorUtils = ({ data }) => ({
     data[key] = value;
   }
 });
-fp.curry(traverseEntity);
+const traverseEntity$1 = fp.curry(traverseEntity);
 const GROUP_OPERATORS = ["$and", "$or"];
 const WHERE_OPERATORS = [
   "$not",
@@ -24429,6 +24274,100 @@ const visitor$7 = ({ schema: schema2, key, attribute }, { remove: remove2 }) =>
     remove2(key);
   }
 };
+const VALID_RELATION_ORDERING_KEYS = {
+  strict: fp.isBoolean
+};
+const ACTIONS_TO_VERIFY$1 = ["find"];
+const { CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$1 } = constants$1;
+const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schema: schema2 }, { remove: remove2, set: set2 }) => {
+  if (!attribute) {
+    return;
+  }
+  const isRelation = attribute.type === "relation";
+  if (!isRelation) {
+    return;
+  }
+  const handleMorphRelation = async () => {
+    const elements = data[key];
+    if ("connect" in elements || "set" in elements || "disconnect" in elements) {
+      const newValue = {};
+      const connect = await handleMorphElements(elements.connect || []);
+      const relSet = await handleMorphElements(elements.set || []);
+      const disconnect = await handleMorphElements(elements.disconnect || []);
+      if (connect.length > 0) {
+        newValue.connect = connect;
+      }
+      if (relSet.length > 0) {
+        newValue.set = relSet;
+      }
+      if (disconnect.length > 0) {
+        newValue.disconnect = disconnect;
+      }
+      if ("options" in elements && typeof elements.options === "object" && elements.options !== null) {
+        const filteredOptions = {};
+        Object.keys(elements.options).forEach((key2) => {
+          const validator = VALID_RELATION_ORDERING_KEYS[key2];
+          if (validator && validator(elements.options[key2])) {
+            filteredOptions[key2] = elements.options[key2];
+          }
+        });
+        newValue.options = filteredOptions;
+      } else {
+        newValue.options = {};
+      }
+      set2(key, newValue);
+    } else {
+      const newMorphValue = await handleMorphElements(elements);
+      if (newMorphValue.length) {
+        set2(key, newMorphValue);
+      }
+    }
+  };
+  const handleMorphElements = async (elements) => {
+    const allowedElements = [];
+    if (!fp.isArray(elements)) {
+      return allowedElements;
+    }
+    for (const element of elements) {
+      if (!fp.isObject(element) || !("__type" in element)) {
+        continue;
+      }
+      const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${element.__type}.${action}`);
+      const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
+      if (isAllowed) {
+        allowedElements.push(element);
+      }
+    }
+    return allowedElements;
+  };
+  const handleRegularRelation = async () => {
+    const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${attribute.target}.${action}`);
+    const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
+    if (!isAllowed) {
+      remove2(key);
+    }
+  };
+  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key);
+  if (isMorphToRelationalAttribute(attribute)) {
+    await handleMorphRelation();
+    return;
+  }
+  if (isCreatorRelation && schema2.options?.populateCreatorFields) {
+    return;
+  }
+  await handleRegularRelation();
+};
+const hasAccessToSomeScopes$1 = async (scopes, auth) => {
+  for (const scope of scopes) {
+    try {
+      await strapi.auth.verify(auth, { scope });
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+};
 const visitor$6 = ({ key, attribute }, { remove: remove2 }) => {
   if (isMorphToRelationalAttribute(attribute)) {
     remove2(key);
@@ -24439,6 +24378,54 @@ const visitor$5 = ({ key, attribute }, { remove: remove2 }) => {
     remove2(key);
   }
 };
+const removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path2 } }, { remove: remove2 }) => {
+  if (allowedFields === null) {
+    return;
+  }
+  if (!(fp.isArray(allowedFields) && allowedFields.every(fp.isString))) {
+    throw new TypeError(
+      `Expected array of strings for allowedFields but got "${typeof allowedFields}"`
+    );
+  }
+  if (fp.isNil(path2)) {
+    return;
+  }
+  const containedPaths = getContainedPaths$1(path2);
+  const isPathAllowed = allowedFields.some(
+    (p) => containedPaths.includes(p) || p.startsWith(`${path2}.`)
+  );
+  if (isPathAllowed) {
+    return;
+  }
+  remove2(key);
+};
+const getContainedPaths$1 = (path2) => {
+  const parts = fp.toPath(path2);
+  return parts.reduce((acc, value, index2, list) => {
+    return [...acc, list.slice(0, index2 + 1).join(".")];
+  }, []);
+};
+const removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path2 } }, { remove: remove2 }) => {
+  if (restrictedFields === null) {
+    remove2(key);
+    return;
+  }
+  if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
+    throw new TypeError(
+      `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
+    );
+  }
+  if (restrictedFields.includes(path2)) {
+    remove2(key);
+    return;
+  }
+  const isRestrictedNested = restrictedFields.some(
+    (allowedPath) => path2?.toString().startsWith(`${allowedPath}.`)
+  );
+  if (isRestrictedNested) {
+    remove2(key);
+  }
+};
 const visitor$4 = ({ schema: schema2, key, value }, { set: set2 }) => {
   if (key === "" && value === "*") {
     const { attributes } = schema2;
@@ -24448,6 +24435,17 @@ const visitor$4 = ({ schema: schema2, key, value }, { set: set2 }) => {
     set2("", newPopulateQuery);
   }
 };
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  expandWildcardPopulate: visitor$4,
+  removeDisallowedFields,
+  removeDynamicZones: visitor$5,
+  removeMorphToRelations: visitor$6,
+  removePassword: visitor$8,
+  removePrivate: visitor$7,
+  removeRestrictedFields,
+  removeRestrictedRelations
+}, Symbol.toStringTag, { value: "Module" }));
 const DEFAULT_PATH = { raw: null, attribute: null };
 const traverseFactory = () => {
   const state = {
@@ -25003,6 +25001,25 @@ const fields = traverseFactory().intercept(isStringArray, async (visitor2, optio
 }));
 const traverseQueryFields = fp.curry(fields.traverse);
 const { ID_ATTRIBUTE: ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$2 } = constants$1;
+const sanitizePasswords = (ctx) => async (entity) => {
+  if (!ctx.schema) {
+    throw new Error("Missing schema in sanitizePasswords");
+  }
+  return traverseEntity$1(visitor$8, ctx, entity);
+};
+const defaultSanitizeOutput = async (ctx, entity) => {
+  if (!ctx.schema) {
+    throw new Error("Missing schema in defaultSanitizeOutput");
+  }
+  return traverseEntity$1(
+    (...args) => {
+      visitor$8(...args);
+      visitor$7(...args);
+    },
+    ctx,
+    entity
+  );
+};
 const defaultSanitizeFilters = fp.curry((ctx, filters2) => {
   if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeFilters");
@@ -25117,6 +25134,144 @@ const defaultSanitizePopulate = fp.curry((ctx, populate2) => {
     traverseQueryPopulate(visitor$7, ctx)
   )(populate2);
 });
+const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  defaultSanitizeFields,
+  defaultSanitizeFilters,
+  defaultSanitizeOutput,
+  defaultSanitizePopulate,
+  defaultSanitizeSort,
+  sanitizePasswords
+}, Symbol.toStringTag, { value: "Module" }));
+const createAPISanitizers = (opts) => {
+  const { getModel } = opts;
+  const sanitizeInput = (data, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeInput");
+    }
+    if (fp.isArray(data)) {
+      return Promise.all(data.map((entry) => sanitizeInput(entry, schema2, { auth })));
+    }
+    const nonWritableAttributes = getNonWritableAttributes(schema2);
+    const transforms = [
+      // Remove first level ID in inputs
+      fp.omit(constants$1.ID_ATTRIBUTE),
+      fp.omit(constants$1.DOC_ID_ATTRIBUTE),
+      // Remove non-writable attributes
+      traverseEntity$1(removeRestrictedFields(nonWritableAttributes), { schema: schema2, getModel })
+    ];
+    if (auth) {
+      transforms.push(
+        traverseEntity$1(removeRestrictedRelations(auth), { schema: schema2, getModel })
+      );
+    }
+    opts?.sanitizers?.input?.forEach((sanitizer) => transforms.push(sanitizer(schema2)));
+    return pipe(...transforms)(data);
+  };
+  const sanitizeOutput = async (data, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeOutput");
+    }
+    if (fp.isArray(data)) {
+      const res = new Array(data.length);
+      for (let i = 0; i < data.length; i += 1) {
+        res[i] = await sanitizeOutput(data[i], schema2, { auth });
+      }
+      return res;
+    }
+    const transforms = [
+      (data2) => defaultSanitizeOutput({ schema: schema2, getModel }, data2)
+    ];
+    if (auth) {
+      transforms.push(
+        traverseEntity$1(removeRestrictedRelations(auth), { schema: schema2, getModel })
+      );
+    }
+    opts?.sanitizers?.output?.forEach((sanitizer) => transforms.push(sanitizer(schema2)));
+    return pipe(...transforms)(data);
+  };
+  const sanitizeQuery = async (query, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeQuery");
+    }
+    const { filters: filters2, sort: sort2, fields: fields2, populate: populate2 } = query;
+    const sanitizedQuery = fp.cloneDeep(query);
+    if (filters2) {
+      Object.assign(sanitizedQuery, { filters: await sanitizeFilters(filters2, schema2, { auth }) });
+    }
+    if (sort2) {
+      Object.assign(sanitizedQuery, { sort: await sanitizeSort(sort2, schema2, { auth }) });
+    }
+    if (fields2) {
+      Object.assign(sanitizedQuery, { fields: await sanitizeFields(fields2, schema2) });
+    }
+    if (populate2) {
+      Object.assign(sanitizedQuery, { populate: await sanitizePopulate(populate2, schema2) });
+    }
+    return sanitizedQuery;
+  };
+  const sanitizeFilters = (filters2, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeFilters");
+    }
+    if (fp.isArray(filters2)) {
+      return Promise.all(filters2.map((filter) => sanitizeFilters(filter, schema2, { auth })));
+    }
+    const transforms = [defaultSanitizeFilters({ schema: schema2, getModel })];
+    if (auth) {
+      transforms.push(
+        traverseQueryFilters(removeRestrictedRelations(auth), { schema: schema2, getModel })
+      );
+    }
+    return pipe(...transforms)(filters2);
+  };
+  const sanitizeSort = (sort2, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeSort");
+    }
+    const transforms = [defaultSanitizeSort({ schema: schema2, getModel })];
+    if (auth) {
+      transforms.push(
+        traverseQuerySort(removeRestrictedRelations(auth), { schema: schema2, getModel })
+      );
+    }
+    return pipe(...transforms)(sort2);
+  };
+  const sanitizeFields = (fields2, schema2) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizeFields");
+    }
+    const transforms = [defaultSanitizeFields({ schema: schema2, getModel })];
+    return pipe(...transforms)(fields2);
+  };
+  const sanitizePopulate = (populate2, schema2, { auth } = {}) => {
+    if (!schema2) {
+      throw new Error("Missing schema in sanitizePopulate");
+    }
+    const transforms = [defaultSanitizePopulate({ schema: schema2, getModel })];
+    if (auth) {
+      transforms.push(
+        traverseQueryPopulate(removeRestrictedRelations(auth), { schema: schema2, getModel })
+      );
+    }
+    return pipe(...transforms)(populate2);
+  };
+  return {
+    input: sanitizeInput,
+    output: sanitizeOutput,
+    query: sanitizeQuery,
+    filters: sanitizeFilters,
+    sort: sanitizeSort,
+    fields: sanitizeFields,
+    populate: sanitizePopulate
+  };
+};
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createAPISanitizers,
+  sanitizers,
+  visitors: index$4
+}, Symbol.toStringTag, { value: "Module" }));
 [constants$1.DOC_ID_ATTRIBUTE, constants$1.DOC_ID_ATTRIBUTE];
 const isCamelCase = (value) => /^[a-z][a-zA-Z0-9]+$/.test(value);
 const isKebabCase = (value) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
@@ -25242,6 +25397,175 @@ setLocale({
     }
   }
 });
+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 populateIsWildcardEquivalent = async ({
+  strapi: strapi2,
+  schema: schema2,
+  populate: populate2
+}) => {
+  const expandedWildcardQuery = await index$2.sanitizers.defaultSanitizePopulate(
+    {
+      schema: schema2,
+      getModel: (uid) => strapi2.getModel(uid)
+    },
+    "*"
+  );
+  return populate2 === "*" || populate2 === true || JSON.stringify(expandedWildcardQuery) === JSON.stringify(populate2);
+};
+const register = async ({ strapi: strapi2 }) => {
+  strapi2.hook("strapi::content-types.afterSync").register(async () => {
+    const tableName = "populate_cache";
+    const columnName = "dependencies";
+    const hasIndex = await hasDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+    const hasTable = await strapi2.db.connection.schema.hasTable(tableName);
+    const hasColumn = hasTable && await strapi2.db.connection.schema.hasColumn(tableName, columnName);
+    const cacheIsEnabled = strapi2.config.get("plugin::deep-populate").useCache === true;
+    const shouldCreateIndex = cacheIsEnabled && hasTable && hasColumn && !hasIndex;
+    const shouldRemoveIndex = hasIndex && (!cacheIsEnabled || !hasTable || !hasColumn);
+    if (shouldCreateIndex) await addDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+    if (shouldRemoveIndex) await removeDeepPopulateCacheFullTextIndex(strapi2.db, tableName, columnName);
+  });
+  strapi2.documents.use(async (context, next) => {
+    const { useCache, replaceWildcard } = strapi2.config.get("plugin::deep-populate");
+    if (
+      // do nothing if not configured
+      !useCache && !replaceWildcard || 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 = replaceWildcard && await populateIsWildcardEquivalent({ strapi: strapi2, schema: context.contentType, populate: populate2 });
+    if (useCache && 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 (useCache && context.action === "update")
+        await cacheService.clear({ ...context.params, contentType: context.uid });
+      if (useCache || 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 }) {
+    const documentService = strapi2.documents("plugin::deep-populate.cache");
+    const hash = getHash(params);
+    const entry = await documentService.findFirst({ filters: { hash: { $eq: hash } } });
+    return entry ? await documentService.update({
+      documentId: entry.documentId,
+      data: { populate: populate2, dependencies: dependencies.join(",") }
+    }) : await documentService.create({ data: { hash, 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)));
+    }
+  }
+});
 const getRelations = (model) => {
   const filteredAttributes = /* @__PURE__ */ new Set();
   const { populateCreatorFields } = contentTypes.getOptions(model);
@@ -25452,8 +25776,8 @@ async function populate$1(params) {
 }
 const populate = ({ strapi: strapi2 }) => ({
   async get(params) {
-    const { cachePopulate } = strapi2.config.get("plugin::deep-populate");
-    if (!cachePopulate) return (await populate$1(params)).populate;
+    const { useCache } = strapi2.config.get("plugin::deep-populate");
+    if (!useCache) 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);