@swell/cli 2.2.1 → 2.3.0

package/dist/commands/create/function.js

@@ -7,65 +7,127 @@ 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',
+        name: Args.string({
+            default: '',
+            description: 'Filename with extension (e.g., my-func.ts)',
         }),
         trigger: Args.string({
-            description: `function trigger type`,
+            default: '',
+            description: 'cron | model | route',
             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.',
-        },
+        '$ swell create function',
+        '$ swell create function order-handler.ts model -e order.created,order.updated -y',
+        '$ swell create function cleanup.ts cron -s "0 0 * * *" -y',
+        '$ swell create function api-endpoint.ts route -r public -y',
     ];
+    static helpMeta = {
+        usageDirect: '<name> <trigger> [...] -y',
+        variantSection: {
+            title: 'TRIGGER OPTIONS',
+            variants: [
+                {
+                    name: 'model',
+                    flag: '-e, --events=<value>',
+                    description: 'Model events (e.g., order.created,order.updated)',
+                },
+                {
+                    name: 'cron',
+                    flag: '-s, --schedule=<value>',
+                    description: 'Cron expression (e.g., "0 0 * * *")',
+                },
+                {
+                    name: 'route',
+                    flag: '-r, --route=<option>',
+                    description: 'Access: public (default) | private',
+                },
+            ],
+        },
+        variantFlags: ['events', 'schedule', 'route'],
+    };
     static flags = {
         description: Flags.string({
             char: 'd',
             default: '',
-            description: 'function description',
+            description: 'Description',
         }),
         events: Flags.string({
             char: 'e',
             default: '',
-            description: 'list of data model events used with model trigger, delimited by commas',
+            description: 'Model events (e.g., order.created,order.updated)',
         }),
         overwrite: Flags.boolean({
             default: false,
-            description: 'overwrite existing function file',
+            description: 'Overwrite existing file',
         }),
         route: Flags.string({
             char: 'r',
-            default: 'public',
-            description: 'access type used with route trigger',
+            default: '',
+            description: 'Access: public | private',
             options: ['public', 'private'],
         }),
         schedule: Flags.string({
             char: 's',
             default: '',
-            description: 'crontab value used with cron trigger',
+            description: 'Cron expression (e.g., "0 0 * * *")',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip prompts, require all arguments',
         }),
     };
