@strapi/plugin-documentation 4.2.0-beta.0 → 4.2.0-beta.3

package/__mocks__/strapi.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const strapi = {
+  plugins: {
+    'users-permissions': {
+      contentTypes: {
+        role: {
+          attributes: {
+            name: {
+              type: 'string',
+            },
+          },
+        },
+      },
+      routes: {
+        'content-api': {
+          routes: [],
+        },
+      },
+    },
+  },
+  api: {
+    restaurant: {
+      contentTypes: {
+        restaurant: {
+          attributes: {
+            name: {
+              type: 'string',
+            },
+          },
+        },
+      },
+      routes: {
+        restaurant: { routes: [] },
+      },
+    },
+  },
+  contentType: () => ({ info: {}, attributes: { test: { type: 'string' } } }),
+};
+
+module.exports = strapi;

package/__tests__/build-component-schema.test.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const _ = require('lodash');
+const buildComponentSchema = require('../server/services/helpers/build-component-schema');
+const strapi = require('../__mocks__/strapi');
+
+describe('Build Component Schema', () => {
+  beforeEach(() => {
+    // Reset the mocked strapi instance
+    global.strapi = _.cloneDeep(strapi);
+  });
+
+  it('builds the Response schema', () => {
+    const apiMocks = [
+      {
+        name: 'users-permissions',
+        getter: 'plugin',
+        ctNames: ['role'],
+      },
+      { name: 'restaurant', getter: 'api', ctNames: ['restaurant'] },
+    ];
+
+    let schemas = {};
+    for (const mock of apiMocks) {
+      schemas = {
+        ...schemas,
+        ...buildComponentSchema(mock),
+      };
+    }
+
+    const schemaNames = Object.keys(schemas);
+    const [pluginResponseName, apiResponseName] = Object.keys(schemas);
+    const [pluginResponseValue, apiResponseValue] = Object.values(schemas);
+
+    const expectedShape = {
+      properties: {
+        data: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            attributes: { type: 'object', properties: { test: { type: 'string' } } },
+          },
+        },
+        meta: { type: 'object' },
+      },
+    };
+
+    expect(schemaNames.length).toBe(2);
+    expect(pluginResponseName).toBe('UsersPermissionsRoleResponse');
+    expect(apiResponseName).toBe('RestaurantResponse');
+    expect(pluginResponseValue).toStrictEqual(expectedShape);
+    expect(apiResponseValue).toStrictEqual(expectedShape);
+  });
+
+  it('builds the ResponseList schema', () => {
+    global.strapi.plugins['users-permissions'].routes['content-api'].routes = [
+      { method: 'GET', path: '/test', handler: 'test.find' },
+    ];
+    global.strapi.api.restaurant.routes.restaurant.routes = [
+      { method: 'GET', path: '/test', handler: 'test.find' },
+    ];
+
+    const apiMocks = [
+      {
+        name: 'users-permissions',
+        getter: 'plugin',
+        ctNames: ['role'],
+      },
+      { name: 'restaurant', getter: 'api', ctNames: ['restaurant'] },
+    ];
+
+    let schemas = {};
+    for (const mock of apiMocks) {
+      schemas = {
+        ...schemas,
+        ...buildComponentSchema(mock),
+      };
+    }
+
+    const schemaNames = Object.keys(schemas);
+    const pluginListResponseValue = schemas['UsersPermissionsRoleListResponse'];
+    const apiListResponseValue = schemas['RestaurantListResponse'];
+
+    const expectedShape = {
+      properties: {
+        data: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              attributes: { type: 'object', properties: { test: { type: 'string' } } },
+            },
+          },
+        },
+        meta: {
+          type: 'object',
+          properties: {
+            pagination: {
+              properties: {
+                page: { type: 'integer' },
+                pageSize: { type: 'integer', minimum: 25 },
+                pageCount: { type: 'integer', maximum: 1 },
+                total: { type: 'integer' },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    expect(schemaNames.length).toBe(4);
+    expect(schemaNames.includes('UsersPermissionsRoleListResponse')).toBe(true);
+    expect(schemaNames.includes('RestaurantListResponse')).toBe(true);
+    expect(pluginListResponseValue).toStrictEqual(expectedShape);
+    expect(apiListResponseValue).toStrictEqual(expectedShape);
+  });
+
+  it('builds the Request schema', () => {
+    global.strapi.plugins['users-permissions'].routes['content-api'].routes = [
+      { method: 'POST', path: '/test', handler: 'test.create' },
+    ];
+    global.strapi.api.restaurant.routes.restaurant.routes = [
+      { method: 'POST', path: '/test', handler: 'test.create' },
+    ];
+
+    const apiMocks = [
+      {
+        name: 'users-permissions',
+        getter: 'plugin',
+        ctNames: ['role'],
+      },
+      { name: 'restaurant', getter: 'api', ctNames: ['restaurant'] },
+    ];
+
+    let schemas = {};
+    for (const mock of apiMocks) {
+      schemas = {
+        ...schemas,
+        ...buildComponentSchema(mock),
+      };
+    }
+
+    const schemaNames = Object.keys(schemas);
+    const pluginListResponseValue = schemas['UsersPermissionsRoleRequest'];
+    const apiListResponseValue = schemas['RestaurantRequest'];
+
+    const expectedShape = {
+      type: 'object',
+      required: ['data'],
+      properties: {
+        data: {
+          required: [],
+          type: 'object',
+          properties: { test: { type: 'string' } },
+        },
+      },
+    };
+
+    expect(schemaNames.length).toBe(4);
+    expect(schemaNames.includes('UsersPermissionsRoleRequest')).toBe(true);
+    expect(schemaNames.includes('RestaurantRequest')).toBe(true);
+    expect(pluginListResponseValue).toStrictEqual(expectedShape);
+    expect(apiListResponseValue).toStrictEqual(expectedShape);
+  });
+
+  it('builds the LocalizationResponse schema', () => {
+    global.strapi.plugins['users-permissions'].routes['content-api'].routes = [
+      { method: 'GET', path: '/localizations', handler: 'test' },
+    ];
+    global.strapi.api.restaurant.routes.restaurant.routes = [
+      { method: 'GET', path: '/localizations', handler: 'test' },
+    ];
+
+    const apiMocks = [
+      {
+        name: 'users-permissions',
+        getter: 'plugin',
+        ctNames: ['role'],
+      },
+      { name: 'restaurant', getter: 'api', ctNames: ['restaurant'] },
+    ];
+
+    let schemas = {};
+    for (const mock of apiMocks) {
+      schemas = {
+        ...schemas,
+        ...buildComponentSchema(mock),
+      };
+    }
+
+    const schemaNames = Object.keys(schemas);
+    const pluginListResponseValue = schemas['UsersPermissionsRoleLocalizationResponse'];
+    const apiListResponseValue = schemas['RestaurantLocalizationResponse'];
+
+    const expectedShape = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        test: { type: 'string' },
+      },
+    };
+
+    expect(schemaNames.length).toBe(4);
+    expect(schemaNames.includes('UsersPermissionsRoleLocalizationResponse')).toBe(true);
+    expect(schemaNames.includes('RestaurantLocalizationResponse')).toBe(true);
+    expect(pluginListResponseValue).toStrictEqual(expectedShape);
+    expect(apiListResponseValue).toStrictEqual(expectedShape);
+  });
+
+  it('builds the LocalizationRequest schema', () => {
+    global.strapi.plugins['users-permissions'].routes['content-api'].routes = [
+      { method: 'POST', path: '/localizations', handler: 'test' },
+    ];
+    global.strapi.api.restaurant.routes.restaurant.routes = [
+      { method: 'POST', path: '/localizations', handler: 'test' },
+    ];
+
+    const apiMocks = [
+      {
+        name: 'users-permissions',
+        getter: 'plugin',
+        ctNames: ['role'],
+      },
+      { name: 'restaurant', getter: 'api', ctNames: ['restaurant'] },
+    ];
+
+    let schemas = {};
+    for (const mock of apiMocks) {
+      schemas = {
+        ...schemas,
+        ...buildComponentSchema(mock),
+      };
+    }
+
+    const schemaNames = Object.keys(schemas);
+    const pluginListResponseValue = schemas['UsersPermissionsRoleLocalizationRequest'];
+    const apiListResponseValue = schemas['RestaurantLocalizationRequest'];
+
+    const expectedShape = {
+      type: 'object',
+      required: ['locale'],
+      properties: { test: { type: 'string' } },
+    };
+
+    expect(schemaNames.length).toBe(8);
+    expect(schemaNames.includes('UsersPermissionsRoleLocalizationRequest')).toBe(true);
+    expect(schemaNames.includes('RestaurantLocalizationRequest')).toBe(true);
+    expect(pluginListResponseValue).toStrictEqual(expectedShape);
+    expect(apiListResponseValue).toStrictEqual(expectedShape);
+  });
+
+  it('creates the correct name given multiple content types', () => {
+    const apiMock = {
+      name: 'users-permissions',
+      getter: 'plugin',
+      ctNames: ['permission', 'role', 'user'],
+    };
+
+    const schemas = buildComponentSchema(apiMock);
+    const schemaNames = Object.keys(schemas);
+    const [permission, role, user] = schemaNames;
+
+    expect(schemaNames.length).toBe(3);
+    expect(permission).toBe('UsersPermissionsPermissionResponse');
+    expect(role).toBe('UsersPermissionsRoleResponse');
+    expect(user).toBe('UsersPermissionsUserResponse');
+  });
+});

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

