@strapi/generators 4.0.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined in "ee/LICENSE".
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @strapi/generators
+
+This package contains strapi code generators available through the CLI or programmatically.
+
+## API Reference
+
+### `runCLI()`
+
+Start the generator CLI.
+
+### `generate(generatorName, options, plopOptions)`
+
+Execute a generator without interactive mode.
+
+- `generatorName` - one of `api`, `controller`, `service`, `model`, `plugin`, `policy`.
+- `options` - options are specific to each generator
+- `plopOtions`
+  - `dir`: base directory that plop will use as base directory for its actions

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

@@ -0,0 +1,26 @@
+/**
+ *
+ * Initializer
+ *
+ */
+
+import { useEffect, useRef } from 'react';
+import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef();
+  ref.current = setPlugin;
+
+  useEffect(() => {
+    ref.current(pluginId);
+  }, []);
+
+  return null;
+};
+
+Initializer.propTypes = {
+  setPlugin: PropTypes.func.isRequired,
+};
+
+export default Initializer;

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

@@ -0,0 +1,25 @@
+/**
+ *
+ * This component is the skeleton around the actual pages, and should only
+ * contain code that should be seen on all pages. (e.g. navigation bar)
+ *
+ */
+
+import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+import { NotFound } from '@strapi/helper-plugin';
+import pluginId from '../../pluginId';
+import HomePage from '../HomePage';
+
+const App = () => {
+  return (
+    <div>
+      <Switch>
+        <Route path={`/plugins/${pluginId}`} component={HomePage} exact />
+        <Route component={NotFound} />
+      </Switch>
+    </div>
+  );
+};
+
+export default App;

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

@@ -0,0 +1,20 @@
+/*
+ *
+ * HomePage
+ *
+ */
+
+import React, { memo } from 'react';
+// import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+
+const HomePage = () => {
+  return (
+    <div>
+      <h1>{pluginId}&apos;s HomePage</h1>
+      <p>Happy coding</p>
+    </div>
+  );
+};
+
+export default memo(HomePage);

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

@@ -0,0 +1,26 @@
+/**
+ *
+ * Initializer
+ *
+ */
+
+import { useEffect, useRef } from 'react';
+import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef();
+  ref.current = setPlugin;
+
+  useEffect(() => {
+    ref.current(pluginId);
+  }, []);
+
+  return null;
+};
+
+Initializer.propTypes = {
+  setPlugin: PropTypes.func.isRequired,
+};
+
+export default Initializer;

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

@@ -0,0 +1,65 @@
+import { prefixPluginTranslations } from '@strapi/helper-plugin';
+import pluginPkg from '../../package.json';
+import pluginId from './pluginId';
+import Initializer from './components/Initializer';
+
+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,
+      intlLabel: {
+        id: `${pluginId}.plugin.name`,
+        defaultMessage: name,
+      },
+      Component: async () => {
+        const component = await import(/* webpackChunkName: "[request]" */ './pages/App');
+
+        return component;
+      },
+      permissions: [
+        // Uncomment to set the permissions of the plugin here
+        // {
+        //   action: '', // the action name should be plugin::plugin-name.actionType
+        //   subject: null,
+        // },
+      ],
+    });
+    app.registerPlugin({
+      description: pluginDescription,
+      icon,
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      isRequired: pluginPkg.strapi.required || false,
+      name,
+    });
+  },
+
+  bootstrap(app) {},
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map(locale => {
+        return import(`./translations/${locale}.json`)
+          .then(({ default: data }) => {
+            return {
+              data: prefixPluginTranslations(data, pluginId),
+              locale,
+            };
+          })
+          .catch(() => {
+            return {
+              data: {},
+              locale,
+            };
+          });
+      })
+    );
+
+    return Promise.resolve(importedTrads);
+  },
+};

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

