@strapi/generators 0.0.0-next.e3b4cdeebf6e9b0cd5575ff80b8a86715d44ce98 → 0.0.0-next.e61eff51f9834ffdef16bdc236aecab5f837723b

package/dist/plopfile.js

@@ -1,29 +1,657 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+'use strict';
+
+var pluralize = require('pluralize');
+var path = require('path');
+var fs = require('fs-extra');
+var tsUtils = require('@strapi/typescript-utils');
+var slugify = require('@sindresorhus/slugify');
+var utils = require('@strapi/utils');
+
+var validateInput = ((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";
+});
+
+var generateApi = ((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 = path.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) {
+            if (!answers) {
+                return [];
+            }
+            const filePath = answers.isPluginApi && answers.plugin ? 'plugins/{{ plugin }}/server' : '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
+            ];
+        }
+    });
+});
+
+var getDestinationPrompts = ((action, basePath, { rootFolder = false } = {})=>{
+    return [
+        {
+            type: 'list',
+            name: 'destination',
+            message: `Where do you want to add this ${action}?`,
+            choices: [
+                ...rootFolder ? [
+                    {
+                        name: `Add ${action} to root of project`,
+                        value: 'root'
+                    }
+                ] : [
+                    {
+                        name: `Add ${action} to 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 = path.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 = path.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(path.join(pluginsPath, api)).isDirectory());
+                if (pluginsDirContent.length === 0) {
+                    throw Error('The "plugins" directory is empty');
+                }
+                return pluginsDirContent;
+            }
+        }
+    ];
+});
+
+var getFilePath = ((destination)=>{
+    if (destination === 'api') {
+        return `api/{{ api }}`;
+    }
+    if (destination === 'plugin') {
+        return `plugins/{{ plugin }}/server`;
+    }
+    if (destination === 'root') {
+        return './';
+    }
+    return `api/{{ id }}`;
+});
+
+var generateController = ((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) {
+            if (!answers) {
+                return [];
+            }
+            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`
+                }
+            ];
+        }
+    });
+});
+
+const questions$2 = [
+    {
+        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 (!utils.strings.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 (!utils.strings.isKebabCase(input)) {
+                return 'Value must be in kebab-case';
+            }
+            return true;
+        }
+    }
+];
+
+const questions$1 = [
+    {
+        type: 'list',
+        name: 'kind',
+        message: 'Please choose the model type',
+        default: 'collectionType',
+        choices: [
+            {
+                name: 'Collection Type',
+                value: 'collectionType'
+            },
+            {
+                name: 'Single Type',
+                value: 'singleType'
+            }
+        ],
+        validate: (input)=>validateInput(input)
+    }
+];
+
+var validateAttributeInput = ((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";
+});
+
+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 getAttributesPrompts = async (inquirer)=>{
+    const { addAttributes } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'addAttributes',
+            message: 'Do you want to add attributes?'
+        }
+    ]);
+    const attributes = [];
+    /**
+   * @param {import('inquirer').Inquirer} inquirer
+   * @returns {Promise<void>}
+   */ const createNewAttributes = async (inquirer)=>{
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'attributeName',
+                message: 'Name of attribute',
+                validate: (input)=>validateAttributeInput(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?'
+            }
+        ]);
+        attributes.push(answers);
+        if (!answers.addAttributes) {
+            return;
+        }
+        await createNewAttributes(inquirer);
+    };
+    if (addAttributes) {
+        await createNewAttributes(inquirer);
+    } else {
+        console.warn(`You won't be able to manage entries from the admin, you can still add attributes later from the content type builder.`);
+    }
+    return attributes;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const pluralize_1 = __importDefault(require("pluralize"));
-const api_1 = __importDefault(require("./plops/api"));
-const controller_1 = __importDefault(require("./plops/controller"));
-const content_type_1 = __importDefault(require("./plops/content-type"));
-const plugin_1 = __importDefault(require("./plops/plugin"));
-const policy_1 = __importDefault(require("./plops/policy"));
-const middleware_1 = __importDefault(require("./plops/middleware"));
-const migration_1 = __importDefault(require("./plops/migration"));
-const service_1 = __importDefault(require("./plops/service"));
-exports.default = (plop) => {
+
+const questions = [
+    {
+        type: 'confirm',
+        name: 'bootstrapApi',
+        default: true,
+        message: 'Bootstrap API related files?'
+    }
+];
+
+var generateContentType = ((plop)=>{
+    // Model generator
+    plop.setGenerator('content-type', {
+        description: 'Generate a content type for an API',
+        async prompts (inquirer) {
+            const config = await inquirer.prompt([
+                ...questions$2,
+                ...questions$1
+            ]);
+            // @ts-expect-error issue with deprecated inquirer.prompts attribute to fix with ugprade to inquirer
+            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 (!utils.strings.isKebabCase(input)) {
+                            return 'Value must be in kebab-case';
+                        }
+                        const apiPath = path.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((dir)=>dir.name === input) !== -1) {
+                            throw new Error('This name is already taken.');
+                        }
+                        return true;
+                    }
+                },
+                ...questions
+            ]);
+            return {
+                ...config,
+                ...api,
+                attributes
+            };
+        },
+        actions (answers) {
+            if (!answers) {
+                return [];
+            }
+            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;
+        }
+    });
+});
+
+var generatePolicy = ((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) {
+            if (!answers) {
+                return [];
+            }
+            const currentDir = process.cwd();
+            const filePath = getFilePath(answers.destination);
+            const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
+            return [
+                {
+                    type: 'add',
+                    path: `${filePath}/policies/{{ id }}.${language}`,
+                    templateFile: `templates/${language}/policy.${language}.hbs`
+                }
+            ];
+        }
+    });
+});
+
+var generateMiddleware = ((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) {
+            if (!answers) {
+                return [];
+            }
+            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`
+                }
+            ];
+        }
+    });
+});
+
+var validateFileNameInput = ((input)=>{
+    const regex = /^[A-Za-z-_0-9]+$/g;
+    if (!input) {
+        return 'You must provide an input';
+    }
+    return regex.test(input) || "Please use only letters and number, '-' or '_' and no spaces";
+});
+
+var getFormattedDate = ((date = new Date())=>{
+    return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toJSON().replace(/[-:]/g, '.').replace(/\....Z/, '');
+});
+
+var generateMigration = ((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`
+                }
+            ];
+        }
+    });
+});
+
+var generateService = ((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) {
+            if (!answers) {
+                return [];
+            }
+            const filePath = getFilePath(answers?.destination);
+            const currentDir = process.cwd();
+            const language = tsUtils.isUsingTypeScriptSync(currentDir) ? 'ts' : 'js';
+            return [
+                {
+                    type: 'add',
+                    path: `${filePath}/services/{{ id }}.${language}`,
+                    templateFile: `templates/${language}/service.${language}.hbs`
+                }
+            ];
+        }
+    });
+});
+
+var plopfile = ((plop)=>{
     // Plop config
     plop.setWelcomeMessage('Strapi Generators');
-    plop.addHelper('pluralize', (text) => (0, pluralize_1.default)(text));
+    plop.setHelper('pluralize', (text)=>pluralize(text));
     // Generators
-    (0, api_1.default)(plop);
-    (0, controller_1.default)(plop);
-    (0, content_type_1.default)(plop);
-    (0, plugin_1.default)(plop);
-    (0, policy_1.default)(plop);
-    (0, middleware_1.default)(plop);
-    (0, migration_1.default)(plop);
-    (0, service_1.default)(plop);
-};
-//# sourceMappingURL=plopfile.js.map
+    generateApi(plop);
+    generateController(plop);
+    generateContentType(plop);
+    generatePolicy(plop);
+    generateMiddleware(plop);
+    generateMigration(plop);
+    generateService(plop);
+});
+
+module.exports = plopfile;
+//# sourceMappingURL=plopfile.js.map