@strapi/generators 0.0.0-next.f45143c5e2a8a9d85691d0abf79a3f42024a0c71 → 0.0.0-next.f5b09a8e61e059f02784478e27c310c6290be088

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

@@ -1,179 +0,0 @@
-'use strict';
-
-const path = require('path');
-const { readFile, remove, stat } = require('fs-extra');
-const strapiGenerators = require('../../index');
-
-describe('Content Type Generator', () => {
-  const outputDirectory = path.join(__dirname, 'output');
-
-  afterEach(async () => {
-    await remove(outputDirectory);
-  });
-
-  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

@@ -1,82 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const fs = require('fs-extra');
-const tsUtils = require('@strapi/typescript-utils');
-
-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;
-        },
-      },
-    ],
-    actions(answers) {
-      const filePath =
-        answers.isPluginApi && answers.plugin ? 'plugins/{{ plugin }}' : 'api/{{ id }}';
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-
-      const baseActions = [
-        {
-          type: 'add',
-          path: `${filePath}/controllers/{{ id }}.${language}`,
-          templateFile: `templates/${language}/controller.${language}.hbs`,
-        },
-        {
-          type: 'add',
-          path: `${filePath}/services/{{ id }}.${language}`,
-          templateFile: `templates/${language}/service.${language}.hbs`,
-        },
-      ];
-
-      if (answers.isPluginApi) {
-        return baseActions;
-      }
-
-      return [
-        {
-          type: 'add',
-          path: `${filePath}/routes/{{ id }}.${language}`,
-          templateFile: `templates/${language}/single-route.${language}.hbs`,
-        },
-        ...baseActions,
-      ];
-    },
-  });
-};

package/lib/plops/content-type.js

@@ -1,148 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const slugify = require('@sindresorhus/slugify');
-const fs = require('fs-extra');
-const { isKebabCase } = require('@strapi/utils');
-const tsUtils = require('@strapi/typescript-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', 'audios'];
-          val.multiple = answer.multiple;
-        }
-
-        return Object.assign(object, { [answer.attributeName]: val }, {});
-      }, {});
-
-      const filePath = getFilePath(answers.destination);
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-
-      const baseActions = [
-        {
-          type: 'add',
-          path: `${filePath}/content-types/{{ singularName }}/schema.json`,
-          templateFile: `templates/${language}/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 }}.${language}`,
-            templateFile: `templates/${language}/core-controller.${language}.hbs`,
-            data: { uid },
-          },
-          {
-            type: 'add',
-            path: `${filePath}/services/{{ singularName }}.${language}`,
-            templateFile: `templates/${language}/core-service.${language}.hbs`,
-            data: { uid },
-          },
-          {
-            type: 'add',
-            path: `${filePath}/routes/{{ singularName }}.${language}`,
-            templateFile: `templates/${language}/core-router.${language}.hbs`,
-            data: { uid },
-          }
-        );
-      }
-
-      return baseActions;
-    },
-  });
-};

package/lib/plops/controller.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const tsUtils = require('@strapi/typescript-utils');
-
-const getDestinationPrompts = require('./prompts/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);
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-
-      return [
-        {
-          type: 'add',
-          path: `${filePath}/controllers/{{ id }}.${language}`,
-          templateFile: `templates/${language}/controller.${language}.hbs`,
-        },
-      ];
-    },
-  });
-};

package/lib/plops/middleware.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const tsUtils = require('@strapi/typescript-utils');
-
-const getDestinationPrompts = require('./prompts/get-destination-prompts');
-const validateInput = require('./utils/validate-input');
-const getFilePath = require('./utils/get-file-path');
-
-module.exports = (plop) => {
-  // middleware generator
-  plop.setGenerator('middleware', {
-    description: 'Generate a middleware for an API',
-    prompts: [
-      {
-        type: 'input',
-        name: 'name',
-        message: 'Middleware name',
-        validate: (input) => validateInput(input),
-      },
-      ...getDestinationPrompts('middleware', plop.getDestBasePath(), { rootFolder: true }),
-    ],
-    actions(answers) {
-      const filePath = getFilePath(answers.destination);
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-
-      return [
-        {
-          type: 'add',
-          path: `${filePath}/middlewares/{{ name }}.${language}`,
-          templateFile: `templates/${language}/middleware.${language}.hbs`,
-        },
-      ];
-    },
-  });
-};

package/lib/plops/migration.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const tsUtils = require('@strapi/typescript-utils');
-const validateFileNameInput = require('./utils/validate-file-name-input');
-const getFormattedDate = require('./utils/get-formatted-date');
-
-module.exports = (plop) => {
-  // Migration generator
-  plop.setGenerator('migration', {
-    description: 'Generate a migration',
-    prompts: [
-      {
-        type: 'input',
-        name: 'name',
-        message: 'Migration name',
-        validate: (input) => validateFileNameInput(input),
-      },
-    ],
-    actions() {
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-      const timestamp = getFormattedDate();
-
-      return [
-        {
-          type: 'add',
-          path: `${currentDir}/database/migrations/${timestamp}.{{ name }}.${language}`,
-          templateFile: `templates/${language}/migration.${language}.hbs`,
-        },
-      ];
-    },
-  });
-};

package/lib/plops/plugin.js

