@swell/cli/dist/commands/create/function.js

Swell's command line interface/utility

import { input, select } from '@inquirer/prompts';
import { Args, Flags } from '@oclif/core';
import { CreateConfigCommand } from '../../create-config-command.js';
import { ConfigType } from '../../lib/apps/index.js';
import { getFunctionTemplate, } from '../../lib/create/function.js';
import { toFunctionFileName } from '../../lib/create/index.js';
const PERMITTED_TRIGGERS = ['cron', 'model', 'route'];
export default class CreateFunction extends CreateConfigCommand {
    static args = {
        functionName: Args.string({
            description: 'function name, used in an http route if applicable',
        }),
        trigger: Args.string({
            description: `function trigger type`,
            options: PERMITTED_TRIGGERS,
        }),
    };
    static description = `This command assists in generating functions scripts. CLI will prompt for values when flags are not present.`;
    static examples = [
        {
            command: 'swell create function',
            description: 'Create function script interactively.',
        },
        {
            command: 'swell create function orders-subscriptions-created.ts model --events order.created,subscription.created',
            description: 'Specify model event trigger of the function.',
        },
        {
            command: 'swell create function get-frontend-data.ts route --route public',
            description: 'Specify public API access.',
        },
        {
            command: 'swell create function process-metrics.ts cron --schedule "0 0 * * *"',
            description: 'Specify schedule of the cron function.',
        },
    ];
    static flags = {
        description: Flags.string({
            char: 'd',
            default: '',
            description: 'function description',
        }),
        events: Flags.string({
            char: 'e',
            default: '',
            description: 'list of data model events used with model trigger, delimited by commas',
        }),
        overwrite: Flags.boolean({
            default: false,
            description: 'overwrite existing function file',
        }),
        route: Flags.string({
            char: 'r',
            default: 'public',
            description: 'access type used with route trigger',
            options: ['public', 'private'],
        }),
        schedule: Flags.string({
            char: 's',
            default: '',
            description: 'crontab value used with cron trigger',
        }),
    };
    static summary = 'Initialize a functions script in JavaScript or TypeScript.';
    createType = ConfigType.FUNCTION;
    async run() {
        const { args, flags } = await this.parse(CreateFunction);
        const { functionName, trigger } = args;
        const { description, events, overwrite, route, schedule } = flags;
        let writeFunctionFileParams = {
            description,
            events,
            functionName: functionName || '',
            language: (functionName?.includes('.ts')
                ? 'ts'
                : 'js'),
            route,
            schedule,
            trigger: trigger,
        };
        writeFunctionFileParams = {
            ...writeFunctionFileParams,
            ...(await this.gatherInput(writeFunctionFileParams)),
        };
        await this.writeFunctionFile(writeFunctionFileParams, overwrite);
    }
    async gatherInput(params) {
        let { language } = params;
        if (!language) {
            language = await select({
                choices: [
                    {
                        name: 'TypeScript',
                        value: 'ts',
                    },
                    {
                        name: 'JavaScript',
                        value: 'js',
                    },
                ],
                message: 'What language are you using?',
            });
        }
        let { trigger } = params;
        if (!trigger) {
            trigger = await select({
                choices: [
                    {
                        name: 'Event (model)',
                        value: 'model',
                    },
                    {
                        name: 'Schedule (cron)',
                        value: 'cron',
                    },
                    {
                        name: 'HTTP (route)',
                        value: 'route',
                    },
                ],
                message: 'How will your function be triggered?',
            });
        }
        let { events } = params;
        if (trigger === 'model' && !events) {
            events = await input({
                default: 'product.created, etc...',
                message: 'Enter event types to trigger this function (comma separated)',
            });
            if (events === 'product.created, etc...') {
                events = '';
            }
        }
        let { schedule } = params;
        if (trigger === 'cron' && !schedule) {
            schedule = await input({
                default: '0 0 * * *',
                message: 'Enter a crontab value',
            });
        }
        let { route } = params;
        if (trigger === 'route' && !route) {
            route = await select({
                choices: [
                    { name: 'Public', value: 'public' },
                    { name: 'Private', value: 'private' },
                ],
                message: 'Should the HTTP route be public (using public_key) or private (using secret_key)?',
            });
        }
        let { functionName } = params;
        if (!functionName) {
            functionName = await input({
                default: functionName,
                message: 'Name your function',
            });
        }
        const { description } = params;
        if (!description) {
            await input({
                default: 'Does a thing when another other thing happens',
                message: 'Describe what the function does',
            });
        }
        return {
            description,
            events: events || '',
            functionName,
            language,
            route: route || '',
            schedule: schedule || '',
            trigger,
        };
    }
    async writeFunctionFile({ description, events, functionName, language, route, schedule, trigger, }, overwrite) {
        const fileName = toFunctionFileName(functionName);
        await this.createFile({
            extension: language,
            fileBody: getFunctionTemplate({
                description,
                events,
                functionName,
                language,
                route,
                schedule,
                trigger,
            }),
            fileName,
        }, overwrite);
    }
}