multi-content-type-relation 0.1.0 → 2.0.1

package/dist/server/index.mjs

@@ -0,0 +1,509 @@
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const getPluginConfiguration = () => {
+  const pluginConfiguration = strapi.config.get(
+    "plugin::multi-content-type-relation"
+  );
+  return pluginConfiguration;
+};
+const log = (message) => {
+  const { debug } = getPluginConfiguration();
+  if (debug) {
+    console.log(`[MCTR DEBUG] ${message}`);
+  }
+};
+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;
+};
+const middleware = async (ctx, next) => {
+  await next();
+  if (!ctx.body) return;
+  if (!ctx.body.data) return;
+  if ([
+    "collection-types.create",
+    "collection-types.update",
+    "single-types.createOrUpdate"
+  ].includes(ctx?.state?.route?.handler)) {
+    const [, _, __, rest] = ctx?.request.url.split("/");
+    const contentType = rest.split("?")[0];
+    const isDraftAndPublish = strapi.contentTypes[contentType].options?.draftAndPublish;
+    if (isDraftAndPublish) {
+      log(`[MIDDLEWARE] ${contentType}is draft and publish`);
+      return;
+    }
+    const documentId = ctx.body.data.documentId;
+    syncMctrRelation(documentId, contentType);
+  }
+  if (["collection-types.publish", "single-types.publish"].includes(
+    ctx?.state?.route?.handler
+  )) {
+    const [, _, __, rest] = ctx?.request.url.split("/");
+    const contentType = rest.split("?")[0];
+    const documentId = ctx.body.data.documentId;
+    syncMctrRelation(documentId, contentType);
+  }
+  if (!ctx?.request?.url?.startsWith("/api")) return;
+  if (ctx.request.method !== "GET") return;
+  if (!ctx.body) return;
+  const configuration = getPluginConfiguration();
+  const handler = ctx.state.route.handler;
+  const contentTypes2 = Object.keys(strapi.contentTypes);
+  log(`[MIDDLEWARE] URL: ${ctx.request.url} (${ctx.request.method})`);
+  log(`[MIDDLEWARE] Strapi Route: ${JSON.stringify(ctx.state.route, null, 2)}`);
+  if (typeof handler !== "string") return;
+  const validHandler = contentTypes2.filter((contentType) => contentType.startsWith("api::")).some(
+    (contentType) => handler.includes(`${contentType}.findOne`) || handler.includes(`${contentType}.findMany`) || handler.includes(`${contentType}.find`)
+  );
+  log(`[MIDDLEWARE] Is valid handler: ${validHandler}`);
+  if (!validHandler) return;
+  const context = {
+    configuration,
+    publicationState: ctx.request.query?.["publicationState"] ?? "live"
+  };
+  log(`[MIDDLEWARE] Context Body: ${JSON.stringify(ctx.body, null, 2)}`);
+  if (ctx.body.error || !ctx.body?.data) 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 = /* @__PURE__ */ new Set();
+  const contentsToFetch = /* @__PURE__ */ new Set();
+  const { configuration } = context;
+  const flattenedProperties = flattenObj(content, 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.documentId)
+          continue;
+        const compositeID = `${item.uid}####${item.documentId}`;
+        eligibleProperties.add(key);
+        if (contentsToFetch.has(compositeID)) continue;
+        else contentsToFetch.add(compositeID);
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  if (!contentsToFetch.size) return content;
+  log(
+    `[MCTR HYDRATOR] Depth: ${currentDepth}, Hydrating MCTR for ID ${content.id}`
+  );
+  const promises = [];
+  for (const item of Array.from(contentsToFetch)) {
+    const [uid, documentId] = item.split("####");
+    const promise = strapi.documents(uid).findOne({ documentId, populate: "*", status: "published" }).then(async (response) => {
+      if (!response) return { uid, response };
+      if (configuration.recursive.enabled && currentDepth < configuration.recursive.maxDepth) {
+        const hydratedResponse = await hydrateMRCT(
+          response,
+          //TODO: fix me
+          currentDepth + 1,
+          context
+        );
+        return {
+          uid,
+          response: {
+            documentId: response.documentId,
+            ...hydratedResponse
+          }
+        };
+      } else {
+        return {
+          uid,
+          response: {
+            documentId: response.documentId,
+            ...response
+          }
+        };
+      }
+    });
+    promises.push(promise);
+  }
+  const linkedEntries = await Promise.all(promises);
+  const filteredLinkedEntries = linkedEntries.filter((linkedEntry) => Boolean(linkedEntry.response)).filter((linkedEntry) => {
+    const contentTypeConfiguration = strapi.contentTypes[linkedEntry.uid];
+    if (!contentTypeConfiguration) return true;
+    if (!contentTypeConfiguration.options?.draftAndPublish) return true;
+    if (context.publicationState === "preview") return true;
+    return typeof linkedEntry.response?.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.documentId === linkedEntry.response.documentId
+      );
+      if (matchingContent) {
+        hydratedArray.push(matchingContent.response);
+      }
+    }
+    flattenedProperties[key] = hydratedArray;
+  }
+  const newContent = unflatten(flattenedProperties);
+  return {
+    ...content,
+    ...newContent
+  };
+};
+const syncMctrRelation = async (documentId, uid) => {
+  const mctrDocuments = await strapi.documents("plugin::multi-content-type-relation.mctr-relation").findMany({
+    filters: {
+      sourceDocId: documentId
+    }
+  });
+  if (mctrDocuments.length !== 0) {
+    log(`[SYNC] Delete MCTR relations for ${documentId}`);
+    await Promise.all(
+      mctrDocuments.map(async ({ documentId: documentId2 }) => {
+        await strapi.documents("plugin::multi-content-type-relation.mctr-relation").delete({
+          documentId: documentId2
+        });
+      })
+    );
+  }
+  log(`[SYNC] Find document ${documentId}`);
+  const document = await strapi.documents(uid).findOne({
+    documentId
+  });
+  const contentTypeKey = Object.keys(strapi.contentTypes).find(
+    (ct) => strapi.contentTypes[ct].uid === uid
+  );
+  if (!contentTypeKey) return;
+  const contentType = strapi.contentTypes[contentTypeKey];
+  const mctrFields = Object.keys(contentType.attributes).filter(
+    (field) => contentType.attributes[field].customField === "plugin::multi-content-type-relation.multi-content-type-relation"
+  );
+  if (mctrFields.length === 0) return;
+  const targetJSON = [];
+  mctrFields.forEach(async (field) => {
+    const fieldValue = document[field];
+    if (!fieldValue) return;
+    try {
+      const mctrField = JSON.parse(fieldValue);
+      mctrField.forEach((item) => {
+        targetJSON.push(`${field}##${item.uid}##${item.documentId}`);
+      });
+    } catch (e) {
+      log(`[SYNC] Error parsing field ${field} ${fieldValue}`);
+    }
+  });
+  log(`[SYNC] Target JSON ${targetJSON}`);
+  if (targetJSON.length === 0) return;
+  await strapi.documents("plugin::multi-content-type-relation.mctr-relation").create({
+    data: {
+      sourceUID: uid,
+      sourceDocId: documentId,
+      target: targetJSON
+    }
+  });
+  log(`[SYNC] MCTR relation created for ${documentId}`);
+};
+const middlewares = {
+  middleware
+};
+const register = ({ strapi: strapi2 }) => {
+  strapi2.customFields.register({
+    name: "multi-content-type-relation",
+    plugin: "multi-content-type-relation",
+    type: "richtext"
+  });
+  strapi2.server.use(middlewares.middleware);
+};
+const config = {
+  default: ({ env }) => {
+    return {
+      recursive: {
+        enabled: false,
+        maxDepth: 1
+      },
+      debug: false
+    };
+  },
+  validator(config2) {
+    if (typeof config2.recursive !== "object") {
+      throw new Error("recursive must be an object");
+    }
+    if (typeof config2.recursive.enabled !== "boolean") {
+      throw new Error("recursive.enabled must be a boolean");
+    }
+    if (typeof config2.recursive.maxDepth !== "number") {
+      throw new Error("recursive.maxDepth must be a number");
+    }
+    if (typeof config2.debug !== "boolean") {
+      throw new Error("Debug must be a boolean");
+    }
+  }
+};
+const schema = {
+  collectionName: "mctr-relation",
+  info: {
+    singularName: "mctr-relation",
+    pluralName: "mctr-relations",
+    displayName: "MCTR Relation",
+    name: "mctr-relation"
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    sourceUID: {
+      type: "string",
+      required: true
+    },
+    sourceDocId: {
+      type: "string",
+      required: true
+    },
+    target: {
+      type: "json"
+    }
+  }
+};
+const mctrRelation = {
+  schema
+};
+const contentTypes = {
+  "mctr-relation": mctrRelation
+};
+const controller = ({ strapi: strapi2 }) => ({
+  getMatchingContent(ctx) {
+    const contentTypes2 = strapi2.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(contentTypes2).forEach((model) => {
+          const strapiContentType = contentTypes2[model];
+          if (strapiContentType.info.singularName === contentType || strapiContentType.info.pluralName === contentType) {
+            accumulator[contentType] = {
+              uid: model,
+              displayName: contentTypes2[model].info.displayName,
+              searchableField: strapi2.plugin("multi-content-type-relation").service("service").getFirstStringFieldInContentType(contentTypes2[model])
+            };
+          }
+        });
+        return accumulator;
+      },
+      {}
+    );
+    const promises = Object.keys(mapping).map((contentType) => {
+      const uid = mapping[contentType].uid;
+      return strapi2.documents(uid).findMany({
+        filters: {
+          [mapping[contentType].searchableField]: {
+            $containsi: keyword
+          }
+        },
+        locale,
+        status: "published"
+      }).then((results) => {
+        let contents = Array.isArray(results) ? results : typeof results === "object" && results ? [results] : [];
+        const contentTypeDefinition = strapi2.contentType(uid);
+        if (contentTypeDefinition?.options?.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 contentTypes2 = strapi2.contentTypes;
+    const body = ctx.request.body;
+    const entries = body.entries;
+    const promises = entries.map((entry) => {
+      return strapi2.documents(entry.uid).findOne({
+        documentId: entry.documentId,
+        populate: "*",
+        status: "published"
+      }).then((result) => {
+        return {
+          uid: entry.uid,
+          result
+        };
+      });
+    });
+    const responses = await Promise.all(promises);
+    return responses.map((response) => {
+      return {
+        displayName: contentTypes2[response.uid].info.displayName,
+        uid: response.uid,
+        searchableField: strapi2.plugin("multi-content-type-relation").service("service").getFirstStringFieldInContentType(contentTypes2[response.uid]),
+        item: response.result
+      };
+    }).filter((entry) => entry.item);
+  },
+  listContentTypes: async function() {
+    const contentTypes2 = [];
+    for (const contentType of Object.values(strapi2.contentTypes)) {
+      if ((contentType.kind === "collectionType" || contentType.kind === "singleType") && !contentType.plugin) {
+        contentTypes2.push(contentType);
+      }
+    }
+    return contentTypes2;
+  },
+  fetchRevertRelations: async function(ctx) {
+    const body = ctx.request.body;
+    let documentId = body.documentId;
+    const uid = body.uid;
+    const isSingleType = body.isSingleType;
+    if (isSingleType) {
+      const document = await strapi2.documents(uid).findFirst({
+        populate: "*",
+        status: "published"
+      });
+      if (!document) return [];
+      documentId = document.documentId;
+    }
+    const mctrRelations = await strapi2.documents("plugin::multi-content-type-relation.mctr-relation").findMany({
+      filters: {
+        target: {
+          $containsi: `${uid}##${documentId}`
+        }
+      }
+    });
+    const relations = await Promise.all(
+      mctrRelations.map(async (relation) => {
+        const sourceDocumentId = relation.sourceDocId;
+        const sourceUid = relation.sourceUID;
+        const target = relation.target.find(
+          (target2) => target2.includes(`${uid}##${documentId}`)
+        );
+        const [field] = target.split("##");
+        const contentTypeName = Object.keys(strapi2.contentTypes).find(
+          (key) => strapi2.contentTypes[key].uid === sourceUid
+        );
+        if (!contentTypeName) return null;
+        const contentType = strapi2.contentTypes[contentTypeName];
+        const document = await strapi2.documents(sourceUid).findOne({
+          documentId: sourceDocumentId,
+          populate: "*",
+          status: "published"
+        });
+        const searchableField = strapi2.plugin("multi-content-type-relation").service("service").getFirstStringFieldInContentType(contentType);
+        return {
+          title: document[searchableField],
+          uid: sourceUid,
+          isSingleType: contentType.kind === "singleType",
+          field,
+          type: contentType.info.displayName,
+          documentId: sourceDocumentId
+        };
+      })
+    );
+    return relations;
+  }
+});
+const controllers = {
+  controller
+};
+const policies = {};
+const routes = [
+  {
+    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: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/fetch-revert-relations",
+    handler: "controller.fetchRevertRelations",
+    config: {
+      policies: []
+    }
+  }
+];
+const service = ({ strapi: strapi2 }) => ({
+  getFirstStringFieldInContentType(contentType) {
+    const result = Object.keys(contentType.attributes).find(
+      (attribute) => contentType.attributes[attribute].type === "string"
+    );
+    return result;
+  }
+});
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+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,13 @@
+declare const _default: {
+    default: ({ env }: {
+        env: any;
+    }) => {
+        recursive: {
+            enabled: boolean;
+            maxDepth: number;
+        };
+        debug: boolean;
+    };
+    validator(config: any): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,35 @@
+declare const _default: {
+    'mctr-relation': {
+        schema: {
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                name: string;
+            };
+            pluginOptions: {
+                'content-manager': {
+                    visible: boolean;
+                };
+                'content-type-builder': {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                sourceUID: {
+                    type: string;
+                    required: boolean;
+                };
+                sourceDocId: {
+                    type: string;
+                    required: boolean;
+                };
+                target: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/mctr-relation/index.d.ts

@@ -0,0 +1,33 @@
+declare const _default: {
+    schema: {
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            name: string;
+        };
+        pluginOptions: {
+            'content-manager': {
+                visible: boolean;
+            };
+            'content-type-builder': {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            sourceUID: {
+                type: string;
+                required: boolean;
+            };
+            sourceDocId: {
+                type: string;
+                required: boolean;
+            };
+            target: {
+                type: string;
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/mctr-relation/schema.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    collectionName: string;
+    info: {
+        singularName: string;
+        pluralName: string;
+        displayName: string;
+        name: string;
+    };
+    pluginOptions: {
+        'content-manager': {
+            visible: boolean;
+        };
+        'content-type-builder': {
+            visible: boolean;
+        };
+    };
+    attributes: {
+        sourceUID: {
+            type: string;
+            required: boolean;
+        };
+        sourceDocId: {
+            type: string;
+            required: boolean;
+        };
+        target: {
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,27 @@
+import type { Core, UID } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getMatchingContent(ctx: any): Promise<{
+        uid: UID.ContentType;
+        displayName: string;
+        searchableField: string;
+        results: import("@strapi/types/dist/modules/documents").AnyDocument[];
+    }[]>;
+    validateRelations: (ctx: any) => Promise<{
+        displayName: any;
+        uid: string;
+        searchableField: any;
+        item: import("@strapi/types/dist/modules/documents").AnyDocument;
+    }[]>;
+    listContentTypes: () => Promise<Record<string, unknown>[]>;
+    fetchRevertRelations: (ctx: any) => Promise<{
+        title: any;
+        uid: any;
+        isSingleType: boolean;
+        field: any;
+        type: any;
+        documentId: any;
+    }[]>;
+};
+export default _default;

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

@@ -0,0 +1,28 @@
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getMatchingContent(ctx: any): Promise<{
+            uid: import("@strapi/types/dist/uid").ContentType;
+            displayName: string;
+            searchableField: string;
+            results: import("@strapi/types/dist/modules/documents").AnyDocument[];
+        }[]>;
+        validateRelations: (ctx: any) => Promise<{
+            displayName: any;
+            uid: string;
+            searchableField: any;
+            item: import("@strapi/types/dist/modules/documents").AnyDocument;
+        }[]>;
+        listContentTypes: () => Promise<Record<string, unknown>[]>;
+        fetchRevertRelations: (ctx: any) => Promise<{
+            title: any;
+            uid: any;
+            isSingleType: boolean;
+            field: any;
+            type: any;
+            documentId: any;
+        }[]>;
+    };
+};
+export default _default;

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

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

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

@@ -0,0 +1,2 @@
+export declare const flattenObj: (obj: any, parent: any, res?: Record<string, any>) => Record<string, any>;
+export declare const unflatten: (data: any) => {};