@@ -1,91 +0,0 @@
-'use strict';
-
-const chalk = require('chalk');
-const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
-const { isKebabCase, toKebabCase } = require('@strapi/utils');
-
-const validateInput = require('./utils/validate-input');
-
-const LANGUAGES = {
-  javascript: 'JavaScript',
-  typescript: 'TypeScript',
-};
-
-const logInstructions = (pluginName, { language }) => {
-  const maxLength = `    resolve: './src/plugins/${pluginName}'`.length;
-  const separator = Array(maxLength).fill('─').join('');
-
-  const exportInstruction = language === 'js' ? 'module.exports =' : 'export default';
-
-  return `
-You can now enable your plugin by adding the following in ${chalk.yellow(
-    `./config/plugins.${language}`
-  )}
-${separator}
-${exportInstruction} {
-  ${chalk.gray('// ...')}
-  ${chalk.green(`'${pluginName}'`)}: {
-    enabled: ${chalk.yellow(true)},
-    resolve: ${chalk.yellow(`'./src/plugins/${pluginName}'`)}
-  },
-  ${chalk.gray('// ...')}
-}
-${separator}
-`;
-};
-
-module.exports = (plop) => {
-  // Plugin generator
-  plop.setGenerator('plugin', {
-    description: 'Generate a basic plugin',
-    prompts: [
-      {
-        type: 'input',
-        name: 'pluginName',
-        message: 'Plugin name',
-        validate: (input) => validateInput(input),
-      },
-      {
-        type: 'list',
-        name: 'language',
-        message: 'Choose your preferred language',
-        choices: Object.values(LANGUAGES),
-        default: LANGUAGES.javascript,
-      },
-    ],
-    actions(answers) {
-      const isTypescript = answers.language === LANGUAGES.typescript;
-      const language = isTypescript ? 'ts' : 'js';
-      const projectLanguage = isUsingTypeScriptSync(process.cwd()) ? 'ts' : 'js';
-
-      if (!isKebabCase(answers.pluginName)) {
-        answers.pluginName = toKebabCase(answers.pluginName);
-        console.log(
-          chalk.yellow(
-            `Strapi only supports kebab-cased names for plugins.\nYour plugin has been automatically renamed to "${answers.pluginName}".`
-          )
-        );
-      }
-
-      return [
-        {
-          type: 'addMany',
-          destination: 'plugins/{{ pluginName }}',
-          base: `files/${language}/plugin`,
-          templateFiles: `files/${language}/plugin/**`,
-        },
-        {
-          type: 'add',
-          path: 'plugins/{{ pluginName }}/README.md',
-          templateFile: `templates/${language}/README.md.hbs`,
-        },
-        {
-          type: 'add',
-          path: 'plugins/{{ pluginName }}/package.json',
-          templateFile: `templates/${language}/plugin-package.json.hbs`,
-        },
-        () => plop.renderString(logInstructions(answers.pluginName, { language: projectLanguage })),
-      ];
-    },
-  });
-};

package/lib/plops/policy.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const tsUtils = require('@strapi/typescript-utils');
-
-const getDestinationPrompts = require('./prompts/get-destination-prompts');
-const validateInput = require('./utils/validate-input');
-const getFilePath = require('./utils/get-file-path');
-
-module.exports = (plop) => {
-  // Policy generator
-  plop.setGenerator('policy', {
-    description: 'Generate a policy for an API',
-    prompts: [
-      {
-        type: 'input',
-        name: 'id',
-        message: 'Policy name',
-        validate: (input) => validateInput(input),
-      },
-      ...getDestinationPrompts('policy', plop.getDestBasePath(), { rootFolder: true }),
-    ],
-    actions(answers) {
-      const filePath = getFilePath(answers.destination);
-      const currentDir = process.cwd();
-      const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
-
-      return [
-        {
-          type: 'add',
-          path: `${filePath}/policies/{{ id }}.${language}`,
-          templateFile: `templates/${language}/policy.${language}.hbs`,
-        },
-      ];
-    },
-  });
-};

package/lib/plops/prompts/bootstrap-api-prompts.js

@@ -1,10 +0,0 @@
-'use strict';
-
-module.exports = [
-  {
-    type: 'confirm',
-    name: 'bootstrapApi',
-    default: true,
-    message: 'Bootstrap API related files?',
-  },
-];

package/lib/plops/prompts/ct-names-prompts.js

@@ -1,44 +0,0 @@
-'use strict';
-
-const pluralize = require('pluralize');
-const slugify = require('@sindresorhus/slugify');
-const { isKebabCase } = require('@strapi/utils');
-
-module.exports = [
-  {
-    type: 'input',
-    name: 'displayName',
-    message: 'Content type display name',
-    validate: (input) => !!input,
-  },
-  {
-    type: 'input',
-    name: 'singularName',
-    message: 'Content type singular name',
-    default: (answers) => slugify(answers.displayName),
-    validate(input) {
-      if (!isKebabCase(input)) {
-        return 'Value must be in kebab-case';
-      }
-
-      return true;
-    },
-  },
-  {
-    type: 'input',
-    name: 'pluralName',
-    message: 'Content type plural name',
-    default: (answers) => pluralize(answers.singularName),
-    validate(input, answers) {
-      if (answers.singularName === input) {
-        return 'Singular and plural names cannot be the same';
-      }
-
-      if (!isKebabCase(input)) {
-        return 'Value must be in kebab-case';
-      }
-
-      return true;
-    },
-  },
-];