strapi-plugin-populate-all 1.0.0

package/README.md

@@ -0,0 +1,43 @@
+# Strapi Plugin Populate All
+
+A lightweight Strapi plugin that enables you to **recursively populate** all nested components, dynamic zones and relations in your REST API responses using a simple query parameter: `?populate=all`.
+
+## Features
+
+- Use `?populate=all` in your API requests to automatically and deeply populate all nested relations, components, and dynamic zones for any content type.
+- Fine-tune which relations are populated using plugin configuration.
+- The generated populate queries are cached, so repeated REST requests for the same model are faster.
+
+## Usage
+
+Just add `?populate=all` to your REST API request, for example: `GET /api/articles?populate=all`
+This will return the article with all nested components, dynamic zones and relations fully populated, regardless of depth.
+
+## Configuration
+
+You can configure which relations should be populated by default.  
+Add the following to your Strapi project's `config/plugins.js` (or `config/plugins.ts`):
+
+```js
+module.exports = {
+  'populate-all': {
+    enabled: true,
+    config: {
+      // Populate all relations recursively (default)
+      relations: true,
+
+      // OR: Do not populate any relations
+      relations: false,
+
+      // OR: Only populate specific collection types by UID
+      relations: ['api::article.article', 'api::category.category'],
+    },
+  },
+};
+```
+
+## How it works
+
+- The plugin provides a global middleware that intercepts requests with `?populate=all` and rewrites the query to trigger recursive population.
+- In the background, it builds a standard Strapi populate query as described in the [Strapi documentation](https://docs.strapi.io/cms/api/rest/populate-select).
+- You can control which relations are included using the relations config option.

package/dist/server/index.js

@@ -0,0 +1,105 @@
+"use strict";
+const config = {
+  default: {
+    relations: true
+  },
+  validator(config2) {
+    const isBoolean = typeof config2?.relations === "boolean";
+    const isArrayOfStrings = Array.isArray(config2?.relations) && config2?.relations?.every((relation) => typeof relation === "string");
+    if (!(isBoolean || isArrayOfStrings)) {
+      throw new Error(
+        `[populate-all] config "relations" of type ${typeof config2?.relation} is not valid. Supported are boolean or Array of strings.`
+      );
+    }
+  }
+};
+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 queryCache = {};
+const getPopulateQuery = (modelUid) => {
+  try {
+    if (queryCache[modelUid]) {
+      strapi.log.debug(`[populate-all] query cache hit: ${modelUid}`);
+      return queryCache[modelUid];
+    }
+    const query = { populate: {} };
+    const model = strapi.getModel(modelUid);
+    for (const fieldName in model.attributes) {
+      const attribute = model.attributes[fieldName];
+      if (fieldName === "localizations") {
+        continue;
+      }
+      if (attribute.type === "dynamiczone") {
+        const components = Object.fromEntries(
+          attribute.components.map((component) => [component, getPopulateQuery(component)])
+        );
+        query.populate[fieldName] = { on: components };
+        continue;
+      }
+      if (attribute.type === "component") {
+        query.populate[fieldName] = getPopulateQuery(attribute.component);
+        continue;
+      }
+      if (attribute.type === "relation") {
+        const relations = strapi.plugin("populate-all").config("relations");
+        strapi.log.debug(`[populate-all] relations to populate ${JSON.stringify(relations)}`);
+        if (relations === true) {
+          query.populate[fieldName] = getPopulateQuery(attribute.target);
+          continue;
+        }
+        if (Array.isArray(relations) && relations.includes(attribute.target)) {
+          query.populate[fieldName] = getPopulateQuery(attribute.target);
+          continue;
+        }
+      }
+      if (attribute.type === "media") {
+        query.populate[fieldName] = { populate: true };
+        continue;
+      }
+    }
+    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) {
+    strapi.log.error(`[populate-all] getPopulateQuery(${modelUid}) failed: ${error}`);
+    return void 0;
+  }
+};
+const bootstrap = ({ strapi: strapi2 }) => {
+  strapi2.db.lifecycles.subscribe((event) => {
+    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;
+        }
+      }
+    }
+  });
+};
+const index = {
+  config,
+  register,
+  bootstrap
+};
+module.exports = index;

