multi-content-type-relation 0.1.0

package/admin/src/hooks/useSearchedEntries.ts

@@ -0,0 +1,41 @@
+import { useEffect, useMemo, useState } from "react"
+
+import { MatchingContent } from "../interface"
+import { fetchMatchingContent } from "../helpers/content"
+
+export function useSearchedEntries(keyword: string, contentTypes: string, locale: string) {
+  const [loading, setLoading] = useState(false)
+  const [results, setResults] = useState<MatchingContent[]>([])
+  const [total, setTotal] = useState(0)
+
+  async function fetchEntries() {
+    setResults([])
+    setTotal(0)
+
+    if (loading || !keyword) return
+
+    try {
+      const { data, total } = await fetchMatchingContent(keyword, contentTypes, locale)
+
+      setResults(data)
+      setTotal(total)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    const timeout = setTimeout(() => fetchEntries(), 500)
+
+    return () => clearTimeout(timeout)
+  }, [keyword])
+
+  return useMemo(
+    () => ({
+      loading,
+      results,
+      total
+    }),
+    [results, total]
+  )
+}

package/admin/src/index.tsx

@@ -0,0 +1,140 @@
+import React, { ComponentType } from "react"
+import { prefixPluginTranslations, CustomField } from "@strapi/helper-plugin"
+
+import pluginPkg from "../../package.json"
+
+import PluginIcon from "./components/PluginIcon"
+import pluginId from "./pluginId"
+import getTrad from "./utils/getTrad"
+import { listContentTypes } from "./helpers/content"
+import { setContentTypes } from "./helpers/storage"
+
+const name = pluginPkg.strapi.name
+
+export default {
+  async register(app) {
+    const contentTypes = await listContentTypes()
+    setContentTypes(contentTypes)
+
+    app.customFields.register({
+      name,
+      pluginId,
+      type: "richtext",
+      intlLabel: {
+        id: "multi-content-type-relation.text-ai.label",
+        defaultMessage: "Multi Content Type Relation"
+      },
+      intlDescription: {
+        id: "multi-content-type-relation.text-ai.description",
+        defaultMessage: "Write content types separated by commas"
+      },
+      icon: PluginIcon, // don't forget to create/import your icon component
+      components: {
+        Input: async () =>
+          import(/* webpackChunkName: "input-component" */ "./components/Input") as unknown as ComponentType
+      },
+      inputSize: {
+        default: 12,
+        isResizable: false
+      },
+      options: {
+        base: [
+          /*
+            Declare settings to be added to the "Base settings" section
+            of the field in the Content-Type Builder
+          */
+          {
+            sectionTitle: {
+              id: "multi-content-type-relation.text-ai.length",
+              defaultMessage: "Content types"
+            },
+            items: contentTypes.map((contentType) => {
+              const value = contentType.info.singularName
+
+              return {
+                intlLabel: {
+                  id: `multi-content-type-relation.options.${contentType.uid}`,
+                  defaultMessage: contentType.info.displayName
+                },
+                type: "checkbox",
+                name: `options.contentTypes.${value}`
+              }
+            })
+          }
+        ],
+        advanced: [
+          {
+            sectionTitle: {
+              id: "global.settings",
+              defaultMessage: "Settings"
+            },
+            items: [
+              {
+                name: "required",
+                type: "checkbox",
+                intlLabel: {
+                  id: getTrad("content-type-relation-select.options.advanced.requiredField"),
+                  defaultMessage: "Required field"
+                },
+                description: {
+                  id: getTrad("content-type-relation-select.options.advanced.requiredField.description"),
+                  defaultMessage: "You won't be able to create an entry if this field is empty"
+                }
+              },
+              {
+                name: "options.min",
+                type: "number",
+                intlLabel: {
+                  id: getTrad("content-type-relation-select.options.advanced.minField"),
+                  defaultMessage: "Minimum values"
+                },
+                description: {
+                  id: getTrad("content-type-relation-select.options.advanced.minField.description"),
+                  defaultMessage: "Minimum number of entries"
+                }
+              },
+              {
+                name: "options.max",
+                type: "number",
+                intlLabel: {
+                  id: getTrad("content-type-relation-select.options.advanced.maxField"),
+                  defaultMessage: "Maximum values"
+                },
+                description: {
+                  id: getTrad("content-type-relation-select.options.advanced.maxField.description"),
+                  defaultMessage: "Maximum number of entries"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    } as CustomField)
+  },
+
+  bootstrap(app: any) {},
+
+  async registerTrads(app: any) {
+    const { locales } = app
+
+    const importedTrads = await Promise.all(
+      (locales as any[]).map((locale) => {
+        return import(`./translations/${locale}.json`)
+          .then(({ default: data }) => {
+            return {
+              data: prefixPluginTranslations(data, pluginId),
+              locale
+            }
+          })
+          .catch(() => {
+            return {
+              data: {},
+              locale
+            }
+          })
+      })
+    )
+
+    return Promise.resolve(importedTrads)
+  }
+}

package/admin/src/interface.ts

@@ -0,0 +1,37 @@
+export type PluginOption = {
+  options: {
+    min: number
+    max: number
+    contentTypes: string
+  }
+}
+
+export type MatchingContent = {
+  uid: string
+  displayName: string
+  searchableField: string
+  results: {
+    id: string
+    [key: string]: any
+  }[]
+}
+
+export type MatchingContentResponse = {
+  data: MatchingContent[]
+  total: number
+}
+
+export type SelectedEntry = {
+  displayName: string
+  searchableField: string
+  uid: string
+  item: {
+    id: string
+    [key: string]: any
+  }
+}
+
+export type FormattedStrapiEntry = {
+  uid: string
+  id: string
+}

package/admin/src/pluginId.ts

@@ -0,0 +1,5 @@
+import pluginPkg from '../../package.json';
+
+const pluginId = pluginPkg.name.replace(/^(@[^-,.][\w,-]+\/|strapi-)plugin-/i, '');
+
+export default pluginId;

package/admin/src/translations/en.json

@@ -0,0 +1 @@
+{}

package/admin/src/translations/fr.json

@@ -0,0 +1 @@
+{}

package/admin/src/utils/getTrad.ts

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = (id: string) => `${pluginId}.${id}`;
+
+export default getTrad;

package/dist/server/bootstrap.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
+    // bootstrap phase
+};

package/dist/server/config/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    default: ({ env }) => {
+        return {
+            recursive: {
+                enabled: false,
+                maxDepth: 1
+            },
+            debug: false
+        };
+    },
+    validator(config) {
+        if (typeof config.recursive !== "object") {
+            throw new Error("recursive must be an object");
+        }
+        if (typeof config.recursive.enabled !== "boolean") {
+            throw new Error("recursive.enabled must be a boolean");
+        }
+        if (typeof config.recursive.maxDepth !== "number") {
+            throw new Error("recursive.maxDepth must be a number");
+        }
+        if (typeof config.debug !== "boolean") {
+            throw new Error("Debug must be a boolean");
+        }
+    }
+};

package/dist/server/content-types/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {};

package/dist/server/controllers/controller.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => ({
+    getMatchingContent(ctx) {
+        const contentTypes = strapi.contentTypes;
+        const body = ctx.request.body;
+        const requestedContentTypes = body.contentTypes;
+        const keyword = body.keyword;
+        const locale = body.locale;
+        const mapping = requestedContentTypes.reduce((accumulator, contentType) => {
+            Object.keys(contentTypes).forEach((model) => {
+                const strapiContentType = contentTypes[model];
+                if (strapiContentType.info.singularName === contentType || strapiContentType.info.pluralName === contentType) {
+                    accumulator[contentType] = {
+                        uid: model,
+                        displayName: contentTypes[model].info.displayName,
+                        searchableField: strapi
+                            .plugin("multi-content-type-relation")
+                            .service("service")
+                            .getFirstStringFieldInContentType(contentTypes[model])
+                    };
+                }
+            });
+            return accumulator;
+        }, {});
+        const promises = Object.keys(mapping).map((contentType) => {
+            const uid = mapping[contentType].uid;
+            return strapi
+                .entityService.findMany(uid, {
+                filters: {
+                    [mapping[contentType].searchableField]: {
+                        $containsi: keyword
+                    }
+                },
+                locale
+            })
+                .then((results) => {
+                var _a;
+                let contents = Array.isArray(results) ? results : typeof results === "object" && results ? [results] : [];
+                const contentTypeDefinition = strapi.contentType(uid);
+                if ((_a = contentTypeDefinition === null || contentTypeDefinition === void 0 ? void 0 : contentTypeDefinition.options) === null || _a === void 0 ? void 0 : _a.draftAndPublish) {
+                    contents = contents.filter((content) => content.publishedAt !== null);
+                }
+                return {
+                    uid,
+                    displayName: mapping[contentType].displayName,
+                    searchableField: mapping[contentType].searchableField,
+                    results: contents
+                };
+            });
+        });
+        return Promise.all(promises);
+    },
+    validateRelations: async function (ctx) {
+        const contentTypes = strapi.contentTypes;
+        const body = ctx.request.body;
+        const entries = body.entries;
+        const promises = entries.map((entry) => {
+            return strapi
+                .entityService.findOne(entry.uid, entry.id, { populate: "deep" })
+                .then((result) => {
+                return {
+                    uid: entry.uid,
+                    result
+                };
+            });
+        });
+        const responses = await Promise.all(promises);
+        return responses
+            .map((response) => {
+            return {
+                displayName: contentTypes[response.uid].info.displayName,
+                uid: response.uid,
+                searchableField: strapi
+                    .plugin("multi-content-type-relation")
+                    .service("service")
+                    .getFirstStringFieldInContentType(contentTypes[response.uid]),
+                item: response.result
+            };
+        })
+            .filter((entry) => entry.item);
+    },
+    listContentTypes: async function (ctx) {
+        const contentTypes = [];
+        for (const contentType of Object.values(strapi.contentTypes)) {
+            if ((contentType.kind === "collectionType" || contentType.kind === "singleType") && !contentType.plugin) {
+                contentTypes.push(contentType);
+            }
+        }
+        return contentTypes;
+    }
+});

package/dist/server/controllers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const controller_1 = __importDefault(require("./controller"));
+exports.default = {
+    controller: controller_1.default
+};

package/dist/server/destroy.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
+    // destroy phase
+};

package/dist/server/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const register_1 = __importDefault(require("./register"));
+const bootstrap_1 = __importDefault(require("./bootstrap"));
+const destroy_1 = __importDefault(require("./destroy"));
+const config_1 = __importDefault(require("./config"));
+const content_types_1 = __importDefault(require("./content-types"));
+const controllers_1 = __importDefault(require("./controllers"));
+const routes_1 = __importDefault(require("./routes"));
+const middlewares_1 = __importDefault(require("./middlewares"));
+const policies_1 = __importDefault(require("./policies"));
+const services_1 = __importDefault(require("./services"));
+exports.default = {
+    register: register_1.default,
+    bootstrap: bootstrap_1.default,
+    destroy: destroy_1.default,
+    config: config_1.default,
+    controllers: controllers_1.default,
+    routes: routes_1.default,
+    services: services_1.default,
+    contentTypes: content_types_1.default,
+    policies: policies_1.default,
+    middlewares: middlewares_1.default,
+};

package/dist/server/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/middlewares/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = __importDefault(require("./middleware"));
+exports.default = {
+    middleware: middleware_1.default
+};

package/dist/server/middlewares/middleware.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = async (ctx, next) => {
+    var _a, _b, _c, _d, _e;
+    await next();
+    if (!((_b = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.request) === null || _a === void 0 ? void 0 : _a.url) === null || _b === void 0 ? void 0 : _b.startsWith("/api")))
+        return;
+    if (ctx.request.method !== "GET")
+        return;
+    if (!ctx.body)
+        return;
+    const configuration = (0, utils_1.getPluginConfiguration)();
+    const handler = ctx.state.route.handler;
+    const contentTypes = Object.keys(strapi.contentTypes);
+    (0, utils_1.log)(`URL: ${ctx.request.url} (${ctx.request.method})`);
+    (0, utils_1.log)(`Strapi Route: ${JSON.stringify(ctx.state.route, null, 2)}`);
+    const validHandler = contentTypes
+        .filter((contentType) => contentType.startsWith("api::"))
+        .some((contentType) => handler.includes(`${contentType}.findOne`) ||
+        handler.includes(`${contentType}.findMany`) ||
+        handler.includes(`${contentType}.find`));
+    (0, utils_1.log)(`Is valid handler: ${validHandler}`);
+    // Allow only findOne/findMany for native contentypes that have api::
+    if (!validHandler)
+        return;
+    const context = {
+        configuration,
+        publicationState: (_d = (_c = ctx.request.query) === null || _c === void 0 ? void 0 : _c["publicationState"]) !== null && _d !== void 0 ? _d : "live"
+    };
+    (0, utils_1.log)(" ----- ");
+    (0, utils_1.log)(`Context Body: ${JSON.stringify(ctx.body, null, 2)}`);
+    if (ctx.body.error || !((_e = ctx.body) === null || _e === void 0 ? void 0 : _e.data.attributes))
+        return;
+    const hydratedData = await augmentMRCT(ctx.body, 1, context);
+    ctx.body.data = hydratedData;
+};
+const augmentMRCT = async (strapiResponse, currentDepth, context) => {
+    if (Array.isArray(strapiResponse.data)) {
+        const promises = strapiResponse.data.map((item) => hydrateMRCT(item, currentDepth, context));
+        return await Promise.all(promises);
+    }
+    else {
+        return await hydrateMRCT(strapiResponse.data, currentDepth, context);
+    }
+};
+const hydrateMRCT = async (content, currentDepth, context) => {
+    const eligibleProperties = new Set();
+    const contentsToFetch = new Set();
+    const { configuration } = context;
+    const flattenedProperties = flattenObj(content.attributes, null);
+    for (const [key, value] of Object.entries(flattenedProperties)) {
+        if (typeof value !== "string" || !value.includes("MRCT"))
+            continue;
+        try {
+            const field = JSON.parse(value);
+            if (!Array.isArray(field))
+                continue;
+            for (const item of field) {
+                if (Object.keys(item).length !== 3 || (!item.uid && typeof item.uid !== "string") || !item.id)
+                    continue;
+                const compositeID = `${item.uid}####${item.id}`;
+                eligibleProperties.add(key);
+                if (contentsToFetch.has(compositeID))
+                    continue;
+                else
+                    contentsToFetch.add(compositeID);
+            }
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    if (!contentsToFetch.size)
+        return content;
+    (0, utils_1.log)(`Depth: ${currentDepth}, Hydrating MCTR for ID ${content.id}`);
+    const promises = [];
+    for (const item of Array.from(contentsToFetch)) {
+        const [uid, id] = item.split("####");
+        const promise = strapi.entityService
+            .findOne(uid, id, { populate: "deep" })
+            .then(async (response) => {
+            if (!response)
+                return { uid, response };
+            if (configuration.recursive.enabled && currentDepth < configuration.recursive.maxDepth) {
+                // Entity service serve the content flattened, so we need to rebuild the API format for the hydrate recursion
+                const hydratedResponse = await hydrateMRCT({
+                    id: response.id,
+                    attributes: response
+                }, currentDepth + 1, context);
+                return {
+                    uid,
+                    response: {
+                        id: response.id,
+                        attributes: hydratedResponse.attributes
+                    }
+                };
+            }
+            else {
+                return {
+                    uid,
+                    response: {
+                        id: response.id,
+                        attributes: response
+                    }
+                };
+            }
+        });
+        promises.push(promise);
+    }
+    const linkedEntries = await Promise.all(promises);
+    const filteredLinkedEntries = linkedEntries
+        .filter((linkedEntry) => Boolean(linkedEntry.response))
+        .filter((linkedEntry) => {
+        var _a, _b;
+        const contentTypeConfiguration = strapi.contentTypes[linkedEntry.uid];
+        if (!contentTypeConfiguration)
+            return true;
+        if (!((_a = contentTypeConfiguration.options) === null || _a === void 0 ? void 0 : _a.draftAndPublish))
+            return true;
+        if (context.publicationState === "preview")
+            return true;
+        return typeof ((_b = linkedEntry.response) === null || _b === void 0 ? void 0 : _b.attributes.publishedAt) === "string";
+    });
+    for (const key of Array.from(eligibleProperties)) {
+        const hydratedArray = [];
+        const unhydratedField = JSON.parse(flattenedProperties[key]);
+        for (const item of unhydratedField) {
+            const matchingContent = filteredLinkedEntries.find((linkedEntry) => item.uid === linkedEntry.uid && item.id === linkedEntry.response.id);
+            if (matchingContent) {
+                hydratedArray.push(matchingContent.response);
+            }
+        }
+        flattenedProperties[key] = hydratedArray;
+    }
+    const newContent = unflatten(flattenedProperties);
+    return {
+        ...content,
+        attributes: newContent
+    };
+};
+const flattenObj = (obj, parent, res = {}) => {
+    for (let key in obj) {
+        let propName = parent ? parent + "." + key : key;
+        if (typeof obj[key] == "object") {
+            flattenObj(obj[key], propName, res);
+        }
+        else {
+            res[propName] = obj[key];
+        }
+    }
+    return res;
+};
+const unflatten = (data) => {
+    var result = {};
+    for (var i in data) {
+        var keys = i.split(".");
+        keys.reduce(function (r, e, j) {
+            return r[e] || (r[e] = isNaN(Number(keys[j + 1])) ? (keys.length - 1 == j ? data[i] : {}) : []);
+        }, result);
+    }
+    return result;
+};

package/dist/server/policies/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {};

package/dist/server/register.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const middlewares_1 = __importDefault(require("./middlewares"));
+exports.default = ({ strapi }) => {
+    // register phase
+    strapi.customFields.register({
+        name: "multi-content-type-relation",
+        plugin: "multi-content-type-relation",
+        type: "richtext"
+    });
+    strapi.server.use(middlewares_1.default.middleware);
+};

package/dist/server/routes/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        method: "GET",
+        path: "/list-content-types",
+        handler: "controller.listContentTypes",
+        config: {
+            policies: [],
+            auth: false
+        }
+    },
+    {
+        method: "POST",
+        path: "/get-content",
+        handler: "controller.getMatchingContent",
+        config: {
+            policies: []
+        }
+    },
+    {
+        method: "POST",
+        path: "/validate-relations",
+        handler: "controller.validateRelations",
+        config: {
+            policies: []
+        }
+    }
+];

package/dist/server/services/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = __importDefault(require("./service"));
+exports.default = {
+    service: service_1.default
+};

package/dist/server/services/service.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => ({
+    getFirstStringFieldInContentType(contentType) {
+        const result = Object.keys(contentType.attributes).find((attribute) => contentType.attributes[attribute].type === "string");
+        return result;
+    }
+});