-    static summary = 'Initialize a functions script in JavaScript or TypeScript.';
+    static summary = 'Create a serverless function in JavaScript or TypeScript.';
     createType = ConfigType.FUNCTION;
     async run() {
         const { args, flags } = await this.parse(CreateFunction);
-        const { functionName, trigger } = args;
+        const confirmYes = Boolean(flags.yes);
+        // NON-INTERACTIVE PATH
+        if (confirmYes) {
+            // Validate name argument
+            if (!args.name) {
+                this.error('Missing required argument for non-interactive mode: NAME\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
+            }
+            // Validate trigger argument
+            if (!args.trigger) {
+                this.error('Missing required argument for non-interactive mode: TRIGGER\n\nValid triggers: cron, model, route\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
+            }
+            // Validate filename has extension
+            const language = args.name.endsWith('.ts')
+                ? 'ts'
+                : args.name.endsWith('.js')
+                    ? 'js'
+                    : null;
+            if (!language) {
+                this.error('Function name must end with .ts or .js extension\n\nExample: swell create function my-func.ts model -e order.created -y', { exit: 1 });
+            }
+            const trigger = args.trigger;
+            // Validate trigger-specific requirements
+            if (trigger === 'model' && !flags.events) {
+                this.error('Missing required flag for model trigger: --events\n\nExample: swell create function my-func.ts model -e order.created,order.updated -y', { exit: 1 });
+            }
+            if (trigger === 'cron' && !flags.schedule) {
+                this.error('Missing required flag for cron trigger: --schedule\n\nExample: swell create function my-func.ts cron -s "0 0 * * *" -y', { exit: 1 });
+            }
+            // Build params with defaults
+            const writeFunctionFileParams = {
+                description: flags.description || '',
+                events: flags.events || '',
+                extension: undefined,
+                functionName: args.name,
+                language,
+                route: flags.route || 'public',
+                schedule: flags.schedule || '',
+                trigger,
+            };
+            // Write file without confirmation
+            await this.writeFunctionFile(writeFunctionFileParams, flags.overwrite, 
+            /* shouldConfirm */ false);
+            return;
+        }
+        // INTERACTIVE PATH
+        const { name: functionName, trigger } = args;
         const { description, events, overwrite, route, schedule } = flags;
         let writeFunctionFileParams = {
             description,
@@ -85,7 +147,8 @@ export default class CreateFunction extends CreateConfigCommand {
             ...writeFunctionFileParams,
             ...(await this.gatherInput(writeFunctionFileParams)),
         };
-        await this.writeFunctionFile(writeFunctionFileParams, overwrite);
+        await this.writeFunctionFile(writeFunctionFileParams, overwrite, 
+        /* shouldConfirm */ true);
     }
     async gatherInput(params) {
         // Check if there are any extensions in the app configuration
@@ -193,7 +256,7 @@ export default class CreateFunction extends CreateConfigCommand {
             trigger,
         };
     }
-    async writeFunctionFile({ description, events, extension, functionName, language, route, schedule, trigger, }, overwrite) {
+    async writeFunctionFile({ description, events, extension, functionName, language, route, schedule, trigger, }, overwrite, shouldConfirm = true) {
         const fileName = toFunctionFileName(functionName);
         await this.createFile({
             extension: language,
@@ -208,6 +271,6 @@ export default class CreateFunction extends CreateConfigCommand {
                 trigger,
             }),
             fileName,
-        }, overwrite);
+        }, overwrite, shouldConfirm);
     }
 }

package/dist/commands/create/index.js

@@ -26,10 +26,18 @@ export default class Create extends Command {
                     name: 'Notification',
                     value: 'notification',
                 },
+                {
+                    name: 'Setting',
+                    value: 'setting',
+                },
                 {
                     name: 'Tests',
                     value: 'tests',
                 },
+                {
+                    name: 'Webhook',
+                    value: 'webhook',
+                },
             ],
             message: 'What do you want to create?',
         });

package/dist/commands/create/model.d.ts

@@ -1,19 +1,18 @@
 import { CreateCollectionCommand } from '../../create-collection-command.js';
