multi-content-type-relation 0.1.0 → 2.1.0

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

@@ -0,0 +1,113 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: ({ env }: {
+            env: any;
+        }) => {
+            recursive: {
+                enabled: boolean;
+                maxDepth: number;
+            };
+            debug: boolean;
+        };
+        validator(config: any): void;
+    };
+    controllers: {
+        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;
+            }[]>;
+        };
+    };
+    routes: ({
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: any[];
+            auth: boolean;
+        };
+    } | {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: any[];
+            auth?: undefined;
+        };
+    })[];
+    services: {
+        service: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getFirstStringFieldInContentType(contentType: any): string;
+        };
+    };
+    contentTypes: {
+        '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;
+                    };
+                };
+            };
+        };
+    };
+    policies: {};
+    middlewares: {
+        middleware: (ctx: any, next: any) => Promise<void>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,42 @@
+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;
+    documentId: string;
+};
+export type Configuration = {
+    recursive: {
+        enabled: boolean;
+        maxDepth: number;
+    };
+    debug: boolean;
+};
+export type AnyEntity = {
+    documentId: number | string;
+    [key: string]: any;
+};
+export type StrapiResponse = {
+    data: AnyEntity | AnyEntity[];
+};
+export type Context = {
+    configuration: Configuration;
+    publicationState: 'live' | 'preview';
+};

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

@@ -0,0 +1,4 @@
+declare const _default: {
+    middleware: (ctx: any, next: any) => Promise<void>;
+};
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any, next: any) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: {};
+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/routes/index.d.ts

@@ -0,0 +1,18 @@
+declare const _default: ({
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: any[];
+        auth: boolean;
+    };
+} | {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: any[];
+        auth?: undefined;
+    };
+})[];
+export default _default;

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    service: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getFirstStringFieldInContentType(contentType: any): string;
+    };
+};
+export default _default;

package/dist/server/src/services/service.d.ts

@@ -0,0 +1,7 @@
+import type { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getFirstStringFieldInContentType(contentType: any): string;
+};
+export default _default;

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

@@ -0,0 +1,3 @@
+import { Configuration } from './interface';
+export declare const getPluginConfiguration: () => Configuration;
+export declare const log: (message: string) => void;

package/package.json