@@ -0,0 +1,25 @@
+/**
+ *
+ * This component is the skeleton around the actual pages, and should only
+ * contain code that should be seen on all pages. (e.g. navigation bar)
+ *
+ */
+
+import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+import { NotFound } from '@strapi/helper-plugin';
+import pluginId from '../../pluginId';
+import HomePage from '../HomePage';
+
+const App = () => {
+  return (
+    <div>
+      <Switch>
+        <Route path={`/plugins/${pluginId}`} component={HomePage} exact />
+        <Route component={NotFound} />
+      </Switch>
+    </div>
+  );
+};
+
+export default App;

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

@@ -0,0 +1,20 @@
+/*
+ *
+ * HomePage
+ *
+ */
+
+import React, { memo } from 'react';
+// import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+
+const HomePage = () => {
+  return (
+    <div>
+      <h1>{pluginId}&apos;s HomePage</h1>
+      <p>Happy coding</p>
+    </div>
+  );
+};
+
+export default memo(HomePage);

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

@@ -0,0 +1,5 @@
+const pluginPkg = require('../../package.json');
+
+const pluginId = pluginPkg.name.replace(/^@strapi\/plugin-/i, '');
+
+module.exports = pluginId;

package/lib/files/plugin/admin/src/translations/en.json

@@ -0,0 +1 @@
+{}

package/lib/files/plugin/admin/src/translations/fr.json

@@ -0,0 +1 @@
+{}

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

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = id => `${pluginId}.${id}`;
+
+export default getTrad;