+import { HelpMeta } from '../../help/types.js';
 import { ConfigType } from '../../lib/apps/index.js';
 export default class CreateModel extends CreateCollectionCommand {
     static args: {
         collection: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
     static description: string;
-    static examples: {
-        command: string;
-        description: string;
-    }[];
+    static examples: string[];
+    static helpMeta: HelpMeta;
     static flags: {
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         fields: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };

package/dist/commands/create/model.js

@@ -9,58 +9,46 @@ export default class CreateModel extends CreateCollectionCommand {
     static args = {
         collection: Args.string({
             default: '',
-            description: 'collection ID to create or apply to, e.g., products (required with -y)',
+            description: 'Collection ID to create or extend (e.g., products)',
         }),
     };
-    static description = `Interactive mode: choose to create a new collection or extend an existing standard collection. The CLI will propose a list of standard collections you can extend.
-
-Non-interactive (-y): provide COLLECTION explicitly. To discover standard collections first, run: swell inspect models.`;
+    static description = 'Interactive mode lets you choose to create a new collection or extend a standard one.\nTo discover standard collections: swell inspect models';
     static examples = [
-        {
-            command: 'swell create model',
-            description: 'Create data model configuration interactively',
-        },
-        {
-            command: 'swell create model products -y',
-            description: 'Apply configuration to a standard collection (non-interactive)',
-        },
-        {
-            command: 'swell create model visitors -e created,updated -f title:string,photo:image -l "Visitors" -d "" -y',
-            description: 'Create custom collection with explicit fields (non-interactive)',
-        },
-        {
-            command: 'swell inspect models',
-            description: 'List standard collections available for extending',
-        },
+        '$ swell create model',
+        '$ swell create model products -y',
+        '$ swell create model visitors -f title:string,photo:string -l "Visitors" -y',
     ];
+    static helpMeta = {
+        usageDirect: '<collection> [...] -y',
+    };
     static flags = {
+        label: Flags.string({
+            char: 'l',
+            default: '',
+            description: 'Display label (default: capitalized collection)',
+        }),
         description: Flags.string({
             char: 'd',
             default: '',
-            description: 'data model description',
-        }),
-        events: Flags.string({
-            char: 'e',
-            default: 'created,updated,deleted',
-            description: 'comma-separated events - valid: created, updated, deleted',
+            description: 'Description',
         }),
         fields: Flags.string({
             char: 'f',
             default: '',
-            description: 'comma-separated id:type pairs (e.g., title:string, price:currency). Types: collection, currency, image, int, link, string',
+            description: 'Fields as id:type pairs (e.g., title:string,price:currency)',
         }),
-        label: Flags.string({
-            char: 'l',
-            default: '',
-            description: 'display label for the model (defaults to capitalized collection name)',
+        events: Flags.string({
+            char: 'e',
+            default: 'created,updated,deleted',
+            description: 'Events to track (default: created,updated,deleted)',
         }),
         overwrite: Flags.boolean({
             default: false,
-            description: 'overwrite existing data model configuration file (use with -y to force overwrite)',
+            description: 'Overwrite existing file',
         }),
         yes: Flags.boolean({
             char: 'y',
-            description: 'accept all default values; non-interactive, never prompts; errors if required values are missing',
+            description: 'Skip prompts, require all arguments',
         }),
     };
     static summary = 'Create or extend a data model configuration in the models folder.';

package/dist/commands/create/notification.d.ts

@@ -1,22 +1,22 @@
 import { CreateConfigCommand } from '../../create-config-command.js';
+import { HelpMeta } from '../../help/types.js';
 import { ConfigType } from '../../lib/apps/index.js';
 export default class CreateNotification extends CreateConfigCommand {
     static args: {
-        model: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
-        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
     static description: string;
-    static examples: {
-        command: string;
-        description: string;
-    }[];
+    static examples: string[];
+    static helpMeta: HelpMeta;
     static flags: {
-        admin: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        model: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         event: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        subject: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        admin: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         once: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        subject: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     static summary: string;
     createType: ConfigType;

package/dist/commands/create/notification.js

@@ -1,92 +1,111 @@
 import { input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { capitalize, singularize } from 'inflection';
+import { singularize } from 'inflection';
 import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { toFileName, toNotificationLabel } from '../../lib/create/index.js';
+import { SCHEMAS } from '../../lib/create/schemas.js';
 export default class CreateNotification extends CreateConfigCommand {
     static args = {
-        model: Args.string({
-            description: 'data model to trigger the notification by',
-        }),
         name: Args.string({
-            description: 'internal name for the notification',
+            default: '',
+            description: 'Notification name (e.g., order-paid)',
         }),
     };
-    static description = `This command assists in generating notifications configuration files. This CLI command will prompt for values when flags are not present.`;
+    static description = 'Create notification files and configuration in the notifications folder.';
     static examples = [
-        {
-            command: 'swell create notification',
-            description: 'Create notification configuration interactively.',
-        },
-        {
-            command: 'swell create notification subscriptions confirmed --event subscription.created --once --s "Your subscription has been confirmed" -d "Send a confirmation email when subscription is created"',
-            description: 'Specify the model, name, event, subject, and description.',
-        },
-        {
-            command: 'swell create notification orders paid --event paid"',
-            description: 'Specify the event to trigger the notification.',
-        },
+        '$ swell create notification',
+        '$ swell create notification order-paid -m orders -y',
+        '$ swell create notification order-paid -m orders -e created -s "Order Paid" --admin --once -y',
     ];
+    static helpMeta = {
+        usageDirect: '<name> -m <model> [...] -y',
+    };
     static flags = {
-        admin: Flags.boolean({
-            char: 'a',
-            description: 'indicate when the notification is sent to store admins only',
-        }),
-        description: Flags.string({
-            char: 'd',
+        model: Flags.string({
+            char: 'm',
             default: '',
-            description: 'notification description',
+            description: 'Triggering model (required with -y)',
         }),
         event: Flags.string({
             char: 'e',
             default: '',
-            description: 'data model event to trigger the notification event, i.e. created',
+            description: 'Triggering event (default: created)',
+        }),
+        subject: Flags.string({
+            char: 's',
+            default: '',
+            description: 'Email subject',
+        }),
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'Description',
+        }),
+        admin: Flags.boolean({
+            char: 'a',
+            description: 'Send to store admins only',
         }),
         once: Flags.boolean({
             char: 'o',
-            description: 'indicate the notification should be sent only once when conditions are met, instead of repeating',
+            description: 'Send only once when conditions met',
         }),
         overwrite: Flags.boolean({
-            description: 'overwrite existing notification configuration file',
+            default: false,
+            description: 'Overwrite existing file',
         }),
-        subject: Flags.string({
-            char: 's',
-            default: '',
-            description: 'notification email subject',
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip prompts, require all arguments',
         }),
     };
-    static summary = 'Initialize notification files and configuration with properties in the notifications folder.';
+    static summary = 'Create notification files and configuration in the notifications folder.';
     createType = ConfigType.NOTIFICATION;
     async run() {
         const { args, flags } = await this.parse(CreateNotification);
-        if (args.model && args.name) {
-            await this.writeNotificationFile({
-                admin: flags.admin,
-                description: flags.description,
-                event: flags.event,
-                model: args.model,
-                name: `${singularize(args.model)}-${args.name.replace(singularize(args.model), '')}`,
-                once: flags.once,
-                subject: flags.subject,
-            }, false);
-        }
-        else {
-            let { admin } = flags;
-            if (admin === undefined) {
-                const choice = await select({
-                    choices: [
-                        { name: 'Admins', value: 'admin' },
-                        { name: 'Customers', value: 'customer' },
-                    ],
-                    message: 'Who will be notified?',
-                });
-                if (choice === 'admin') {
-                    admin = true;
-                }
+        const confirmYes = Boolean(flags.yes);
+        // NON-INTERACTIVE PATH
+        if (confirmYes) {
+            // Validate NAME argument
+            if (!args.name) {
+                this.error('Missing required argument for non-interactive mode: NAME\n\nExample: swell create notification order-paid -m orders -y', { exit: 1 });
             }
+            // Validate --model flag
+            if (!flags.model) {
+                this.error('Missing required flag for non-interactive mode: --model\n\nExample: swell create notification order-paid -m orders -y', { exit: 1 });
+            }
+            // Build with defaults
+            const name = toFileName(args.name);
+            const { model, event: eventFlag, subject: subjectFlag, description: descFlag, admin: adminFlag, once: onceFlag, overwrite, } = flags;
+            const event = eventFlag || 'created';
+            const subject = subjectFlag || toNotificationLabel(name);
+            const description = descFlag || '';
+            const admin = adminFlag || false;
+            const once = onceFlag || false;
+            await this.writeNotificationFile({ admin, description, event, model, name, once, subject }, overwrite, 
+            /* shouldConfirm */ false);
+            return;
+        }
+        // INTERACTIVE PATH
+        let name = args.name;
+        let model = flags.model;
+        const { event: eventFlag, description: descFlag, subject: subjectFlag, overwrite, } = flags;
+        // Prompt for admin if not provided
+        let { admin } = flags;
+        if (admin === undefined) {
+            const choice = await select({
+                choices: [
+                    { name: 'Admins', value: 'admin' },
+                    { name: 'Customers', value: 'customer' },
+                ],
+                message: 'Who will be notified?',
+            });
+            admin = choice === 'admin';
+        }
+        // Prompt for model if not provided
+        if (!model) {
             const collections = await this.getCollectionOptions();
-            const model = await select({
+            model = await select({
                 choices: collections.map((collectionName) => ({
                     name: collectionName,
                     value: collectionName,
@@ -95,46 +114,52 @@ export default class CreateNotification extends CreateConfigCommand {
                 message: 'Which model will trigger the notification?',
                 pageSize: 25,
             });
-            const event = await input({
+        }
+        // Prompt for event if not provided
+        const event = eventFlag ||
+            (await input({
                 default: 'created',
                 message: 'Event to trigger the notification',
+            }));
+        // Prompt for name if not provided
+        if (!name) {
+            name = await input({
+                default: `${singularize(model)}-${event}`,
+                message: 'Name of the notification',
+            });
+        }
+        name = toFileName(name);
+        // Prompt for description if not provided
+        const description = descFlag ||
+            (await input({
+                default: `Notify ${admin ? 'admin' : 'customer'} when ${singularize(model)}...`,
+                message: 'Describe what the notification does',
+            }));
+        // Prompt for once if not provided
+        let { once } = flags;
+        if (once === undefined) {
+            once = await select({
+                choices: [
+                    { name: 'Every time conditions are met', value: false },
+                    { name: 'Only the first time conditions are met', value: true },
+                ],
+                message: 'When should we send this notification?',
             });
-            const answers = {
-                description: await input({
-                    default: `Notify ${admin ? 'admin' : 'customer'} when ${singularize(model)}...`,
-                    message: 'Describe what the notification does',
-                }),
-                name: await input({
-                    default: `${singularize(model)}-${event}`,
-                    message: 'Name of the notification',
-                }),
-                once: await select({
-                    choices: [
-                        {
-                            name: 'Every time conditions are met',
-                            value: false,
-                        },
-                        {
-                            name: 'Only the first time conditions are met',
-                            value: true,
-                        },
-                    ],
-                    message: 'When should we send this notification?',
-                }),
-                subject: await input({
-                    default: `Something happened with ${model}`,
-                    message: 'Subject of the notification email',
-                }),
-            };
-            const { description, name, once, subject } = answers;
-            await this.writeNotificationFile({ admin, description, event, model, name, once, subject }, false);
         }
+        // Prompt for subject if not provided
+        const subject = subjectFlag ||
+            (await input({
+                default: toNotificationLabel(name),
+                message: 'Subject of the notification email',
+            }));
+        await this.writeNotificationFile({ admin, description, event, model, name, once, subject }, overwrite, 
+        /* shouldConfirm */ true);
     }
-    async writeNotificationFile({ admin, description, event, model, name, once, subject, }, overwrite) {
-        const label = [name].map((val) => capitalize(val).trim()).join(' ');
-        const fileName = toFileName(label);
+    async writeNotificationFile({ admin, description, event, model, name, once, subject, }, overwrite, shouldConfirm = true) {
+        const fileName = toFileName(name);
         const noteLabel = toNotificationLabel(name);
         const fileBody = {
+            $schema: SCHEMAS.NOTIFICATION,
             collection: model,
             conditions: {},
             event: event || 'created',
@@ -157,10 +182,7 @@ export default class CreateNotification extends CreateConfigCommand {
             expand: [],
         };
         fileBody.sample = {};
-        const jsonCreated = await this.createFile({
-            fileBody,
-            fileName,
-        }, overwrite);
+        const jsonCreated = await this.createFile({ fileBody, fileName }, overwrite, shouldConfirm);
         if (jsonCreated) {
             await this.createFile({ extension: 'tpl', fileBody: '\n', fileName }, overwrite, false);
         }

package/dist/commands/create/setting.d.ts

@@ -0,0 +1,21 @@
+import { CreateConfigCommand } from '../../create-config-command.js';
+import { HelpMeta } from '../../help/types.js';
+import { ConfigType } from '../../lib/apps/index.js';
+export default class CreateSetting extends CreateConfigCommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static helpMeta: HelpMeta;
+    static flags: {
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    createType: ConfigType;
+    run(): Promise<void>;
+}