multi-content-type-relation 0.1.0 → 2.1.0

package/server/controllers/controller.ts

@@ -1,107 +0,0 @@
-import { Strapi } from "@strapi/strapi"
-import type { Common } from "@strapi/strapi"
-import { FormattedStrapiEntry } from "../interface"
-
-export default ({ strapi }: { strapi: Strapi }) => ({
-  getMatchingContent(ctx) {
-    const contentTypes = strapi.contentTypes
-    const body = ctx.request.body
-
-    const requestedContentTypes = body.contentTypes as string[]
-    const keyword = body.keyword as string
-    const locale = body.locale as string
-
-    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
-    }, {} as Record<string, { uid: string; displayName: string; searchableField: string }>)
-
-    const promises = Object.keys(mapping).map((contentType) => {
-      const uid = mapping[contentType].uid
-
-      return strapi
-        .entityService!.findMany(uid as Common.UID.ContentType, {
-          filters: {
-            [mapping[contentType].searchableField]: {
-              $containsi: keyword
-            }
-          },
-          locale
-        })
-        .then((results) => {
-          let contents = Array.isArray(results) ? results : typeof results === "object" && results ? [results] : []
-
-          const contentTypeDefinition = strapi.contentType(uid as Common.UID.ContentType)
-          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 contentTypes = strapi.contentTypes
-    const body = ctx.request.body
-
-    const entries = body.entries as FormattedStrapiEntry[]
-
-    const promises = entries.map((entry) => {
-      return strapi
-        .entityService!.findOne(entry.uid as Common.UID.ContentType, 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: Record<string, unknown>[] = []
-
-    for (const contentType of Object.values(strapi.contentTypes) as { kind: string; plugin: boolean }[]) {
-      if ((contentType.kind === "collectionType" || contentType.kind === "singleType") && !contentType.plugin) {
-        contentTypes.push(contentType as Record<string, unknown>)
-      }
-    }
-
-    return contentTypes
-  }
-})

package/server/controllers/index.ts

@@ -1,5 +0,0 @@
-import controller from "./controller"
-
-export default {
-  controller
-}

package/server/destroy.ts

@@ -1,5 +0,0 @@
-import { Strapi } from '@strapi/strapi';
-
-export default ({ strapi }: { strapi: Strapi }) => {
-  // destroy phase
-};

package/server/index.ts

@@ -1,23 +0,0 @@
-import register from './register';
-import bootstrap from './bootstrap';
-import destroy from './destroy';
-import config from './config';
-import contentTypes from './content-types';
-import controllers from './controllers';
-import routes from './routes';
-import middlewares from './middlewares';
-import policies from './policies';
-import services from './services';
-
-export default {
-  register,
-  bootstrap,
-  destroy,
-  config,
-  controllers,
-  routes,
-  services,
-  contentTypes,
-  policies,
-  middlewares,
-};

package/server/interface.ts

@@ -1,50 +0,0 @@
-export type StrapiContentTypeDefinition = {
-  collectionName: string
-  info: {
-    name: string
-    description: string
-    singularName: string
-    pluralName: string
-    displayName: string
-  }
-  attributes: Record<string, unknown>
-}
-
-export type SelectedEntry = {
-  displayName: string
-  searchableField: string
-  uid: string
-  item: {
-    id: string
-    [key: string]: any
-  }
-}
-
-export type FormattedStrapiEntry = {
-  uid: string
-  id: string
-}
-
-export type Configuration = {
-  recursive: {
-    enabled: boolean
-    maxDepth: number
-  }
-  debug: boolean
-}
-
-export type AnyEntity = {
-  id: number | string
-  attributes: {
-    [key: string]: any
-  }
-}
-
-export type StrapiResponse = {
-  data: AnyEntity | AnyEntity[]
-}
-
-export type Context = {
-  configuration: Configuration
-  publicationState: "live" | "preview"
-}

package/server/middlewares/index.ts

@@ -1,5 +0,0 @@
-import middleware from "./middleware"
-
-export default {
-  middleware
-}

package/server/middlewares/middleware.ts

@@ -1,197 +0,0 @@
-import type { Common } from "@strapi/strapi"
-import { getPluginConfiguration, log } from "../utils"
-import type { Context, StrapiResponse, AnyEntity } from "../interface"
-
-export default async (ctx, next) => {
-  await next()
-
-  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 contentTypes = Object.keys(strapi.contentTypes)
-
-  log(`URL: ${ctx.request.url} (${ctx.request.method})`)
-  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`)
-    )
-
-  log(`Is valid handler: ${validHandler}`)
-
-  // Allow only findOne/findMany for native contentypes that have api::
-  if (!validHandler) return
-
-  const context = {
-    configuration,
-    publicationState: ctx.request.query?.["publicationState"] ?? "live"
-  }
-
-  log(" ----- ")
-  log(`Context Body: ${JSON.stringify(ctx.body, null, 2)}`)
-  if (ctx.body.error || !ctx.body?.data.attributes) return
-
-  const hydratedData = await augmentMRCT(ctx.body, 1, context)
-
-  ctx.body.data = hydratedData
-}
-
-const augmentMRCT = async (
-  strapiResponse: StrapiResponse,
-  currentDepth: number,
-  context: Context
-): Promise<AnyEntity | AnyEntity[]> => {
-  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: AnyEntity, currentDepth: number, context: Context) => {
-  const eligibleProperties: Set<string> = new Set()
-  const contentsToFetch: Set<string> = 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
-
-  log(`Depth: ${currentDepth}, Hydrating MCTR for ID ${content.id}`)
-
-  const promises: Promise<any>[] = []
-  for (const item of Array.from(contentsToFetch)) {
-    const [uid, id] = item.split("####")
-    const promise = strapi.entityService
-      .findOne(uid as Common.UID.ContentType, 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: any[] = await Promise.all(promises)
-
-  const filteredLinkedEntries: { uid: string; response: AnyEntity }[] = 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?.attributes.publishedAt === "string"
-    })
-
-  for (const key of Array.from(eligibleProperties)) {
-    const hydratedArray: AnyEntity[] = []
-
-    const unhydratedField = JSON.parse(flattenedProperties[key]) as { uid: string; id: string }[]
-
-    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: any, parent: any, res: Record<string, any> = {}) => {
-  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: any) => {
-  var result = {}
-  for (var i in data) {
-    var keys = i.split(".")
-    keys.reduce(function (r: any, e, j) {
-      return r[e] || (r[e] = isNaN(Number(keys[j + 1])) ? (keys.length - 1 == j ? data[i] : {}) : [])
-    }, result)
-  }
-  return result
-}

package/server/policies/index.ts

@@ -1 +0,0 @@
-export default {};

package/server/register.ts

@@ -1,14 +0,0 @@
-import { Strapi } from "@strapi/strapi"
-
-import middlewares from "./middlewares"
-
-export default ({ strapi }: { strapi: Strapi }) => {
-  // register phase
-  strapi.customFields.register({
-    name: "multi-content-type-relation",
-    plugin: "multi-content-type-relation",
-    type: "richtext"
-  })
-
-  strapi.server.use(middlewares.middleware)
-}

package/server/routes/index.ts

@@ -1,27 +0,0 @@
-export 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/server/services/index.ts

@@ -1,5 +0,0 @@
-import service from "./service"
-
-export default {
-  service
-}

package/server/services/service.ts

@@ -1,11 +0,0 @@
-import { Strapi } from "@strapi/strapi"
-
-export default ({ strapi }: { strapi: Strapi }) => ({
-  getFirstStringFieldInContentType(contentType) {
-    const result = Object.keys(contentType.attributes).find(
-      (attribute) => contentType.attributes[attribute].type === "string"
-    )
-
-    return result
-  }
-})

package/server/utils.ts

@@ -1,14 +0,0 @@
-import { Configuration } from "./interface"
-
-export const getPluginConfiguration = (): Configuration => {
-  const pluginConfiguration = strapi.config.get("plugin.multi-content-type-relation") as Configuration
-
-  return pluginConfiguration
-}
-export const log = (message: string) => {
-  const { debug } = getPluginConfiguration()
-
-  if (debug) {
-    console.log(`[MCTR DEBUG] ${message}`)
-  }
-}

package/strapi-admin.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./admin/src').default;

package/strapi-server.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./dist/server');

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "@strapi/typescript-utils/tsconfigs/admin",
-
-  "compilerOptions": {
-    "target": "ESNext",
-    "strict": true
-  },
-
-  "include": ["admin", "custom.d.ts"],
-
-  "exclude": [
-    "node_modules/",
-    "dist/",
-
-    // Do not include server files in the server compilation
-    "server/",
-    // Do not include test files
-    "**/*.test.ts"
-  ]
-}

package/tsconfig.server.json

@@ -1,25 +0,0 @@
-{
-  "extends": "@strapi/typescript-utils/tsconfigs/server",
-
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "."
-  },
-
-  "include": [
-    // Include the root directory
-    "server",
-    // Force the JSON files in the src folder to be included
-    "server/**/*.json"
-  ],
-
-  "exclude": [
-    "node_modules/",
-    "dist/",
-
-    // Do not include admin files in the server compilation
-    "admin/",
-    // Do not include test files
-    "**/*.test.ts"
-  ]
-}