package/lib/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { join } = require('path');
+const { Plop, run } = require('plop');
+const nodePlop = require('node-plop');
+
+/**
+ * Starts the Plop CLI programmatically
+ */
+const runCLI = () => {
+  Plop.launch({ configPath: join(__dirname, 'plopfile.js') }, env =>
+    run({ ...env, dest: join(process.cwd(), 'src') }, undefined, true)
+  );
+};
+
+/**
+ * Runs a generator programmatically without prompts
+ * @param {string} generatorName
+ * @param {Object} options generator options replacing the prompts answers
+ * @param {Object} plopOptions
+ * @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: join(dir, 'src') });
+
+  const generator = plop.getGenerator(generatorName);
+  await generator.runActions(options, {
+    onSuccess() {},
+    onFailure() {},
+    onComment() {},
+  });
+};
+
+module.exports = {
+  generate,
+  runCLI,
+};

package/lib/plopfile.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const pluralize = require('pluralize');
+
+const generateApi = require('./plops/api');
+const generateController = require('./plops/controller');
+const generateContentType = require('./plops/content-type');
+const generatePlugin = require('./plops/plugin');
+const generatePolicy = require('./plops/policy');
+const generateService = require('./plops/service');
+
+module.exports = plop => {
+  // Plop config
+  plop.setWelcomeMessage('Strapi Generators');
+  plop.addHelper('pluralize', text => pluralize(text));
+
+  // Generators
+  generateApi(plop);
+  generateController(plop);
+  generateContentType(plop);
+  generatePlugin(plop);
+  generatePolicy(plop);
+  generateService(plop);
+};

package/lib/plops/api.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const { join } = require('path');
+const fs = require('fs-extra');
+const validateInput = require('./utils/validate-input');
+
+module.exports = plop => {
+  // API generator
+  plop.setGenerator('api', {
+    description: 'Generate a basic API',
+    prompts: [
+      {
+        type: 'input',
+        name: 'id',
+        message: 'API name',
+        validate: input => validateInput(input),
+      },
+      {
+        type: 'confirm',
+        name: 'isPluginApi',
+        message: 'Is this API for a plugin?',
+      },
+      {
+        when: answers => answers.isPluginApi,
+        type: 'list',
+        name: 'plugin',
+        message: 'Plugin name',
+        async choices() {
+          const pluginsPath = join(plop.getDestBasePath(), 'plugins');
+          const exists = await fs.pathExists(pluginsPath);
+
+          if (!exists) {
+            throw Error('Couldn\'t find a "plugins" directory');
+          }
+
+          const pluginsDir = await fs.readdir(pluginsPath, { withFileTypes: true });
+          const pluginsDirContent = pluginsDir.filter(fd => fd.isDirectory());
+
+          if (pluginsDirContent.length === 0) {
+            throw Error('The "plugins" directory is empty');
+          }
+
+          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}}`;
+      }
+
+      const baseActions = [
+        {
+          type: 'add',
+          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`,
+          templateFile: 'templates/service.js.hbs',
+        },
+      ];
+
+      if (answers.isPluginApi) {
+        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}`,
+        },
+        ...baseActions,
+      ];
+    },
+  });
+};

package/lib/plops/content-type.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const getDestinationPrompts = require('./utils/get-destination-prompts');
+const getFilePath = require('./utils/get-file-path');
+const validateInput = require('./utils/validate-input');
+
+const DEFAULT_TYPES = [
+  // advanced types
+  'media',
+
+  // scalar types
+  'string',
+  'text',
+  'richtext',
+  'json',
+  'enumeration',
+  'password',
+  'email',
+  'integer',
+  'biginteger',
+  'float',
+  'decimal',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'boolean',
+];
+
+const promptConfigQuestions = (plop, inquirer) => {
+  return inquirer.prompt([
+    {
+      type: 'input',
+      name: 'id',
+      message: 'Content type name',
+      validate: input => validateInput(input),
+    },
+    {
+      type: 'list',
+      name: 'kind',
+      message: 'Please choose the model type',
+      default: 'collectionType',
+      choices: [
+        { name: 'Collection Type', value: 'collectionType' },
+        { name: 'Singe Type', value: 'singleType' },
+      ],
+      validate: input => validateInput(input),
+    },
+    ...getDestinationPrompts('model', plop.getDestBasePath()),
+    {
+      type: 'confirm',
+      name: 'useDraftAndPublish',
+      default: false,
+      message: 'Use draft and publish?',
+    },
+    {
+      type: 'confirm',
+      name: 'addAttributes',
+      message: 'Do you want to add attributes?',
+    },
+  ]);
+};
+
+const promptAttributeQuestions = inquirer => {
+  return inquirer.prompt([
+    {
+      type: 'input',
+      name: 'attributeName',
+      message: 'Name of attribute',
+      validate: input => validateInput(input),
+    },
+    {
+      type: 'list',
+      name: 'attributeType',
+      message: 'What type of attribute',
+      pageSize: DEFAULT_TYPES.length,
+      choices: DEFAULT_TYPES.map(type => {
+        return { name: type, value: type };
+      }),
+    },
+    {
+      when: answers => answers.attributeType === 'enumeration',
+      type: 'input',
+      name: 'enum',
+      message: 'Add values separated by a comma',
+    },
+    {
+      when: answers => answers.attributeType === 'media',
+      type: 'list',
+      name: 'multiple',
+      message: 'Choose media type',
+      choices: [
+        { name: 'Multiple', value: true },
+        { name: 'Single', value: false },
+      ],
+    },
+    {
+      type: 'confirm',
+      name: 'addAttributes',
+      message: 'Do you want to add another attribute?',
+    },
+  ]);
+};
+
+module.exports = plop => {
+  // Model generator
+  plop.setGenerator('content-type', {
+    description: 'Generate a content type for an API',
+    async prompts(inquirer) {
+      const config = await promptConfigQuestions(plop, inquirer);
+
+      if (!config.addAttributes) {
+        return {
+          ...config,
+          attributes: [],
+        };
+      }
+
+      const attributes = [];
+
+      const genAttribute = async () => {
+        const answers = await promptAttributeQuestions(inquirer);
+
+        attributes.push(answers);
+
+        if (answers.addAttributes) {
+          return genAttribute();
+        }
+      };
+
+      await genAttribute();
+
+      return {
+        ...config,
+        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);
+
+      return [
+        {
+          type: 'add',
+          path: `${filePath}/content-types/{{id}}/schema.json`,
+          templateFile: 'templates/model.schema.json.hbs',
+        },
+        {
+          type: 'modify',
+          path: `${filePath}/content-types/{{id}}/schema.json`,
+          transform(template) {
+            const parsedTemplate = JSON.parse(template);
+            parsedTemplate.attributes = attributes;
+            return JSON.stringify(parsedTemplate, null, 2);
+          },
+        },
+      ];
+    },
+  });
+};

package/lib/plops/controller.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const getDestinationPrompts = require('./utils/get-destination-prompts');
+const getFilePath = require('./utils/get-file-path');
+const validateInput = require('./utils/validate-input');
+
+module.exports = plop => {
+  // Controller generator
+  plop.setGenerator('controller', {
+    description: 'Generate a controller for an API',
+    prompts: [
+      {
+        type: 'input',
+        name: 'id',
+        message: 'Controller name',
+        validate: input => validateInput(input),
+      },
+      ...getDestinationPrompts('controller', plop.getDestBasePath()),
+    ],
+    actions(answers) {
+      const filePath = getFilePath(answers.destination);
+
+      return [
+        {
+          type: 'add',
+          path: `${filePath}/controllers/{{id}}.js`,
+          templateFile: 'templates/controller.js.hbs',
+        },
+      ];
+    },
+  });
+};

package/lib/plops/plugin.js

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = plop => {
+  // Plugin generator
+  plop.setGenerator('plugin', {
+    description: 'Generate a basic plugin',
+    prompts: [
+      {
+        type: 'input',
+        name: 'id',
+        message: 'Plugin name',
+      },
+    ],
+    actions() {
+      return [
+        {
+          type: 'addMany',
+          destination: 'plugins/{{id}}/admin',
+          base: 'files/plugin/admin',
+          templateFiles: 'files/plugin/admin/**',
+        },
+        {
+          type: 'add',
+          path: 'plugins/{{id}}/services/{{id}}.js',
+          templateFile: 'templates/service.js.hbs',
+        },
+        {
+          type: 'add',
+          path: 'plugins/{{id}}/controllers/{{id}}.js',
+          templateFile: 'templates/controller.js.hbs',
+        },
+        {
+          type: 'add',
+          path: 'plugins/{{id}}/config/routes.json',
+          templateFile: 'templates/plugin-routes.json.hbs',
+        },
+        {
+          type: 'add',
+          path: 'plugins/{{id}}/README.md',
+          templateFile: 'templates/README.md.hbs',
+        },
+        {
+          type: 'add',
+          path: 'plugins/{{id}}/package.json',
+          templateFile: 'templates/plugin-package.json.hbs',
+        },
+      ];
+    },
+  });
+};

package/lib/plops/policy.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const getDestinationPrompts = require('./utils/get-destination-prompts');
+
+module.exports = plop => {
+  // Policy generator
+  plop.setGenerator('policy', {
+    description: 'Generate a policy for an API',
+    prompts: [
+      {
+        type: 'input',
+        name: 'id',
+        message: 'Policy name',
+      },
+      ...getDestinationPrompts('policy', plop.getDestBasePath()),
+    ],
+    actions(answers) {
+      let filePath;
+      if (answers.destination === 'api') {
+        filePath = `api/{{api}}`;
+      } else if (answers.destination === 'plugin') {
+        filePath = `plugins/{{plugin}}`;
+      } else {
+        filePath = `./`;
+      }
+
+      return [
+        {
+          type: 'add',
+          path: `${filePath}/policies/{{id}}.js`,
+          templateFile: 'templates/policy.js.hbs',
+        },
+      ];
+    },
+  });
+};

package/lib/plops/service.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const getDestinationPrompts = require('./utils/get-destination-prompts');
+const getFilePath = require('./utils/get-file-path');
+
+module.exports = plop => {
+  // Service generator
+  plop.setGenerator('service', {
+    description: 'Generate a service for an API',
+    prompts: [
+      {
+        type: 'input',
+        name: 'id',
+        message: 'Service name',
+      },
+      ...getDestinationPrompts('service', plop.getDestBasePath()),
+    ],
+    actions(answers) {
+      const filePath = getFilePath(answers.destination);
+      return [
+        {
+          type: 'add',
+          path: `${filePath}/services/{{id}}.js`,
+          templateFile: 'templates/service.js.hbs',
+        },
+      ];
+    },
+  });
+};

package/lib/plops/utils/get-destination-prompts.js

@@ -0,0 +1,69 @@
+'use strict';
+const { join } = require('path');
+const fs = require('fs-extra');
+
+module.exports = (action, basePath) => {
+  return [
+    {
+      type: 'list',
+      name: 'destination',
+      message: `Where do you want to add this ${action}?`,
+      choices: [
+        {
+          name: `Add ${action} to ${action === 'policy' ? 'root of project' : 'new API'}`,
+          value: 'new',
+        },
+        { name: `Add ${action} to an existing API`, value: 'api' },
+        { name: `Add ${action} to an existing plugin`, value: 'plugin' },
+      ],
+    },
+    {
+      when: answers => answers.destination === 'api',
+      type: 'list',
+      message: 'Which API is this for?',
+      name: 'api',
+      async choices() {
+        const apiPath = join(basePath, 'api');
+        const exists = await fs.pathExists(apiPath);
+
+        if (!exists) {
+          throw Error('Couldn\'t find an "api" directory');
+        }
+
+        const apiDir = await fs.readdir(apiPath, { withFileTypes: true });
+        const apiDirContent = apiDir.filter(fd => fd.isDirectory());
+
+        if (apiDirContent.length === 0) {
+          throw Error('The "api" directory is empty');
+        }
+
+        return apiDirContent;
+      },
+    },
+    {
+      when: answers => answers.destination === 'plugin',
+      type: 'list',
+      message: 'Which plugin is this for?',
+      name: 'plugin',
+      async choices() {
+        const pluginsPath = join(basePath, 'plugins');
+        const exists = await fs.pathExists(pluginsPath);
+
+        if (!exists) {
+          throw Error('Couldn\'t find a "plugins" directory');
+        }
+
+        const pluginsDir = await fs.readdir(pluginsPath);
+        const pluginsDirContent = pluginsDir.filter(api =>
+          fs.lstatSync(join(pluginsPath, api)).isDirectory()
+        );
+
+        if (pluginsDirContent.length === 0) {
+          throw Error('The "plugins" directory is empty');
+        }
+
+        return pluginsDirContent;
+      },
+    },
+  ];
+};

package/lib/plops/utils/get-file-path.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = destination => {
+  if (destination === 'api') {
+    return `api/{{api}}`;
+  }
+
+  if (destination === 'plugin') {
+    return `plugins/{{plugin}}`;
+  }
+
+  return `api/{{id}}`;
+};

package/lib/plops/utils/validate-input.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = input => {
+  const regex = /^[A-Za-z-]+$/g;
+
+  if (!input) {
+    return 'You must provide an input';
+  }
+
+  return regex.test(input) || 'Please use only letters and no spaces';
+};

package/lib/templates/README.md.hbs

@@ -0,0 +1,3 @@
+# Strapi plugin {{id}}
+
+A quick description of {{id}}.

package/lib/templates/collection-type-routes.js.hbs

@@ -0,0 +1,44 @@
+module.exports = {
+  routes: [
+    {
+      method: 'GET',
+      path: '/{{pluralize id}}',
+      handler: '{{id}}.find',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'GET',
+      path: '/{{pluralize id}}/:id',
+      handler: '{{id}}.findOne',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'POST',
+      path: '/{{pluralize id}}',
+      handler: '{{id}}.create',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'PUT',
+      path: '/{{pluralize id}}/:id',
+      handler: '{{id}}.update',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'DELETE',
+      path: '/{{pluralize id}}/:id',
+      handler: '{{id}}.delete',
+      config: {
+        policies: [],
+      },
+    },
+  ],
+};

package/lib/templates/controller.js.hbs

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * A set of functions called "actions" for `{{id}}`
+ */
+
+module.exports = {
+  // exampleAction: async (ctx, next) => {
+  //   try {
+  //     ctx.body = 'ok';
+  //   } catch (err) {
+  //     ctx.body = err;
+  //   }
+  // }
+};

