@strapi/generators 4.0.0-next.9 → 4.0.3

package/lib/files/plugin/admin/src/components/PluginIcon/index.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * PluginIcon
+ *
+ */
+
+import React from 'react';
+import Puzzle from '@strapi/icons/Puzzle';
+
+const PluginIcon = () => <Puzzle />;
+
+export default PluginIcon;

package/lib/files/plugin/admin/src/index.js

@@ -2,16 +2,15 @@ import { prefixPluginTranslations } from '@strapi/helper-plugin';
 import pluginPkg from '../../package.json';
 import pluginId from './pluginId';
 import Initializer from './components/Initializer';
+import PluginIcon from './components/PluginIcon';
 
-const pluginDescription = pluginPkg.strapi.description || pluginPkg.description;
-const icon = pluginPkg.strapi.icon;
 const name = pluginPkg.strapi.name;
 
 export default {
   register(app) {
     app.addMenuLink({
       to: `/plugins/${pluginId}`,
-      icon,
+      icon: PluginIcon,
       intlLabel: {
         id: `${pluginId}.plugin.name`,
         defaultMessage: name,
@@ -30,12 +29,9 @@ export default {
       ],
     });
     app.registerPlugin({
-      description: pluginDescription,
-      icon,
       id: pluginId,
       initializer: Initializer,
       isReady: false,
-      isRequired: pluginPkg.strapi.required || false,
       name,
     });
   },

package/lib/files/plugin/admin/src/utils/axiosInstance.js

@@ -0,0 +1,40 @@
+/**
+ * axios with a custom config.
+ */
+
+import axios from 'axios';
+import { auth } from '@strapi/helper-plugin';
+
+const instance = axios.create({
+  baseURL: process.env.STRAPI_ADMIN_BACKEND_URL,
+});
+
+instance.interceptors.request.use(
+  async config => {
+    config.headers = {
+      Authorization: `Bearer ${auth.getToken()}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+
+    return config;
+  },
+  error => {
+    Promise.reject(error);
+  }
+);
+
+instance.interceptors.response.use(
+  response => response,
+  error => {
+    // whatever you want to do with the error
+    if (error.response?.status === 401) {
+      auth.clearAppStorage();
+      window.location.reload();
+    }
+
+    throw error;
+  }
+);
+
+export default instance;

package/lib/files/plugin/server/bootstrap.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // bootstrap phase
+};

package/lib/files/plugin/server/config/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  default: {},
+  validator() {},
+};

package/lib/files/plugin/server/controllers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const myController = require('./my-controller');
+
+module.exports = {
+  myController,
+};

package/lib/files/plugin/server/controllers/my-controller.js.hbs

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  index(ctx) {
+    ctx.body = strapi
+      .plugin('{{ pluginName }}')
+      .service('myService')
+      .getWelcomeMessage();
+  },
+};

package/lib/files/plugin/server/destroy.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // destroy phase
+};

package/lib/files/plugin/server/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const services = require('./services');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes: {},
+  policies: {},
+  middlewares: {},
+};

package/lib/files/plugin/server/register.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // registeration phase
+};

package/lib/files/plugin/server/routes/index.js

@@ -0,0 +1,10 @@
+module.exports = [
+  {
+    method: 'GET',
+    path: '/',
+    handler: 'myController.index',
+    config: {
+      policies: [],
+    },
+  },
+];

package/lib/files/plugin/server/services/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const myService = require('./my-service');
+
+module.exports = {
+  myService,
+};

package/lib/files/plugin/server/services/my-service.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = ({ strapi }) => ({
+  getWelcomeMessage() {
+    return 'Welcome to Strapi 🚀';
+  },
+});

package/lib/files/plugin/strapi-admin.js

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

package/lib/files/plugin/strapi-server.js

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

package/lib/index.js

@@ -9,7 +9,7 @@ const nodePlop = require('node-plop');
  */
 const runCLI = () => {
   Plop.launch({ configPath: join(__dirname, 'plopfile.js') }, env =>
-    run({ ...env, dest: process.cwd() }, undefined, true)
+    run({ ...env, dest: join(process.cwd(), 'src') }, undefined, true)
   );
 };
 
@@ -21,13 +21,13 @@ const runCLI = () => {
  * @param {string} plopOptions.dir base path for plop to generate the files from
  */
 const generate = async (generatorName, options, { dir = process.cwd() } = {}) => {
-  const plop = nodePlop(join(__dirname, 'plopfile.js'), { destBasePath: dir });
+  const plop = nodePlop(join(__dirname, 'plopfile.js'), { destBasePath: join(dir, 'src') });
 
   const generator = plop.getGenerator(generatorName);
   await generator.runActions(options, {
-    onSuccess: () => {},
-    onFailure: () => {},
-    onComment: () => {},
+    onSuccess() {},
+    onFailure() {},
+    onComment() {},
   });
 };
 

package/lib/plopfile.js

@@ -4,9 +4,10 @@ const pluralize = require('pluralize');
 
 const generateApi = require('./plops/api');
 const generateController = require('./plops/controller');
-const generateModel = require('./plops/model');
+const generateContentType = require('./plops/content-type');
 const generatePlugin = require('./plops/plugin');
 const generatePolicy = require('./plops/policy');
+const generateMiddleware = require('./plops/middleware');
 const generateService = require('./plops/service');
 
 module.exports = plop => {
@@ -17,8 +18,9 @@ module.exports = plop => {
   // Generators
   generateApi(plop);
   generateController(plop);
-  generateModel(plop);
+  generateContentType(plop);
   generatePlugin(plop);
   generatePolicy(plop);
+  generateMiddleware(plop);
   generateService(plop);
 };

package/lib/plops/__tests__/content-type.test.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const path = require('path');
+const { readFile, rm, stat } = require('fs-extra');
+const strapiGenerators = require('../../index');
+
+describe('Content Type Generator', () => {
+  const outputDirectory = path.join(__dirname, 'output');
+
+  afterEach(async () => {
+    await rm(outputDirectory, { recursive: true, force: true });
+  });
+
+  test('it generates the schema', async () => {
+    await strapiGenerators.generate(
+      'content-type',
+      {
+        displayName: 'testContentType',
+        singularName: 'testContentType',
+        pluralName: 'testContentTypes',
+        kind: 'singleType',
+        id: 'testContentType',
+        useDraftAndPublish: false,
+        destination: 'new',
+        bootstrapApi: false,
+        attributes: [],
+      },
+      { dir: outputDirectory }
+    );
+
+    const generatedSchemaPath = path.join(
+      outputDirectory,
+      'src/api/testContentType',
+      'content-types/testContentType/schema.json'
+    );
+
+    expect((await stat(generatedSchemaPath)).isFile()).toBeTruthy();
+
+    const fileContent = await readFile(generatedSchemaPath, 'utf-8');
+
+    expect(fileContent).not.toBeNull();
+
+    const schema = JSON.parse(fileContent.toString());
+
+    expect(schema).toStrictEqual({
+      kind: 'singleType',
+      collectionName: 'test_content_types',
+      info: {
+        singularName: 'testContentType',
+        pluralName: 'testContentTypes',
+        displayName: 'testContentType',
+      },
+      options: {
+        draftAndPublish: false,
+        comment: '',
+      },
+      attributes: {},
+    });
+  });
+
+  test('it scaffolds a new API', async () => {
+    await strapiGenerators.generate(
+      'content-type',
+      {
+        displayName: 'testContentType',
+        singularName: 'testContentType',
+        pluralName: 'testContentTypes',
+        kind: 'singleType',
+        id: 'testContentType',
+        useDraftAndPublish: false,
+        destination: 'new',
+        bootstrapApi: true,
+        attributes: [],
+      },
+      { dir: outputDirectory }
+    );
+    const generatedApiPath = path.join(outputDirectory, 'src/api/testContentType');
+
+    expect((await stat(generatedApiPath)).isDirectory()).toBeTruthy();
+    expect(
+      (await stat(path.join(generatedApiPath, 'controllers/testContentType.js'))).isFile()
+    ).toBeTruthy();
+    expect(
+      (await stat(path.join(generatedApiPath, 'services/testContentType.js'))).isFile()
+    ).toBeTruthy();
+    expect(
+      (await stat(path.join(generatedApiPath, 'routes/testContentType.js'))).isFile()
+    ).toBeTruthy();
+
+    const controller = await readFile(
+      path.join(generatedApiPath, 'controllers/testContentType.js')
+    );
+    const router = await readFile(path.join(generatedApiPath, 'routes/testContentType.js'));
+    const service = await readFile(path.join(generatedApiPath, 'services/testContentType.js'));
+
+    expect(controller.toString()).toMatchInlineSnapshot(`
+      "'use strict';
+
+      /**
+       *  testContentType controller
+       */
+
+      const { createCoreController } = require('@strapi/strapi').factories;
+
+      module.exports = createCoreController('api::testContentType.testContentType');
+      "
+    `);
+    expect(router.toString()).toMatchInlineSnapshot(`
+      "'use strict';
+
+      /**
+       * testContentType router.
+       */
+
+      const { createCoreRouter } = require('@strapi/strapi').factories;
+
+      module.exports = createCoreRouter('api::testContentType.testContentType');
+      "
+    `);
+    expect(service.toString()).toMatchInlineSnapshot(`
+      "'use strict';
+
+      /**
+       * testContentType service.
+       */
+
+      const { createCoreService } = require('@strapi/strapi').factories;
+
+      module.exports = createCoreService('api::testContentType.testContentType');
+      "
+    `);
+  });
+
+  test('it generates the schema, then adds the attributes', async () => {
+    await strapiGenerators.generate(
+      'content-type',
+      {
+        displayName: 'testContentType',
+        singularName: 'testContentType',
+        pluralName: 'testContentTypes',
+        kind: 'singleType',
+        id: 'testContentType',
+        useDraftAndPublish: false,
+        destination: 'new',
+        bootstrapApi: false,
+        attributes: [
+          {
+            attributeName: 'name',
+            attributeType: 'string',
+          },
+          {
+            attributeName: 'email',
+            attributeType: 'string',
+          },
+        ],
+      },
+      { dir: outputDirectory }
+    );
+
+    const generatedSchemaPath = path.join(
+      outputDirectory,
+      'src/api/testContentType',
+      'content-types/testContentType/schema.json'
+    );
+
+    expect((await stat(generatedSchemaPath)).isFile()).toBeTruthy();
+
+    const fileContent = await readFile(generatedSchemaPath, 'utf-8');
+
+    expect(fileContent).not.toBeNull();
+
+    const schema = JSON.parse(fileContent.toString());
+
+    expect(schema.attributes).toStrictEqual({
+      email: { type: 'string' },
+      name: { type: 'string' },
+    });
+  });
+});

package/lib/plops/api.js

@@ -25,7 +25,7 @@ module.exports = plop => {
         type: 'list',
         name: 'plugin',
         message: 'Plugin name',
-        choices: async () => {
+        async choices() {
           const pluginsPath = join(plop.getDestBasePath(), 'plugins');
           const exists = await fs.pathExists(pluginsPath);
 
@@ -43,30 +43,9 @@ module.exports = plop => {
           return pluginsDirContent;
         },
       },
-      {
-        type: 'list',
-        name: 'kind',
-        message: 'Please choose the model type',
-        default: 'collectionType',
-        choices: [
-          { name: 'Collection Type', value: 'collectionType' },
-          { name: 'Singe Type', value: 'singleType' },
-        ],
-      },
-      {
-        type: 'confirm',
-        name: 'useDraftAndPublish',
-        default: false,
-        message: 'Use draft and publish?',
-      },
     ],
-    actions: answers => {
-      let filePath;
-      if (answers.isPluginApi && answers.plugin) {
-        filePath = `plugins/{{plugin}}`;
-      } else {
-        filePath = `api/{{id}}`;
-      }
+    actions(answers) {
+      const filePath = answers.isPluginApi && answers.plugin ? 'plugins/{{plugin}}' : 'api/{{id}}';
 
       const baseActions = [
         {
@@ -74,11 +53,6 @@ module.exports = plop => {
           path: `${filePath}/controllers/{{id}}.js`,
           templateFile: 'templates/controller.js.hbs',
         },
-        {
-          type: 'add',
-          path: `${filePath}/content-types/{{id}}/schema.json`,
-          templateFile: 'templates/model.schema.json.hbs',
-        },
         {
           type: 'add',
           path: `${filePath}/services/{{id}}.js`,
@@ -90,16 +64,11 @@ module.exports = plop => {
         return baseActions;
       }
 
-      const routeType =
-        answers.kind === 'singleType'
-          ? 'single-type-routes.js.hbs'
-          : 'collection-type-routes.js.hbs';
-
       return [
         {
           type: 'add',
           path: `${filePath}/routes/{{id}}.js`,
-          templateFile: `templates/${routeType}`,
+          templateFile: `templates/single-route.js.hbs`,
         },
         ...baseActions,
       ];

package/lib/plops/content-type.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { join } = require('path');
+const slugify = require('@sindresorhus/slugify');
+const fs = require('fs-extra');
+const { isKebabCase } = require('@strapi/utils');
+
+const getDestinationPrompts = require('./prompts/get-destination-prompts');
+const getFilePath = require('./utils/get-file-path');
+const ctNamesPrompts = require('./prompts/ct-names-prompts');
+const kindPrompts = require('./prompts/kind-prompts');
+const draftAndPublishPrompts = require('./prompts/draft-and-publish-prompts');
+const getAttributesPrompts = require('./prompts/get-attributes-prompts');
+const bootstrapApiPrompts = require('./prompts/bootstrap-api-prompts');
+
+module.exports = plop => {
+  // Model generator
+  plop.setGenerator('content-type', {
+    description: 'Generate a content type for an API',
+    async prompts(inquirer) {
+      const config = await inquirer.prompt([
+        ...ctNamesPrompts,
+        ...kindPrompts,
+        ...draftAndPublishPrompts,
+      ]);
+      const attributes = await getAttributesPrompts(inquirer);
+
+      const api = await inquirer.prompt([
+        ...getDestinationPrompts('model', plop.getDestBasePath()),
+        {
+          when: answers => answers.destination === 'new',
+          type: 'input',
+          name: 'id',
+          default: config.singularName,
+          message: 'Name of the new API?',
+          async validate(input) {
+            if (!isKebabCase(input)) {
+              return 'Value must be in kebab-case';
+            }
+
+            const apiPath = join(plop.getDestBasePath(), 'api');
+            const exists = await fs.pathExists(apiPath);
+
+            if (!exists) {
+              return true;
+            }
+
+            const apiDir = await fs.readdir(apiPath, { withFileTypes: true });
+            const apiDirContent = apiDir.filter(fd => fd.isDirectory());
+
+            if (apiDirContent.findIndex(api => api.name === input) !== -1) {
+              throw new Error('This name is already taken.');
+            }
+
+            return true;
+          },
+        },
+        ...bootstrapApiPrompts,
+      ]);
+
+      return {
+        ...config,
+        ...api,
+        attributes,
+      };
+    },
+    actions(answers) {
+      const attributes = answers.attributes.reduce((object, answer) => {
+        const val = { type: answer.attributeType };
+
+        if (answer.attributeType === 'enumeration') {
+          val.enum = answer.enum.split(',').map(item => item.trim());
+        }
+
+        if (answer.attributeType === 'media') {
+          val.allowedTypes = ['images', 'files', 'videos'];
+          val.multiple = answer.multiple;
+        }
+
+        return Object.assign(object, { [answer.attributeName]: val }, {});
+      }, {});
+
+      const filePath = getFilePath(answers.destination);
+
+      const baseActions = [
+        {
+          type: 'add',
+          path: `${filePath}/content-types/{{ singularName }}/schema.json`,
+          templateFile: 'templates/content-type.schema.json.hbs',
+          data: {
+            collectionName: slugify(answers.pluralName, { separator: '_' }),
+          },
+        },
+      ];
+
+      if (Object.entries(attributes).length > 0) {
+        baseActions.push({
+          type: 'modify',
+          path: `${filePath}/content-types/{{ singularName }}/schema.json`,
+          transform(template) {
+            const parsedTemplate = JSON.parse(template);
+            parsedTemplate.attributes = attributes;
+            return JSON.stringify(parsedTemplate, null, 2);
+          },
+        });
+      }
+
+      if (answers.bootstrapApi) {
+        const { singularName } = answers;
+
+        let uid;
+        if (answers.destination === 'new') {
+          uid = `api::${answers.id}.${singularName}`;
+        } else if (answers.api) {
+          uid = `api::${answers.api}.${singularName}`;
+        } else if (answers.plugin) {
+          uid = `plugin::${answers.plugin}.${singularName}`;
+        }
+
+        baseActions.push(
+          {
+            type: 'add',
+            path: `${filePath}/controllers/{{singularName}}.js`,
+            templateFile: 'templates/core-controller.js.hbs',
+            data: { uid },
+          },
+          {
+            type: 'add',
+            path: `${filePath}/services/{{singularName}}.js`,
+            templateFile: 'templates/core-service.js.hbs',
+            data: { uid },
+          },
+          {
+            type: 'add',
+            path: `${filePath}/routes/{{singularName}}.js`,
+            templateFile: `templates/core-router.js.hbs`,
+            data: { uid },
+          }
+        );
+      }
+
+      return baseActions;
+    },
+  });
+};

package/lib/plops/controller.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const getDestinationPrompts = require('./utils/get-destination-prompts');
+const getDestinationPrompts = require('./prompts/get-destination-prompts');
 const getFilePath = require('./utils/get-file-path');
 const validateInput = require('./utils/validate-input');
 
@@ -17,13 +17,13 @@ module.exports = plop => {
       },
       ...getDestinationPrompts('controller', plop.getDestBasePath()),
     ],
-    actions: answers => {
+    actions(answers) {
       const filePath = getFilePath(answers.destination);
 
       return [
         {
           type: 'add',
-          path: `${filePath}/controllers/{{id}}.js`,
+          path: `${filePath}/controllers/{{ id }}.js`,
           templateFile: 'templates/controller.js.hbs',
         },
       ];