@@ -1,53 +1,81 @@
 {
   "name": "multi-content-type-relation",
-  "version": "0.1.0",
-  "description": "This is the description of the plugin.",
+  "version": "2.1.0",
+  "description": "A multi content type relation plugin for Strapi 5.",
   "license": "MIT",
   "author": {
-    "name": "A Strapi developer"
+    "name": "bleulliette@kaliop.com"
   },
   "maintainers": [
     {
-      "name": "A Strapi developer"
+      "name": "bleulliette@kaliop.com"
     }
   ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./strapi-admin": {
+      "types": "./dist/admin/src/index.d.ts",
+      "source": "./admin/src/index.ts",
+      "import": "./dist/admin/index.mjs",
+      "require": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./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": "tsc -p tsconfig.server.json",
-    "develop": "tsc -p tsconfig.server.json -w"
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch",
+    "watch:link": "strapi-plugin watch:link",
+    "verify": "strapi-plugin verify",
+    "test:ts:front": "run -T tsc -p lib/admin/tsconfig.json",
+    "test:ts:back": "run -T tsc -p lib/server/tsconfig.json"
   },
   "dependencies": {
     "@dnd-kit/sortable": "^7.0.2",
-    "@strapi/design-system": "^1.6.3",
-    "@strapi/helper-plugin": "^4.6.0",
-    "@strapi/icons": "^1.6.3",
-    "prop-types": "^15.7.2"
+    "@strapi/design-system": "^2.0.0-rc.27",
+    "@strapi/icons": "^2.0.0-rc.27",
+    "react-intl": "^7.1.11"
   },
   "devDependencies": {
-    "@strapi/typescript-utils": "^4.6.0",
-    "@types/react": "^17.0.53",
-    "@types/react-dom": "^18.0.28",
-    "@types/react-router-dom": "^5.3.3",
-    "@types/styled-components": "^5.1.26",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-router-dom": "^5.3.4",
-    "styled-components": "^5.3.6",
-    "typescript": "^5.0.4"
+    "@strapi/sdk-plugin": "^5.3.2",
+    "@strapi/strapi": "^5.16.1",
+    "@strapi/typescript-utils": "^5.16.1",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "prettier": "^3.6.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.1",
+    "styled-components": "^6.1.19",
+    "typescript": "^5.8.3"
   },
   "peerDependencies": {
-    "@strapi/strapi": "^4.13.3",
-    "react": "^17.0.0 || ^18.0.0",
-    "react-dom": "^17.0.0 || ^18.0.0",
-    "react-router-dom": "^5.3.4",
-    "styled-components": "^5.3.3"
+    "@strapi/sdk-plugin": "^5.3.2",
+    "@strapi/strapi": "^5.16.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.1",
+    "styled-components": "^6.1.19"
   },
   "engines": {
-    "node": ">=16.0.0 <=20.x.x",
+    "node": ">=20.x.x",
     "npm": ">=6.0.0"
   },
   "strapi": {
     "name": "multi-content-type-relation",
-    "description": "Description of multi-content-type-relation plugin",
+    "description": "A multi content type relation plugin for Strapi 5",
     "kind": "plugin"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/TODO.md

@@ -1,4 +0,0 @@
-# Remaining tasks
-
-- publish it
-- Create tests

package/admin/src/components/Input/InputContentSuggestions.tsx

@@ -1,162 +0,0 @@
-import React, { useMemo } from "react"
-import { Box, Table, Thead, Tr, Th, Tbody, Typography, Divider } from "@strapi/design-system"
-import { DndContext, PointerSensor, closestCenter, useSensor, useSensors } from "@dnd-kit/core"
-import { SortableContext, arrayMove, verticalListSortingStrategy } from "@dnd-kit/sortable"
-
-import { MatchingContent, SelectedEntry } from "../../interface"
-import { TableItem } from "./TableItem"
-
-type Props = {
-  uniqueId: number
-  suggestions?: MatchingContent[]
-  selected?: SelectedEntry[]
-  onAddEntry?(entry: SelectedEntry): void
-  onDeleteEntry?(entry: SelectedEntry): void
-  onEntriesSorted?(entries: SelectedEntry[]): void
-  sortable?: boolean
-  maximum?: number
-}
-
-export function InputContentSuggestions({
-  uniqueId,
-  suggestions,
-  selected,
-  onAddEntry,
-  onDeleteEntry,
-  onEntriesSorted,
-  maximum,
-  sortable
-}: Props) {
-  const suggestionAsSelectedEntry = useMemo(() => {
-    return (suggestions || [])
-      .flatMap((suggestion) =>
-        suggestion.results.map<SelectedEntry>((entrySuggestion) => ({
-          displayName: suggestion.displayName,
-          item: entrySuggestion,
-          searchableField: suggestion.searchableField,
-          uid: suggestion.uid
-        }))
-      )
-      .slice(0, 10)
-  }, [suggestions])
-
-  const buildSelectedId = (entry: SelectedEntry) => {
-    return `${uniqueId}-${entry.uid}-${entry.item.id}`
-  }
-
-  const availableSuggestions = useMemo(() => {
-    const selectedIdentifiers = (selected || []).map(buildSelectedId)
-
-    return suggestionAsSelectedEntry.filter((suggestion) => !selectedIdentifiers.includes(buildSelectedId(suggestion)))
-  }, [suggestions, selected])
-
-  const onAdd = (entry: SelectedEntry) => {
-    if (typeof onAddEntry === "function") {
-      onAddEntry(entry)
-    }
-  }
-
-  const onDelete = (entry: SelectedEntry) => {
-    if (typeof onDeleteEntry === "function") {
-      onDeleteEntry(entry)
-    }
-  }
-
-  // Sortable behavior
-  const onSort = (entries: SelectedEntry[]) => {
-    if (typeof onEntriesSorted === "function") {
-      onEntriesSorted(entries)
-    }
-  }
-
-  const sensors = useSensors(
-    useSensor(PointerSensor, {
-      activationConstraint: {
-        distance: 5
-      }
-    })
-  )
-
-  const handleDragEnd = (event) => {
-    const { active, over } = event
-
-    if (!active || !over) return
-
-    if (active.id !== over.id) {
-      const oldIndex = selected!.findIndex((entry) => buildSelectedId(entry) === active.id)
-      const newIndex = selected!.findIndex((entry) => buildSelectedId(entry) === over.id)
-
-      onSort(arrayMove(selected!, oldIndex, newIndex))
-    }
-  }
-
-  if (!availableSuggestions?.length && !selected?.length) return null
-
-  return (
-    <Box padding={[2, 0, 2, 0]} background="neutral100">
-      <Table style={{ whiteSpace: "unset" }}>
-        <Thead>
-          <Tr>
-            <Th></Th>
-            <Th>
-              <Typography variant="sigma">Title</Typography>
-            </Th>
-            <Th>
-              <Typography variant="sigma">ID</Typography>
-            </Th>
-            <Th>
-              <Typography variant="sigma">Content type</Typography>
-            </Th>
-            <Th>
-              <Typography variant="sigma">State</Typography>
-            </Th>
-          </Tr>
-        </Thead>
-
-        <Tbody>
-          {selected?.length ? (
-            sortable ? (
-              <>
-                {/* @ts-expect-error Server Component */}
-                <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
-                  <SortableContext
-                    items={selected.map((entry) => buildSelectedId(entry))}
-                    strategy={verticalListSortingStrategy}
-                  >
-                    {selected.map((entry) => (
-                      <TableItem
-                        uniqueId={uniqueId}
-                        key={buildSelectedId(entry)}
-                        entry={entry}
-                        type="selected"
-                        onDelete={onDelete}
-                        sortable={sortable}
-                      />
-                    ))}
-                  </SortableContext>
-                </DndContext>
-              </>
-            ) : (
-              (selected || []).map((entry) => (
-                <TableItem uniqueId={uniqueId} entry={entry} type="selected" onDelete={onDelete} />
-              ))
-            )
-          ) : null}
-
-          {availableSuggestions.length && selected?.length ? <Tr style={{ height: "32px" }} /> : null}
-
-          {availableSuggestions.map((entry) => (
-            <TableItem
-              uniqueId={uniqueId}
-              key={buildSelectedId(entry)}
-              entry={entry}
-              type="suggestion"
-              onAdd={onAdd}
-              disabled={typeof maximum === "number" ? (selected?.length ?? 0) >= maximum : false}
-            />
-          ))}
-        </Tbody>
-      </Table>
-    </Box>
-  )
-}

package/admin/src/components/Input/MainInput.tsx

@@ -1,135 +0,0 @@
-import React, { useEffect, useMemo, useState } from "react"
-import { useIntl } from "react-intl"
-import { useLocation } from "react-router-dom"
-
-import { Loader, Field, TextInput } from "@strapi/design-system"
-
-import { FormattedStrapiEntry, PluginOption, SelectedEntry } from "../../interface"
-import { useSearchedEntries } from "../../hooks/useSearchedEntries"
-import { InputContentSuggestions } from "./InputContentSuggestions"
-import { formatToStrapiField, validateCurrentRelations } from "../../helpers/content"
-
-type Props = {
-  name: string
-  error: string
-  description: string
-  value: string
-  onChange(payload: Record<string, unknown>): void
-  intlLabel: Record<string, string>
-  attribute: PluginOption
-  required: boolean
-}
-
-export function MainInput({ name, error, description, onChange, value, intlLabel, attribute, required }: Props) {
-  const { formatMessage } = useIntl()
-  const location = useLocation()
-  const maximumItems = attribute.options.max
-  const minimumItems = attribute.options.min || 0
-  const currentLocale = new URLSearchParams(location.search).get("plugins[i18n][locale]") as string
-
-  const [keyword, setKeyword] = useState("")
-  const [selected, setSelected] = useState<SelectedEntry[]>([])
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    const value = selected.length > maximumItems || selected.length < minimumItems ? [] : selected
-
-    onChange({ target: { name, value: formatToStrapiField(value) } })
-  }, [selected])
-
-  const hint = useMemo(() => {
-    const minLabel = minimumItems > 0 ? `min. ${minimumItems} ${minimumItems > 1 ? "entries" : "entry"}` : ""
-    const maxLabel = maximumItems > 0 ? `max. ${maximumItems} ${maximumItems > 1 ? "entries" : "entry"}` : ""
-
-    return `
-      ${minLabel ? `${minLabel}` : ""}
-      ${minLabel && maxLabel ? ", " : ""}
-      ${maxLabel}
-      ${minLabel || maxLabel ? " - " : ""}
-      ${selected.length} selected
-    `
-  }, [selected, maximumItems, minimumItems])
-
-  const inputError = useMemo(() => {
-    if (!error) return ""
-
-    if (selected.length < minimumItems) return `${error} - A minimum of ${minimumItems} item(s) is required`
-
-    if (selected.length > maximumItems) return `${error} - A maximum of ${maximumItems} item(s) is required`
-
-    return error
-  }, [error, maximumItems, minimumItems, selected])
-
-  const { loading: searchLoading, results } = useSearchedEntries(keyword, attribute.options.contentTypes, currentLocale)
-
-  // Validate relations and remove the one that got deleted
-  useEffect(() => {
-    async function validateContent() {
-      if (!value) {
-        setLoading(false)
-        return
-      }
-
-      const entries = JSON.parse(value) as FormattedStrapiEntry[]
-
-      const result = await validateCurrentRelations(entries)
-
-      setSelected(result)
-      setLoading(false)
-    }
-
-    validateContent()
-  }, [])
-
-  const onAddEntry = (entry: SelectedEntry) => {
-    const alreadyDefined = selected.some(
-      (selectedEntry) => selectedEntry.uid === entry.uid && selectedEntry.item.id === entry.item.id
-    )
-
-    if (alreadyDefined) return
-
-    setSelected([...selected, entry])
-  }
-
-  const onDeleteEntry = (entry: SelectedEntry) => {
-    const newSelected = selected.filter(
-      (selectedEntry) => !(selectedEntry.uid === entry.uid && selectedEntry.item.id === entry.item.id)
-    )
-
-    setSelected(newSelected)
-  }
-
-  const onEntriesSorted = (entries) => {
-    setSelected(entries)
-  }
-
-  if (loading) return <Loader />
-
-  return (
-    <Field name={name} id={name} error={error} hint={description} required={required}>
-      <TextInput
-        label={formatMessage(intlLabel)}
-        placeholder="Type a term to search"
-        required={required}
-        hint={hint}
-        error={inputError}
-        value={keyword}
-        onChange={(e) => setKeyword(e.target.value)}
-      />
-      {searchLoading ? (
-        <Loader />
-      ) : (
-        <InputContentSuggestions
-          uniqueId={Date.now()}
-          suggestions={results}
-          selected={selected}
-          onAddEntry={onAddEntry}
-          onDeleteEntry={onDeleteEntry}
-          onEntriesSorted={onEntriesSorted}
-          maximum={maximumItems}
-          sortable
-        />
-      )}
-    </Field>
-  )
-}

package/admin/src/components/Input/PublicationState.tsx

@@ -1,28 +0,0 @@
-import React, { useMemo } from "react"
-import { Status, Typography } from "@strapi/design-system"
-
-type Props = {
-  isPublished: boolean
-  hasDraftAndPublish?: boolean
-}
-
-export const PublicationState = ({ isPublished, hasDraftAndPublish }: Props) => {
-  const configuration = useMemo(() => {
-    const conf = { variant: "alternative", text: "N/A" }
-
-    if (hasDraftAndPublish) {
-      conf.variant = isPublished ? "success" : "secondary"
-      conf.text = isPublished ? "Published" : "Draft"
-    }
-
-    return conf
-  }, [isPublished, hasDraftAndPublish])
-
-  return (
-    <Status showBullet={false} variant={configuration.variant} size="S" width="min-content">
-      <Typography fontWeight="bold" textColor={`${configuration.variant}700`}>
-        {configuration.text}
-      </Typography>
-    </Status>
-  )
-}