package/lib/templates/model.schema.json.hbs

@@ -0,0 +1,16 @@
+
+{
+  "kind": "{{kind}}",
+  "collectionName": "{{id}}",
+  "info": {
+    "singularName": "{{id}}",
+    "pluralName": "{{pluralize id}}",
+    "displayName": "{{id}}",
+    "name": "{{id}}"
+  },
+  "options": {
+    "draftAndPublish": {{ useDraftAndPublish }},
+    "comment": ""
+  },
+  "attributes": {}
+}

package/lib/templates/plugin-package.json.hbs

@@ -0,0 +1,28 @@
+{
+  "name": "strapi-plugin-{{id}}",
+  "version": "0.0.0",
+  "description": "This is the description of the plugin.",
+  "strapi": {
+    "name": "{{id}}",
+    "icon": "plug",
+    "description": "Description of {{id}} plugin."
+  },
+  "dependencies": {},
+  "author": {
+    "name": "A Strapi developer",
+    "email": "",
+    "url": ""
+  },
+  "maintainers": [
+    {
+      "name": "A Strapi developer",
+      "email": "",
+      "url": ""
+    }
+  ],
+  "engines": {
+    "node": ">=12.x. <=16.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "MIT"
+}

package/lib/templates/plugin-routes.json.hbs

@@ -0,0 +1,12 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/",
+      "handler": "{{id}}.index",
+      "config": {
+        "policies": []
+      }
+    }
+  ]
+}

