@strapi/plugin-documentation 4.10.0-beta.1 → 4.10.1-experimental.0

package/admin/src/pages/PluginPage/index.js

@@ -51,9 +51,9 @@ const PluginPage = () => {
   const colCount = 4;
   const rowCount = (data?.docVersions?.length || 0) + 1;
 
-  const openDocVersion = () => {
+  const openDocVersion = (version) => {
     const slash = data?.prefix.startsWith('/') ? '' : '/';
-    openWithNewTab(`${slash}${data?.prefix}/v${data?.currentVersion}`);
+    openWithNewTab(`${slash}${data?.prefix}/v${version}`);
   };
 
   const handleRegenerateDoc = (version) => {
@@ -141,7 +141,7 @@ const PluginPage = () => {
                       <Td>
                         <Flex justifyContent="end" {...stopPropagation}>
                           <IconButton
-                            onClick={openDocVersion}
+                            onClick={() => openDocVersion(doc.version)}
                             noBorder
                             icon={<Show />}
                             label={formatMessage(

package/admin/src/pages/utils/useReactQuery.js

@@ -1,14 +1,28 @@
 import { useQuery, useMutation, useQueryClient } from 'react-query';
-import { useNotification } from '@strapi/helper-plugin';
-import { fetchDocumentationVersions, deleteDoc, regenerateDoc, updateSettings } from './api';
+import { useNotification, useFetchClient } from '@strapi/helper-plugin';
+import pluginId from '../../pluginId';
 import getTrad from '../../utils/getTrad';
 
 const useReactQuery = () => {
   const queryClient = useQueryClient();
   const toggleNotification = useNotification();
-  const { isLoading, data } = useQuery('get-documentation', () =>
-    fetchDocumentationVersions(toggleNotification)
-  );
+  const { isLoading, data } = useQuery(['get-documentation', pluginId], async () => {
+    try {
+      const { data } = await get(`/${pluginId}/getInfos`);
+
+      return data;
+    } catch (err) {
+      toggleNotification({
+        type: 'warning',
+        message: { id: 'notification.error' },
+      });
+
+      // FIXME
+      return null;
+    }
+  });
+
+  const { del, post, put, get } = useFetchClient();
 
   const handleError = (err) => {
     toggleNotification({
@@ -25,20 +39,26 @@ const useReactQuery = () => {
     });
   };
 
-  const deleteMutation = useMutation(deleteDoc, {
-    onSuccess: () => handleSuccess('info', 'notification.delete.success'),
-    onError: (error) => handleError(error),
-  });
+  const deleteMutation = useMutation(
+    ({ prefix, version }) => del(`${prefix}/deleteDoc/${version}`),
+    {
+      onSuccess: () => handleSuccess('info', 'notification.delete.success'),
+      onError: (error) => handleError(error),
+    }
+  );
 
-  const submitMutation = useMutation(updateSettings, {
+  const submitMutation = useMutation(({ prefix, body }) => put(`${prefix}/updateSettings`, body), {
     onSuccess: () => handleSuccess('success', 'notification.update.success'),
     onError: handleError,
   });
 
-  const regenerateDocMutation = useMutation(regenerateDoc, {
-    onSuccess: () => handleSuccess('info', 'notification.generate.success'),
-    onError: (error) => handleError(error),
-  });
+  const regenerateDocMutation = useMutation(
+    ({ prefix, version }) => post(`${prefix}/regenerateDoc`, { version }),
+    {
+      onSuccess: () => handleSuccess('info', 'notification.generate.success'),
+      onError: (error) => handleError(error),
+    }
+  );
 
   return { data, isLoading, deleteMutation, submitMutation, regenerateDocMutation };
 };

package/jest.config.front.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  preset: '../../../jest-preset.front.js',
+};

package/jest.config.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  preset: '../../../jest-preset.unit.js',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/plugin-documentation",
-  "version": "4.10.0-beta.1",
+  "version": "4.10.1-experimental.0",
   "description": "Create an OpenAPI Document and visualize your API with SWAGGER UI.",
   "repository": {
     "type": "git",
@@ -21,17 +21,19 @@
     }
   ],
   "scripts": {
-    "lint": "run -T eslint ."
+    "lint": "run -T eslint .",
+    "test:unit": "jest --verbose"
   },
   "dependencies": {
     "@strapi/design-system": "1.6.6",
-    "@strapi/helper-plugin": "4.10.0-beta.1",
+    "@strapi/helper-plugin": "4.10.1-experimental.0",
     "@strapi/icons": "1.6.6",
-    "@strapi/utils": "4.10.0-beta.1",
+    "@strapi/utils": "4.10.1-experimental.0",
     "bcryptjs": "2.4.3",
     "cheerio": "^1.0.0-rc.12",
     "formik": "2.2.9",
     "fs-extra": "10.0.0",
+    "immer": "9.0.19",
     "koa-static": "^5.0.0",
     "lodash": "4.17.21",
     "path-to-regexp": "6.2.1",
@@ -55,6 +57,7 @@
     "styled-components": "^5.3.3"
   },
   "devDependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
     "@testing-library/react": "12.1.4",
     "history": "^4.9.0",
     "msw": "1.0.1",
@@ -73,5 +76,5 @@
     "description": "Create an OpenAPI Document and visualize your API with SWAGGER UI.",
     "kind": "plugin"
   },
-  "gitHead": "95d581b31bee464af42e5d8db408fa578d8532c7"
+  "gitHead": "ce60415a0779e850da2c2edd80799f98918c000c"
 }

package/server/config/default-plugin-config.js

@@ -19,9 +19,8 @@ module.exports = {
   },
   'x-strapi-config': {
     path: '/documentation',
-    showGeneratedFiles: true,
-    generateDefaultResponse: true,
-    plugins: ['email', 'upload', 'users-permissions'],
+    plugins: null,
+    mutateDocumentation: null,
   },
   servers: [],
   externalDocs: {
@@ -33,42 +32,4 @@ module.exports = {
       bearerAuth: [],
     },
   ],
-  components: {
-    securitySchemes: {
-      bearerAuth: {
-        type: 'http',
-        scheme: 'bearer',
-        bearerFormat: 'JWT',
-      },
-    },
-    schemas: {
-      Error: {
-        type: 'object',
-        required: ['error'],
-        properties: {
-          data: {
-            nullable: true,
-            oneOf: [{ type: 'object' }, { type: 'array', items: [] }],
-          },
-          error: {
-            type: 'object',
-            properties: {
-              status: {
-                type: 'integer',
-              },
-              name: {
-                type: 'string',
-              },
-              message: {
-                type: 'string',
-              },
-              details: {
-                type: 'object',
-              },
-            },
-          },
-        },
-      },
-    },
-  },
 };

package/server/services/__mocks__/mock-content-types.js

@@ -0,0 +1,269 @@
+'use strict';
+
+module.exports = {
+  'plugin::upload.file': {
+    collectionName: 'files',
+    info: { singularName: 'file', pluralName: 'files', displayName: 'File', description: '' },
+    options: {},
+    pluginOptions: {
+      'content-manager': { visible: false },
+      'content-type-builder': { visible: false },
+    },
+    attributes: {
+      name: { type: 'string', configurable: false, required: true },
+      alternativeText: { type: 'string', configurable: false },
+      caption: { type: 'string', configurable: false },
+      width: { type: 'integer', configurable: false },
+      height: { type: 'integer', configurable: false },
+      formats: { type: 'json', configurable: false },
+      hash: { type: 'string', configurable: false, required: true },
+      ext: { type: 'string', configurable: false },
+      mime: { type: 'string', configurable: false, required: true },
+      size: { type: 'decimal', configurable: false, required: true },
+      url: { type: 'string', configurable: false, required: true },
+      previewUrl: { type: 'string', configurable: false },
+      provider: { type: 'string', configurable: false, required: true },
+      provider_metadata: { type: 'json', configurable: false },
+      related: { type: 'relation', relation: 'morphToMany', configurable: false },
+      folder: {
+        type: 'relation',
+        relation: 'manyToOne',
+        target: 'plugin::upload.folder',
+        inversedBy: 'files',
+        private: true,
+      },
+      folderPath: { type: 'string', min: 1, required: true, private: true },
+      createdAt: { type: 'datetime' },
+      updatedAt: { type: 'datetime' },
+      createdBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+      updatedBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+    },
+    indexes: [
+      { name: 'upload_files_folder_path_index', columns: ['folder_path'], type: null },
+      { name: 'upload_files_created_at_index', columns: ['created_at'], type: null },
+      { name: 'upload_files_updated_at_index', columns: ['updated_at'], type: null },
+      { name: 'upload_files_name_index', columns: ['name'], type: null },
+      { name: 'upload_files_size_index', columns: ['size'], type: null },
+      { name: 'upload_files_ext_index', columns: ['ext'], type: null },
+    ],
+    kind: 'collectionType',
+    modelType: 'contentType',
+    modelName: 'file',
+    connection: 'default',
+    uid: 'plugin::upload.file',
+    plugin: 'upload',
+    globalId: 'UploadFile',
+  },
+  'plugin::upload.folder': {
+    collectionName: 'upload_folders',
+    info: { singularName: 'folder', pluralName: 'folders', displayName: 'Folder' },
+    options: {},
+    pluginOptions: {
+      'content-manager': { visible: false },
+      'content-type-builder': { visible: false },
+    },
+    attributes: {
+      name: { type: 'string', min: 1, required: true },
+      pathId: { type: 'integer', unique: true, required: true },
+      parent: {
+        type: 'relation',
+        relation: 'manyToOne',
+        target: 'plugin::upload.folder',
+        inversedBy: 'children',
+      },
+      children: {
+        type: 'relation',
+        relation: 'oneToMany',
+        target: 'plugin::upload.folder',
+        mappedBy: 'parent',
+      },
+      files: {
+        type: 'relation',
+        relation: 'oneToMany',
+        target: 'plugin::upload.file',
+        mappedBy: 'folder',
+      },
+      path: { type: 'string', min: 1, required: true },
+      createdAt: { type: 'datetime' },
+      updatedAt: { type: 'datetime' },
+      createdBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+      updatedBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+    },
+    indexes: [
+      { name: 'upload_folders_path_id_index', columns: ['path_id'], type: 'unique' },
+      { name: 'upload_folders_path_index', columns: ['path'], type: 'unique' },
+    ],
+    kind: 'collectionType',
+    modelType: 'contentType',
+    modelName: 'folder',
+    connection: 'default',
+    uid: 'plugin::upload.folder',
+    plugin: 'upload',
+    globalId: 'UploadFolder',
+  },
+  'api::kitchensink.kitchensink': {
+    kind: 'collectionType',
+    collectionName: 'kitchensinks',
+    info: {
+      displayName: 'Kitchen Sink',
+      singularName: 'kitchensink',
+      pluralName: 'kitchensinks',
+      description: '',
+      name: 'Kitchen Sink',
+    },
+    options: { draftAndPublish: true },
+    pluginOptions: {},
+    attributes: {
+      short_text: { type: 'string' },
+      long_text: { type: 'text' },
+      rich_text: { type: 'richtext' },
+      integer: { type: 'integer' },
+      biginteger: { type: 'biginteger' },
+      decimal: { type: 'decimal' },
+      float: { type: 'float' },
+      date: { type: 'date' },
+      datetime: { type: 'datetime' },
+      time: { type: 'time' },
+      timestamp: { type: 'timestamp' },
+      boolean: { type: 'boolean' },
+      email: { type: 'email' },
+      password: { type: 'password' },
+      enumeration: { type: 'enumeration', enum: ['A', 'B', 'C', 'D', 'E'] },
+      single_media: {
+        type: 'media',
+        multiple: false,
+        required: false,
+        allowedTypes: ['images', 'files', 'videos'],
+      },
+      multiple_media: {
+        type: 'media',
+        multiple: true,
+        required: false,
+        allowedTypes: ['images', 'files', 'videos'],
+      },
+      json: { type: 'json' },
+      single_compo: { type: 'component', repeatable: false, component: 'basic.simple' },
+      repeatable_compo: { type: 'component', repeatable: true, component: 'basic.simple' },
+      dynamiczone: { type: 'dynamiczone', components: ['basic.simple', 'blog.test-como'] },
+      one_way_tag: { type: 'relation', relation: 'oneToOne', target: 'api::tag.tag' },
+      one_to_one_tag: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'api::tag.tag',
+        private: true,
+        inversedBy: 'one_to_one_kitchensink',
+      },
+      one_to_many_tags: {
+        type: 'relation',
+        relation: 'oneToMany',
+        target: 'api::tag.tag',
+        mappedBy: 'many_to_one_kitchensink',
+      },
+      many_to_one_tag: {
+        type: 'relation',
+        relation: 'manyToOne',
+        target: 'api::tag.tag',
+        inversedBy: 'one_to_many_kitchensinks',
+      },
+      many_to_many_tags: {
+        type: 'relation',
+        relation: 'manyToMany',
+        target: 'api::tag.tag',
+        inversedBy: 'many_to_many_kitchensinks',
+      },
+      many_way_tags: { type: 'relation', relation: 'oneToMany', target: 'api::tag.tag' },
+      morph_to_one: { type: 'relation', relation: 'morphToOne' },
+      morph_to_many: { type: 'relation', relation: 'morphToMany' },
+      custom_field: { type: 'string', customField: 'plugin::color-picker.color' },
+      custom_field_with_default_options: {
+        type: 'string',
+        regex: '^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$',
+        customField: 'plugin::color-picker.color',
+      },
+      cats: { type: 'dynamiczone', components: ['basic.relation', 'basic.simple'] },
+      createdAt: { type: 'datetime' },
+      updatedAt: { type: 'datetime' },
+      publishedAt: { type: 'datetime', configurable: false, writable: true, visible: false },
+      createdBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+      updatedBy: {
+        type: 'relation',
+        relation: 'oneToOne',
+        target: 'admin::user',
+        configurable: false,
+        writable: false,
+        visible: false,
+        useJoinTable: false,
+        private: true,
+      },
+    },
+    modelType: 'contentType',
+    modelName: 'kitchensink',
+    connection: 'default',
+    uid: 'api::kitchensink.kitchensink',
+    apiName: 'kitchensink',
+    globalId: 'Kitchensink',
+    actions: {},
+    lifecycles: {},
+  },
+  'api::homepage.homepage': {
+    kind: 'singleType',
+    collectionName: 'homepages',
+    info: { displayName: 'Homepage', singularName: 'homepage', pluralName: 'homepages' },
+    options: { draftAndPublish: true },
+    pluginOptions: { i18n: { localized: true } },
+    attributes: {
+      title: { type: 'string', required: true, pluginOptions: { i18n: { localized: true } } },
+      slug: {
+        type: 'uid',
+        targetField: 'title',
+        required: true,
+        pluginOptions: { i18n: { localized: true } },
+      },
+    },
+  },
+};

package/server/services/__mocks__/mock-strapi-data.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const contentTypes = require('./mock-content-types');
+
+module.exports = {
+  contentTypes,
+  components: {
+    'basic.simple': {
+      collectionName: 'components_basic_simples',
+      info: { displayName: 'simple', icon: 'ambulance', description: '' },
+      options: {},
+      attributes: { name: { type: 'string', required: true }, test: { type: 'string' } },
+      uid: 'basic.simple',
+      category: 'basic',
+      modelType: 'component',
+      modelName: 'simple',
+      globalId: 'ComponentBasicSimple',
+    },
+    'blog.test-como': {
+      collectionName: 'components_blog_test_comos',
+      info: { displayName: 'test comp', icon: 'air-freshener', description: '' },
+      options: {},
+      attributes: { name: { type: 'string', default: 'toto' } },
+      uid: 'blog.test-como',
+      category: 'blog',
+      modelType: 'component',
+      modelName: 'test-como',
+      globalId: 'ComponentBlogTestComo',
+    },
+    'basic.relation': {
+      collectionName: 'components_basic_relations',
+      info: { displayName: 'Relation' },
+      options: {},
+      attributes: {
+        categories: { type: 'relation', relation: 'oneToMany', target: 'api::category.category' },
+      },
+      uid: 'basic.relation',
+      category: 'basic',
+      modelType: 'component',
+      modelName: 'relation',
+      globalId: 'ComponentBasicRelation',
+    },
+  },
+  plugins: {
+    upload: {
+      contentTypes: {
+        file: contentTypes['plugin::upload.file'],
+        folder: contentTypes['plugin::upload.folder'],
+      },
+      routes: {
+        'content-api': {
+          type: 'content-api',
+          routes: [
+            {
+              method: 'POST',
+              path: '/',
+              handler: 'content-api.upload',
+              config: { auth: { scope: ['plugin::upload.content-api.upload'] } },
+              info: { pluginName: 'upload', type: 'content-api' },
+            },
+            {
+              method: 'GET',
+              path: '/files',
+              handler: 'content-api.find',
+              config: { auth: { scope: ['plugin::upload.content-api.find'] } },
+              info: { pluginName: 'upload', type: 'content-api' },
+            },
+            {
+              method: 'GET',
+              path: '/files/:id',
+              handler: 'content-api.findOne',
+              config: { auth: { scope: ['plugin::upload.content-api.findOne'] } },
+              info: { pluginName: 'upload', type: 'content-api' },
+            },
+            {
+              method: 'DELETE',
+              path: '/files/:id',
+              handler: 'content-api.destroy',
+              config: { auth: { scope: ['plugin::upload.content-api.destroy'] } },
+              info: { pluginName: 'upload', type: 'content-api' },
+            },
+          ],
+          prefix: '/upload',
+        },
+      },
+    },
+    email: {
+      contentTypes: {},
+    },
+    'users-permissions': {
+      contentTypes: {},
+    },
+  },
+  api: {
+    homepage: {
+      contentTypes: {
+        homepage: contentTypes['api::homepage.homepage'],
+      },
+      routes: {
+        homepage: {
+          type: 'content-api',
+          routes: [
+            {
+              method: 'GET',
+              path: '/homepage',
+              handler: 'api::homepage.homepage.find',
+              config: { auth: { scope: ['api::homepage.homepage.find'] } },
+              info: { apiName: 'homepage', type: 'content-api' },
+            },
+            {
+              method: 'PUT',
+              path: '/homepage',
+              handler: 'api::homepage.homepage.update',
+              config: { auth: { scope: ['api::homepage.homepage.update'] } },
+              info: { apiName: 'homepage', type: 'content-api' },
+            },
+            {
+              method: 'DELETE',
+              path: '/homepage',
+              handler: 'api::homepage.homepage.delete',
+              config: { auth: { scope: ['api::homepage.homepage.delete'] } },
+              info: { apiName: 'homepage', type: 'content-api' },
+            },
+            {
+              method: 'POST',
+              path: '/homepage',
+              handler: 'api::homepage.homepage.create',
+              config: { auth: { scope: ['api::homepage.homepage.create'] } },
+              info: { apiName: 'homepage', type: 'content-api' },
+            },
+          ],
+        },
+      },
+    },
+    kitchensink: {
+      contentTypes: {
+        kitchensink: contentTypes['api::kitchensink.kitchensink'],
+      },
+      routes: {
+        kitchensink: {
+          routes: [
+            {
+              method: 'GET',
+              path: '/kitchensinks',
+              handler: 'api::kitchensink.kitchensink.find',
+              config: { auth: { scope: ['api::kitchensink.kitchensink.find'] } },
+              info: { apiName: 'kitchensink', type: 'content-api' },
+            },
+            {
+              method: 'GET',
+              path: '/kitchensinks/:id',
+              handler: 'api::kitchensink.kitchensink.findOne',
+              config: { auth: { scope: ['api::kitchensink.kitchensink.findOne'] } },
+              info: { apiName: 'kitchensink', type: 'content-api' },
+            },
+            {
+              method: 'POST',
+              path: '/kitchensinks',
+              handler: 'api::kitchensink.kitchensink.create',
+              config: { auth: { scope: ['api::kitchensink.kitchensink.create'] } },
+              info: { apiName: 'kitchensink', type: 'content-api' },
+            },
+            {
+              method: 'PUT',
+              path: '/kitchensinks/:id',
+              handler: 'api::kitchensink.kitchensink.update',
+              config: { auth: { scope: ['api::kitchensink.kitchensink.update'] } },
+              info: { apiName: 'kitchensink', type: 'content-api' },
+            },
+            {
+              method: 'DELETE',
+              path: '/kitchensinks/:id',
+              handler: 'api::kitchensink.kitchensink.delete',
+              config: { auth: { scope: ['api::kitchensink.kitchensink.delete'] } },
+              info: { apiName: 'kitchensink', type: 'content-api' },
+            },
+          ],
+          type: 'content-api',
+        },
+      },
+    },
+  },
+};