strapi-plugin-populate-all 1.2.1 → 1.2.2

package/dist/server/index.js

@@ -0,0 +1,151 @@
+"use strict";
+const queryCache = {};
+const getPopulateQuery = (modelUid, parentsModelUids = []) => {
+  try {
+    if (queryCache[modelUid]) {
+      strapi.log.debug(`[populate-all] query cache hit: ${modelUid}`);
+      return queryCache[modelUid];
+    }
+    if (parentsModelUids.includes(modelUid)) {
+      strapi.log.debug(
+        `[populate-all] loop detected skipping population: ${modelUid}`
+      );
+      return { populate: {} };
+    } else {
+      parentsModelUids.push(modelUid);
+    }
+    const query = { populate: {} };
+    const model = strapi.getModel(modelUid);
+    for (const [fieldName, attribute] of Object.entries(
+      model.attributes || {}
+    )) {
+      if (fieldName === "localizations") {
+        query.populate[fieldName] = true;
+        continue;
+      }
+      if (attribute.type === "dynamiczone") {
+        const components = Object.fromEntries(
+          attribute.components.map((component) => [
+            component,
+            getPopulateQuery(component, parentsModelUids)
+          ])
+        );
+        query.populate[fieldName] = { on: components };
+        continue;
+      }
+      if (attribute.type === "component") {
+        query.populate[fieldName] = getPopulateQuery(
+          attribute.component,
+          parentsModelUids
+        );
+        continue;
+      }
+      if (attribute.type === "relation") {
+        if (attribute.private === true) {
+          continue;
+        }
+        const relations = strapi.plugin("populate-all").config("relations");
+        if (relations === true) {
+          query.populate[fieldName] = getPopulateQuery(
+            // @ts-expect-error target actually exists on attribute
+            attribute.target,
+            parentsModelUids
+          );
+          continue;
+        }
+        if (Array.isArray(relations) && relations.includes(attribute.target)) {
+          query.populate[fieldName] = getPopulateQuery(
+            // @ts-expect-error target actually exists on attribute
+            attribute.target,
+            parentsModelUids
+          );
+          continue;
+        }
+      }
+      if (attribute.type === "media") {
+        query.populate[fieldName] = true;
+      }
+    }
+    if (Object.keys(query.populate).length === 0) {
+      query.populate = true;
+    }
+    strapi.log.debug(`[populate-all] new query cached: ${modelUid}`);
+    queryCache[modelUid] = query;
+    return query;
+  } catch (error) {
+    console.error(
+      `[populate-all] getPopulateQuery(${modelUid}) failed: ${error}`
+    );
+    return void 0;
+  }
+};
+const bootstrap = ({ strapi: strapi2 }) => {
+  strapi2.db.lifecycles.subscribe((event) => {
+    try {
+      if (event.params?.recursive === "true") {
+        if (event.action === "beforeFindMany" || event.action === "beforeFindOne") {
+          strapi2.log.debug(
+            `[populate-all] recursively populate ${event.model.uid}`
+          );
+          const populateQuery = getPopulateQuery(event.model.uid);
+          if (populateQuery?.populate) {
+            event.params.populate = populateQuery.populate;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[populate-all] failed to apply populate db query: ${error}`
+      );
+    }
+  });
+};
+const config = {
+  default: {
+    relations: true
+  },
+  validator(config2 = {}) {
+    for (const [key, value] of Object.entries(config2)) {
+      switch (key) {
+        case "relations": {
+          const isBoolean = typeof value === "boolean";
+          const isArrayOfStrings = Array.isArray(value) && value?.every((relation) => typeof relation === "string");
+          if (!(isBoolean || isArrayOfStrings)) {
+            throw new Error(
+              `[populate-all] config "${key}" of type ${typeof value} is not valid. Supported are boolean or Array of strings.`
+            );
+          }
+          break;
+        }
+        default:
+          strapi.log.warn(
+            `[populate-all] unknown config "${key}" provided. This config will be ignored.`
+          );
+      }
+    }
+  }
+};
+const middlewares = {
+  /**
+   * This is a global middleware to add support for the custom query param `?populate=all`.
+   * Since Strapi's validator does not allow custom values for the populate param, we intercept the request here.
+   * If `?populate=all` is detected, we omit the value and set `?recursive=true` instead.
+   * The bootstrap script later picks up `?recursive=true` to apply the desired populate logic.
+   */
+  populateAll: async (ctx, next) => {
+    if (ctx.query.populate === "all") {
+      ctx.query.populate = void 0;
+      ctx.query.recursive = "true";
+    }
+    await next();
+  }
+};
+const register = ({ strapi: strapi2 }) => {
+  strapi2.server.use(middlewares.populateAll);
+};
+const index = {
+  config,
+  register,
+  bootstrap
+};
+module.exports = index;

package/dist/server/index.mjs

@@ -0,0 +1,152 @@
+const queryCache = {};
+const getPopulateQuery = (modelUid, parentsModelUids = []) => {
+  try {
+    if (queryCache[modelUid]) {
+      strapi.log.debug(`[populate-all] query cache hit: ${modelUid}`);
+      return queryCache[modelUid];
+    }
+    if (parentsModelUids.includes(modelUid)) {
+      strapi.log.debug(
+        `[populate-all] loop detected skipping population: ${modelUid}`
+      );
+      return { populate: {} };
+    } else {
+      parentsModelUids.push(modelUid);
+    }
+    const query = { populate: {} };
+    const model = strapi.getModel(modelUid);
+    for (const [fieldName, attribute] of Object.entries(
+      model.attributes || {}
+    )) {
+      if (fieldName === "localizations") {
+        query.populate[fieldName] = true;
+        continue;
+      }
+      if (attribute.type === "dynamiczone") {
+        const components = Object.fromEntries(
+          attribute.components.map((component) => [
+            component,
+            getPopulateQuery(component, parentsModelUids)
+          ])
+        );
+        query.populate[fieldName] = { on: components };
+        continue;
+      }
+      if (attribute.type === "component") {
+        query.populate[fieldName] = getPopulateQuery(
+          attribute.component,
+          parentsModelUids
+        );
+        continue;
+      }
+      if (attribute.type === "relation") {
+        if (attribute.private === true) {
+          continue;
+        }
+        const relations = strapi.plugin("populate-all").config("relations");
+        if (relations === true) {
+          query.populate[fieldName] = getPopulateQuery(
+            // @ts-expect-error target actually exists on attribute
+            attribute.target,
+            parentsModelUids
+          );
+          continue;
+        }
+        if (Array.isArray(relations) && relations.includes(attribute.target)) {
+          query.populate[fieldName] = getPopulateQuery(
+            // @ts-expect-error target actually exists on attribute
+            attribute.target,
+            parentsModelUids
+          );
+          continue;
+        }
+      }
+      if (attribute.type === "media") {
+        query.populate[fieldName] = true;
+      }
+    }
+    if (Object.keys(query.populate).length === 0) {
+      query.populate = true;
+    }
+    strapi.log.debug(`[populate-all] new query cached: ${modelUid}`);
+    queryCache[modelUid] = query;
+    return query;
+  } catch (error) {
+    console.error(
+      `[populate-all] getPopulateQuery(${modelUid}) failed: ${error}`
+    );
+    return void 0;
+  }
+};
+const bootstrap = ({ strapi: strapi2 }) => {
+  strapi2.db.lifecycles.subscribe((event) => {
+    try {
+      if (event.params?.recursive === "true") {
+        if (event.action === "beforeFindMany" || event.action === "beforeFindOne") {
+          strapi2.log.debug(
+            `[populate-all] recursively populate ${event.model.uid}`
+          );
+          const populateQuery = getPopulateQuery(event.model.uid);
+          if (populateQuery?.populate) {
+            event.params.populate = populateQuery.populate;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[populate-all] failed to apply populate db query: ${error}`
+      );
+    }
+  });
+};
+const config = {
+  default: {
+    relations: true
+  },
+  validator(config2 = {}) {
+    for (const [key, value] of Object.entries(config2)) {
+      switch (key) {
+        case "relations": {
+          const isBoolean = typeof value === "boolean";
+          const isArrayOfStrings = Array.isArray(value) && value?.every((relation) => typeof relation === "string");
+          if (!(isBoolean || isArrayOfStrings)) {
+            throw new Error(
+              `[populate-all] config "${key}" of type ${typeof value} is not valid. Supported are boolean or Array of strings.`
+            );
+          }
+          break;
+        }
+        default:
+          strapi.log.warn(
+            `[populate-all] unknown config "${key}" provided. This config will be ignored.`
+          );
+      }
+    }
+  }
+};
+const middlewares = {
+  /**
+   * This is a global middleware to add support for the custom query param `?populate=all`.
+   * Since Strapi's validator does not allow custom values for the populate param, we intercept the request here.
+   * If `?populate=all` is detected, we omit the value and set `?recursive=true` instead.
+   * The bootstrap script later picks up `?recursive=true` to apply the desired populate logic.
+   */
+  populateAll: async (ctx, next) => {
+    if (ctx.query.populate === "all") {
+      ctx.query.populate = void 0;
+      ctx.query.recursive = "true";
+    }
+    await next();
+  }
+};
+const register = ({ strapi: strapi2 }) => {
+  strapi2.server.use(middlewares.populateAll);
+};
+const index = {
+  config,
+  register,
+  bootstrap
+};
+export {
+  index as default
+};

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

@@ -0,0 +1,5 @@
+import type { Core } from "@strapi/strapi";
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    default: {
+        relations: boolean;
+    };
+    validator(config?: Record<string, unknown>): void;
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+declare const _default: {
+    config: {
+        default: {
+            relations: boolean;
+        };
+        validator(config?: Record<string, unknown>): void;
+    };
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+};
+export default _default;

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

@@ -0,0 +1,10 @@
+declare const _default: {
+    /**
+     * This is a global middleware to add support for the custom query param `?populate=all`.
+     * Since Strapi's validator does not allow custom values for the populate param, we intercept the request here.
+     * If `?populate=all` is detected, we omit the value and set `?recursive=true` instead.
+     * The bootstrap script later picks up `?recursive=true` to apply the desired populate logic.
+     */
+    populateAll: (ctx: any, next: any) => Promise<void>;
+};
+export default _default;

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

@@ -0,0 +1,5 @@
+import type { Core } from "@strapi/strapi";
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/utils/getPopulateQuery.d.ts

@@ -0,0 +1,4 @@
+import type { UID } from "@strapi/strapi";
+export declare const getPopulateQuery: (modelUid: UID.Schema, parentsModelUids?: UID.Schema[]) => {
+    populate: object | true;
+} | undefined;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.1",
+  "version": "1.2.2",
   "name": "strapi-plugin-populate-all",
   "description": "A lightweight plugin to recursively populate nested data in RESTful API requests",
   "keywords": [],