package/dist/server/index.mjs

@@ -0,0 +1,106 @@
+const config = {
+  default: {
+    relations: true
+  },
+  validator(config2) {
+    const isBoolean = typeof config2?.relations === "boolean";
+    const isArrayOfStrings = Array.isArray(config2?.relations) && config2?.relations?.every((relation) => typeof relation === "string");
+    if (!(isBoolean || isArrayOfStrings)) {
+      throw new Error(
+        `[populate-all] config "relations" of type ${typeof config2?.relation} is not valid. Supported are boolean or Array of strings.`
+      );
+    }
+  }
+};
+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 queryCache = {};
+const getPopulateQuery = (modelUid) => {
+  try {
+    if (queryCache[modelUid]) {
+      strapi.log.debug(`[populate-all] query cache hit: ${modelUid}`);
+      return queryCache[modelUid];
+    }
+    const query = { populate: {} };
+    const model = strapi.getModel(modelUid);
+    for (const fieldName in model.attributes) {
+      const attribute = model.attributes[fieldName];
+      if (fieldName === "localizations") {
+        continue;
+      }
+      if (attribute.type === "dynamiczone") {
+        const components = Object.fromEntries(
+          attribute.components.map((component) => [component, getPopulateQuery(component)])
+        );
+        query.populate[fieldName] = { on: components };
+        continue;
+      }
+      if (attribute.type === "component") {
+        query.populate[fieldName] = getPopulateQuery(attribute.component);
+        continue;
+      }
+      if (attribute.type === "relation") {
+        const relations = strapi.plugin("populate-all").config("relations");
+        strapi.log.debug(`[populate-all] relations to populate ${JSON.stringify(relations)}`);
+        if (relations === true) {
+          query.populate[fieldName] = getPopulateQuery(attribute.target);
+          continue;
+        }
+        if (Array.isArray(relations) && relations.includes(attribute.target)) {
+          query.populate[fieldName] = getPopulateQuery(attribute.target);
+          continue;
+        }
+      }
+      if (attribute.type === "media") {
+        query.populate[fieldName] = { populate: true };
+        continue;
+      }
+    }
+    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) {
+    strapi.log.error(`[populate-all] getPopulateQuery(${modelUid}) failed: ${error}`);
+    return void 0;
+  }
+};
+const bootstrap = ({ strapi: strapi2 }) => {
+  strapi2.db.lifecycles.subscribe((event) => {
+    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;
+        }
+      }
+    }
+  });
+};
+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: any): void;
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+declare const _default: {
+    config: {
+        default: {
+            relations: boolean;
+        };
+        validator(config: any): 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) => {
+    populate: object | true;
+} | undefined;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "version": "1.0.0",
+  "name": "strapi-plugin-populate-all",
+  "description": "A lightweight plugin to recursively populate nested data in RESTful API requests",
+  "keywords": [],
+  "license": "MIT",
+  "author": "Jan Fässler <strapi-plugin-populate-all@faessler.be>",
+  "type": "commonjs",
+  "homepage": "https://github.com/faessler/strapi-plugin-populate-all#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faessler/strapi-plugin-populate-all.git"
+  },
+  "bugs": {
+    "url": "https://github.com/faessler/strapi-plugin-populate-all/issues"
+  },
+  "strapi": {
+    "kind": "plugin",
+    "name": "populate-all",
+    "displayName": "Strapi Plugin Populate All",
+    "description": "A lightweight plugin to recursively populate nested data in RESTful API requests"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./strapi-server": {
+      "types": "./dist/server/src/index.d.ts",
+      "source": "./server/src/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch",
+    "watch:link": "strapi-plugin watch:link",
+    "verify": "strapi-plugin verify",
+    "test:ts:back": "run -T tsc -p server/tsconfig.json"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@strapi/strapi": "^5.13.1",
+    "@strapi/sdk-plugin": "^5.3.2",
+    "prettier": "^3.5.3",
+    "@strapi/typescript-utils": "^5.13.1",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^5.13.1",
+    "@strapi/sdk-plugin": "^5.3.2"
+  }
+}