package/lib/templates/policy.js.hbs

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * `{{id}}` policy.
+ */
+
+module.exports = async (ctx) => {
+  // Add your own logic here.
+  console.log('In {{id}} policy.');
+
+  const canDoSomething = true;
+
+  if (canDoSomething) {
+    return true;
+  }
+
+  return false;
+};

package/lib/templates/service.js.hbs

@@ -0,0 +1,7 @@
+'use strict';
+
+/**
+ * {{id}} service.
+ */
+
+module.exports = () => ({});

package/lib/templates/single-type-routes.js.hbs

@@ -0,0 +1,28 @@
+module.exports = {
+  routes: [
+    {
+      method: 'GET',
+      path: '/{{id}}',
+      handler: '{{id}}.find',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'PUT',
+      path: '/{{id}}',
+      handler: '{{id}}.update',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'DELETE',
+      path: '/{{id}}',
+      handler: '{{id}}.delete',
+      config: {
+        policies: [],
+      },
+    },
+  ],
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@strapi/generators",
+  "version": "4.0.0-beta.0",
+  "description": "Interactive API generator.",
+  "keywords": [
+    "strapi",
+    "generators"
+  ],
+  "homepage": "https://strapi.io",
+  "bugs": {
+    "url": "https://github.com/strapi/strapi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Strapi team",
+    "email": "hi@strapi.io",
+    "url": "https://strapi.io"
+  },
+  "maintainers": [
+    {
+      "name": "Strapi team",
+      "email": "hi@strapi.io",
+      "url": "https://strapi.io"
+    }
+  ],
+  "main": "lib/index.js",
+  "dependencies": {
+    "fs-extra": "10.0.0",
+    "node-plop": "0.26.2",
+    "plop": "2.7.4",
+    "pluralize": "8.0.0"
+  },
+  "engines": {
+    "node": ">=12.x.x <=16.x.x",
+    "npm": ">=6.0.0"
+  },
+  "gitHead": "9807c78cb7ab6373b7abb46da5ecc4980a9ea56c"
+}