@@ -167,7 +167,7 @@ const PluginPage = () => {
                                 icon={<Trash />}
                                 label={formatMessage(
                                   {
-                                    id: getTrad('pages.PluginPage.table.icon.delete'),
+                                    id: 'global.delete-target',
                                     defaultMessage: 'Delete {target}',
                                   },
                                   { target: `${doc.version}` }

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

@@ -92,7 +92,7 @@ const SettingsPage = () => {
                     <Stack spacing={4}>
                       <Typography variant="delta" as="h2">
                         {formatMessage({
-                          id: getTrad('pages.SettingsPage.title'),
+                          id: 'global.settings',
                           defaultMessage: 'Settings',
                         })}
                       </Typography>
@@ -125,7 +125,7 @@ const SettingsPage = () => {
                           <GridItem col={6} s={12}>
                             <TextInput
                               label={formatMessage({
-                                id: getTrad('pages.SettingsPage.password.label'),
+                                id: 'global.password',
                                 defaultMessage: 'Password',
                               })}
                               name="password"

package/admin/src/translations/dk.json

@@ -26,14 +26,11 @@
   "pages.PluginPage.Button.open": "Åben dokumentation",
   "pages.PluginPage.header.description": "Konfigurér dokumentations pluginnet",
   "pages.PluginPage.table.generated": "Sidst genereret",
-  "pages.PluginPage.table.icon.delete": "Slet {target}",
   "pages.PluginPage.table.icon.regenerate": "Regenerér {target}",
   "pages.PluginPage.table.icon.show": "Åben {target}",
   "pages.PluginPage.table.version": "Version",
   "pages.SettingsPage.Button.description": "Konfigurér dokumentations pluginnet",
   "pages.SettingsPage.header.save": "Gem",
-  "pages.SettingsPage.password.label": "Kodeord",
-  "pages.SettingsPage.title": "Indstillinger",
   "pages.SettingsPage.toggle.hint": "Gør dokumentationens endpoint privat",
   "pages.SettingsPage.toggle.label": "Begrænset adgang",
   "plugin.description.long": "Opret et OpenAPI dokument og visualisér dit API med SWAGGER UI.",

package/admin/src/translations/en.json

@@ -26,14 +26,11 @@
   "pages.PluginPage.Button.open": "Open documentation",
   "pages.PluginPage.header.description": "Configure the documentation plugin",
   "pages.PluginPage.table.generated": "Last generated",
-  "pages.PluginPage.table.icon.delete": "Delete {target}",
   "pages.PluginPage.table.icon.regenerate": "Regenerate {target}",
   "pages.PluginPage.table.icon.show": "Open {target}",
   "pages.PluginPage.table.version": "Version",
   "pages.SettingsPage.Button.description": "Configure the documentation plugin",
   "pages.SettingsPage.header.save": "Save",
-  "pages.SettingsPage.password.label": "Password",
-  "pages.SettingsPage.title": "Settings",
   "pages.SettingsPage.toggle.hint": "Make the documentation endpoint private",
   "pages.SettingsPage.toggle.label": "Restricted Access",
   "plugin.description.long": "Create an OpenAPI Document and visualize your API with SWAGGER UI.",

package/admin/src/translations/es.json

@@ -26,14 +26,11 @@
   "pages.PluginPage.Button.open": "Abrir documentación",
   "pages.PluginPage.header.description": "Configura el plugin de documentación",
   "pages.PluginPage.table.generated": "Último generado",
-  "pages.PluginPage.table.icon.delete": "Eliminar {target}",
   "pages.PluginPage.table.icon.regenerate": "Regenerar {target}",
   "pages.PluginPage.table.icon.show": "Abrir {target}",
   "pages.PluginPage.table.version": "Versión",
   "pages.SettingsPage.Button.description": "Configura el plugin de documentación",
   "pages.SettingsPage.header.save": "Guardar",
-  "pages.SettingsPage.password.label": "Contraseña",
-  "pages.SettingsPage.title": "Ajustes",
   "pages.SettingsPage.toggle.hint": "Hacer que la documentación sea privada",
   "pages.SettingsPage.toggle.label": "Acceso restringido",
   "plugin.description.long": "Cree un documento OpenAPI y visualice su API con SWAGGER UI.",

package/admin/src/translations/ko.json

@@ -26,14 +26,11 @@
   "pages.PluginPage.Button.open": "도큐멘테이션 열기",
   "pages.PluginPage.header.description": "도큐멘테이션 플러그인 설정",
   "pages.PluginPage.table.generated": "최종 생성일",
-  "pages.PluginPage.table.icon.delete": "{target} 삭제",
   "pages.PluginPage.table.icon.regenerate": "{target} 재생성",
   "pages.PluginPage.table.icon.show": "{target} 열기",
   "pages.PluginPage.table.version": "버전",
   "pages.SettingsPage.Button.description": "도큐멘테이션 플러그인 설정",
   "pages.SettingsPage.header.save": "저장",
-  "pages.SettingsPage.password.label": "비밀번호",
-  "pages.SettingsPage.title": "설정",
   "pages.SettingsPage.toggle.hint": "도큐멘테이션 엔드포인트를 비공개로 설정합니다.",
   "pages.SettingsPage.toggle.label": "액세스 제한",
   "plugin.description.long": "SWAGER UI를 사용하여 오픈 API 문서를 만들고 API를 시각화합니다.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/plugin-documentation",
-  "version": "4.2.0-beta.0",
+  "version": "4.2.0-beta.3",
   "description": "Create an OpenAPI Document and visualize your API with SWAGGER UI.",
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
     "test": "echo \"no tests yet\""
   },
   "dependencies": {
-    "@strapi/helper-plugin": "4.2.0-beta.0",
-    "@strapi/utils": "4.2.0-beta.0",
+    "@strapi/helper-plugin": "4.2.0-beta.3",
+    "@strapi/utils": "4.2.0-beta.3",
     "bcryptjs": "2.4.3",
     "cheerio": "^1.0.0-rc.5",
     "fs-extra": "10.0.0",
@@ -57,5 +57,5 @@
     "description": "Create an OpenAPI Document and visualize your API with SWAGGER UI.",
     "kind": "plugin"
   },
-  "gitHead": "db70f0de7cc73fb469c8a076b89530729cf14142"
+  "gitHead": "c4addbad6ecbc8ef7633bbba3806f3b0a2ae5f49"
 }

package/server/config/{default-config.js → default-plugin-config.js}

@@ -21,7 +21,7 @@ module.exports = {
     path: '/documentation',
     showGeneratedFiles: true,
     generateDefaultResponse: true,
-    plugins: ['email', 'upload'],
+    plugins: ['email', 'upload', 'users-permissions'],
   },
   servers: [],
   externalDocs: {
@@ -41,5 +41,34 @@ module.exports = {
         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/config/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const defaultDocumentationConfig = require('./default-config');
+const defaultPluginConfig = require('./default-plugin-config');
 
 module.exports = {
-  default: defaultDocumentationConfig,
+  default: defaultPluginConfig,
 };

package/server/controllers/documentation.js

@@ -49,7 +49,7 @@ module.exports = {
               .getDocumentationVersion();
 
       const openAPISpecsPath = path.join(
-        strapi.dirs.dist.extensions,
+        strapi.dirs.app.extensions,
         'documentation',
         'documentation',
         version,
@@ -82,7 +82,7 @@ module.exports = {
 
           try {
             const staticFolder = path.resolve(
-              strapi.dirs.dist.extensions,
+              strapi.dirs.app.extensions,
               'documentation',
               'public'
             );
@@ -120,7 +120,7 @@ module.exports = {
 
       try {
         const layoutPath = path.resolve(
-          strapi.dirs.dist.extensions,
+          strapi.dirs.app.extensions,
           'documentation',
           'public',
           'login.html'
@@ -131,7 +131,7 @@ module.exports = {
         ctx.url = path.basename(`${ctx.url}/login.html`);
 
         try {
-          const staticFolder = path.resolve(strapi.dirs.dist.extensions, 'documentation', 'public');
+          const staticFolder = path.resolve(strapi.dirs.app.extensions, 'documentation', 'public');
           return koaStatic(staticFolder)(ctx, next);
         } catch (e) {
           strapi.log.error(e);

package/server/services/documentation.js

@@ -5,8 +5,8 @@ const fs = require('fs-extra');
 const _ = require('lodash');
 const { getAbsoluteServerUrl } = require('@strapi/utils');
 
-const { builApiEndpointPath } = require('../utils/builders');
-const defaultConfig = require('../config/default-config');
+const defaultPluginConfig = require('../config/default-plugin-config');
+const { builApiEndpointPath, buildComponentSchema } = require('./helpers');
 
 module.exports = ({ strapi }) => {
   const config = strapi.config.get('plugin.documentation');
@@ -108,7 +108,7 @@ module.exports = ({ strapi }) => {
       return [...apisToDocument, ...pluginsToDocument];
     },
 
-    async getCustomSettings() {
+    async getCustomConfig() {
       const customConfigPath = this.getCustomDocumentationPath();
       const pathExists = await fs.pathExists(customConfigPath);
       if (pathExists) {
@@ -123,23 +123,31 @@ module.exports = ({ strapi }) => {
      */
     async generateFullDoc(version = this.getDocumentationVersion()) {
       let paths = {};
-
+      let schemas = {};
       const apis = this.getPluginAndApiInfo();
       for (const api of apis) {
         const apiName = api.name;
         const apiDirPath = path.join(this.getApiDocumentationPath(api), version);
 
         const apiDocPath = path.join(apiDirPath, `${apiName}.json`);
-        const apiPathsObject = builApiEndpointPath(api);
 
-        if (!apiPathsObject) {
+        const apiPath = builApiEndpointPath(api);
+
+        if (!apiPath) {
           continue;
         }
 
         await fs.ensureFile(apiDocPath);
-        await fs.writeJson(apiDocPath, apiPathsObject, { spaces: 2 });
+        await fs.writeJson(apiDocPath, apiPath, { spaces: 2 });
 
-        paths = { ...paths, ...apiPathsObject.paths };
+        const componentSchema = buildComponentSchema(api);
+
+        schemas = {
+          ...schemas,
+          ...componentSchema,
+        };
+
+        paths = { ...paths, ...apiPath };
       }
 
       const fullDocJsonPath = path.join(
@@ -148,27 +156,26 @@ module.exports = ({ strapi }) => {
         'full_documentation.json'
       );
 
-      const defaultSettings = _.cloneDeep(defaultConfig);
+      const defaultConfig = _.cloneDeep(defaultPluginConfig);
 
       const serverUrl = getAbsoluteServerUrl(strapi.config);
       const apiPath = strapi.config.get('api.rest.prefix');
 
-      _.set(defaultSettings, 'servers', [
+      _.set(defaultConfig, 'servers', [
         {
           url: `${serverUrl}${apiPath}`,
           description: 'Development server',
         },
       ]);
+      _.set(defaultConfig, ['info', 'x-generation-date'], new Date().toISOString());
+      _.set(defaultConfig, ['info', 'version'], version);
+      _.merge(defaultConfig.components, { schemas });
 
-      _.set(defaultSettings, ['info', 'x-generation-date'], new Date().toISOString());
-      _.set(defaultSettings, ['info', 'version'], version);
-
-      const customSettings = await this.getCustomSettings();
-
-      const settings = _.merge(defaultSettings, customSettings);
+      const customConfig = await this.getCustomConfig();
+      const config = _.merge(defaultConfig, customConfig);
 
       await fs.ensureFile(fullDocJsonPath);
-      await fs.writeJson(fullDocJsonPath, { ...settings, paths }, { spaces: 2 });
+      await fs.writeJson(fullDocJsonPath, { ...config, paths }, { spaces: 2 });
     },
   };
 };