@swell/cli 2.1.0 → 2.2.0

package/dist/commands/create/app.js

@@ -7,30 +7,49 @@ import { newConfig, swellConfigFileExists } from '../../lib/app-config.js';
 import { toAppId, toAppName } from '../../lib/create/index.js';
 import style from '../../lib/style.js';
 export default class CreateApp extends CreateAppCommand {
-    appType = '';
     static args = {
         id: Args.string({
             default: '',
-            description: `id of the app to create`,
+            description: `id of the app to create (required in -y)`,
         }),
     };
     static description = 'Create an app.';
     static examples = [
         {
             command: 'swell create app',
-            description: 'Create app following command prompts.',
+            description: 'Interactive: follow prompts to create an app.',
+        },
+        {
+            command: 'swell create app my_app -t admin -y',
+            description: 'Non-interactive: minimal with defaults.',
+        },
+        {
+            command: 'swell create app my_app --type admin --name "My App" --version 1.0.1 --description "" -y',
+            description: 'Non-interactive: explicit name, version, description.',
+        },
+        {
+            command: 'swell create app my_app --type admin --frontend astro -y',
+            description: 'Non-interactive: initialize an Astro frontend.',
         },
         {
-            command: 'swell create app my_app -y',
-            description: 'Create app and accept all default values.',
+            command: 'swell create app my_theme --type theme --storefront-app proxima -y',
+            description: 'Non-interactive: theme targeting a specific storefront app.',
+        },
+        {
+            command: 'swell create app my_payment --type integration --integration-type payment --integration-id card -y',
+            description: 'Non-interactive: payment integration for credit cards.',
+        },
+        {
+            command: 'swell create app my_shipping --type integration --integration-type shipping --integration-id fedex -y',
+            description: 'Non-interactive: shipping integration for FedEx.',
         },
         {
             command: 'swell create app -p yarn',
-            description: 'Create app with yarn package manager instead of npm by default.',
+            description: 'Package manager: use Yarn instead of npm.',
         },
         {
             command: 'swell create app -p none',
-            description: 'Create app without installing TypeScript bindings, etc.',
+            description: 'Package manager: skip installing default dependencies.',
         },
     ];
     static flags = {
@@ -42,34 +61,66 @@ export default class CreateApp extends CreateAppCommand {
         }),
         type: Flags.string({
             char: 't',
-            description: `create a specific app type`,
+            description: `create a specific app type (required in -y)`,
             options: ['admin', 'integration', 'storefront', 'theme'],
         }),
+        name: Flags.string({
+            char: 'n',
+            description: `application name (default: capitalized ID)`,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: `application version (default: 1.0.0)`,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: `application description`,
+        }),
     };
-    async createSwellConfig({ allowOverwrite = true, inputId = '', inputStorefrontApp, inputType, inputYes, nestedPath = true, }) {
-        let confirmYes = inputYes;
+    appType = '';
+    async createSwellConfig({ allowOverwrite = true, inputId = '', inputStorefrontApp, inputType, inputName, inputVersion, inputDescription, inputFrontend, inputIntegrationType, inputIntegrationId, inputYes, nestedPath = true, }) {
+        const confirmYes = inputYes;
+        let appId = toAppId(inputId || '');
+        let storefrontInstalledApps;
+        let storefrontAppId;
+        let installedStorefrontApp;
+        // check missed parameters
+        if (confirmYes) {
+            if (!appId) {
+                this.error('Missing application id for non-interactive mode\n\nYou need to provide an app id value for non-interactive mode\n\nExample: swell create app reviews --type admin -y', {
+                    exit: 1,
+                });
+            }
+            if (!inputType) {
+                this.error('Missing required flag for non-interactive mode: --type\n\nValid types: admin, integration, storefront, theme\n\nExample: swell create app reviews --type admin -y', {
+                    exit: 1,
+                });
+            }
+            if (!inputName) {
+                inputName = toAppName(inputId);
+            }
+            if (!inputVersion) {
+                inputVersion = '1.0.0';
+            }
+        }
         const type = inputType ||
-            (confirmYes
-                ? 'admin'
-                : await select({
-                    choices: [
-                        { name: 'Admin', value: 'admin' },
-                        { name: 'Integration', value: 'integration' },
-                        { name: 'Storefront', value: 'storefront' },
-                        { name: 'Theme', value: 'theme' },
-                    ],
-                    message: `What is the primary purpose of the app?`,
-                }));
+            (await select({
+                choices: [
+                    { name: 'Admin', value: 'admin' },
+                    { name: 'Integration', value: 'integration' },
+                    { name: 'Storefront', value: 'storefront' },
+                    { name: 'Theme', value: 'theme' },
+                ],
+                message: `What is the primary purpose of the app?`,
+            }));
         const typeLabel = type === 'theme' ? 'theme' : 'app';
         const typeLabelTitle = type === 'theme' ? 'Theme' : 'App';
-        const name = confirmYes
-            ? toAppName(inputId)
-            : await input({
+        const name = inputName ||
+            (await input({
                 default: inputId ? toAppName(inputId) : '',
                 message: `${typeLabelTitle} name`,
                 validate: (answer) => answer.length > 2,
-            });
-        let appId = toAppId(inputId || '');
+            }));
         if (!appId) {
             appId = await input({
                 default: toAppId(name),
@@ -77,39 +128,135 @@ export default class CreateApp extends CreateAppCommand {
                 validate: (answer) => answer.length > 2,
             });
             appId = toAppId(appId);
-            confirmYes = Boolean(inputYes && appId);
         }
-        const version = confirmYes
-            ? '1.0.0'
-            : await input({
+        const version = inputVersion ||
+            (await input({
                 default: '1.0.0',
                 message: `${typeLabelTitle} version`,
-            });
-        const description = confirmYes
-            ? ''
-            : await input({
-                default: 'Something special',
-                message: `Describe your ${typeLabel}`,
-            });
-        let storefrontInstalledApps;
-        let storefrontAppId;
-        let installedStorefrontApp;
+            }));
+        const description = inputDescription ||
+            (confirmYes
+                ? ''
+                : await input({
+                    default: 'Something special',
+                    message: `Describe your ${typeLabel}`,
+                }));
+        let integrationType;
+        let extensions;
+        if (type === 'integration') {
+            if (confirmYes && !inputIntegrationType) {
+                this.error('Missing required flag for non-interactive mode for integration app: --integration-type\n\nValid types: generic, payment, shipping, tax\n\nExample: swell create app reviews --type integration --integration-type generic -y', {
+                    exit: 1,
+                });
+            }
+            integrationType =
+                inputIntegrationType ||
+                    (await select({
+                        choices: [
+                            { name: 'Generic', value: 'generic' },
+                            { name: 'Payment gateway', value: 'payment' },
+                            { name: 'Shipping service', value: 'shipping' },
+                            { name: 'Tax service', value: 'tax' },
+                        ],
+                        message: `What type of integration?`,
+                    }));
+            // Create extensions array based on integration type
+            switch (integrationType) {
+                case 'generic': {
+                    // No extension needed for generic integrations
+                    break;
+                }
+                case 'payment':
+                case 'shipping':
+                case 'tax': {
+                    // Unified validation for all extension-based integrations
+                    if (confirmYes && !inputIntegrationId) {
+                        const validValues = integrationType === 'payment'
+                            ? "use 'card' for credit card integration or unique custom ID for other payment integrations"
+                            : 'unique custom ID';
+                        this.error(`Missing required flag for non-interactive mode for ${integrationType} integration: --integration-id\n\nValid values: ${validValues}\n\nExample: swell create app my_app --type integration --integration-type ${integrationType} --integration-id ${integrationType === 'payment' ? 'card' : 'myid'} -y`, {
+                            exit: 1,
+                        });
+                    }
+                    // Interactive prompting
+                    let integrationId = inputIntegrationId;
+                    if (!integrationId) {
+                        if (integrationType === 'payment') {
+                            const methodChoice = await select({
+                                choices: [
+                                    { name: 'Credit card', value: 'card' },
+                                    { name: 'Custom method', value: 'custom' },
+                                ],
+                                message: `What type of payment method?`,
+                            });
+                            integrationId =
+                                methodChoice === 'custom'
+                                    ? await input({
+                                        message: `Enter a unique ID for your payment method`,
+                                        validate: (answer) => answer.length > 2,
+                                    })
+                                    : methodChoice; // 'card'
+                        }
+                        else {
+                            // Shipping or tax
+                            const serviceLabel = integrationType === 'shipping'
+                                ? 'shipping service'
+                                : 'tax service';
+                            integrationId = await input({
+                                message: `Enter a unique ID for your ${serviceLabel}`,
+                                validate: (answer) => answer.length > 2,
+                            });
+                        }
+                    }
+                    // Unified validation
+                    if (integrationId.length < 3) {
+                        this.error(`--integration-id must contain at least 3 characters\n\nValid value is a custom ID containing at least 3 characters\n\nExample: swell create app my_app --type integration --integration-type ${integrationType} --integration-id ${integrationType === 'payment' ? 'card' : 'myid'} -y`, {
+                            exit: 1,
+                        });
+                    }
+                    // Create extension
+                    extensions = [
+                        {
+                            id: integrationId,
+                            type: integrationType,
+                        },
+                    ];
+                    break;
+                }
+                default: {
+                    this.error('Incorrect value for --integration-type\n\nValid types: generic, payment, shipping, tax\n\nExample: swell create app reviews --type integration --integration-type generic -y', {
+                        exit: 1,
+                    });
+                }
+            }
+        }
         if (type === 'theme') {
             storefrontInstalledApps = await this.getInstalledStorefrontApps();
             if (storefrontInstalledApps === false) {
-                return;
+                this.error('There are no installed storefront apps\n\nTo use the theme type, you first need to install the storefront app', {
+                    exit: 1,
+                });
+            }
+            storefrontAppId = inputStorefrontApp || '';
+            if (!storefrontAppId) {
+                if (storefrontInstalledApps.length === 1) {
+                    storefrontAppId = storefrontInstalledApps[0].id;
+                }
+                else {
+                    if (confirmYes) {
+                        this.error('There are several installed storefront apps to choose from\n\nYou should select a specific storefront app in the non-interactive mode using --storefront-app appid\n\nExample: swell create app reviews --type theme --storefront-app proxima -y', {
+                            exit: 1,
+                        });
+                    }
+                    storefrontAppId = await select({
+                        choices: storefrontInstalledApps.map(({ app, id }) => ({
+                            name: app.name,
+                            value: id,
+                        })),
+                        message: `Which storefront app is your theme for?`,
+                    });
+                }
             }
-            storefrontAppId =
-                inputStorefrontApp ||
-                    (storefrontInstalledApps.length > 1
-                        ? await select({
-                            choices: storefrontInstalledApps.map(({ app, id }) => ({
-                                name: app.name,
-                                value: id,
-                            })),
-                            message: `Which storefront app is your theme for?`,
-                        })
-                        : storefrontInstalledApps[0].id);
             installedStorefrontApp = storefrontInstalledApps.find((installedApp) => inputStorefrontApp
                 ? inputStorefrontApp === installedApp.app_private_id ||
                     inputStorefrontApp === installedApp.app_public_id ||
@@ -117,7 +264,20 @@ export default class CreateApp extends CreateAppCommand {
                     inputStorefrontApp === toAppId(installedApp.app_private_id)
                 : installedApp.id === storefrontAppId);
             if (!installedStorefrontApp) {
-                this.error(`Could not find an installed storefront app by id: ${storefrontAppId}`);
+                this.error(`Could not find an installed storefront app by id: ${storefrontAppId}\n\nThe selected storefront app is not among the installed storefront apps`, {
+                    exit: 1,
+                });
+            }
+        }
+        // check inputFrontend value
+        if (!installedStorefrontApp &&
+            confirmYes &&
+            inputFrontend &&
+            inputFrontend !== 'none') {
+            const projectType = this.getProjectType(inputFrontend);
+            if (!projectType) {
+                // error should be thrown from getProjectType
+                return;
             }
         }
         const swellConfigJson = {
@@ -137,6 +297,7 @@ export default class CreateApp extends CreateAppCommand {
                 : {
                     permissions: [],
                 }),
+            ...(extensions && { extensions }),
         };
         const appPath = path.join(process.cwd(), inputId || appId);
         if (swellConfigFileExists(appPath)) {
@@ -151,7 +312,9 @@ export default class CreateApp extends CreateAppCommand {
                 }
             }
             else {
-                this.error(`An app already exists in the target path ${appPath}.`);
+                this.error(`An app already exists in the target path ${appPath}.\n\nCannot overwrite existing app`, {
+                    exit: 1,
+                });
             }
         }
         this.log(`\nCreating ${this.appType === 'theme' ? 'theme' : 'app'} ${style.appConfigValue(name)} in ${appPath}/swell.json`);
@@ -172,13 +335,19 @@ export default class CreateApp extends CreateAppCommand {
     async run() {
         const { args, flags } = await this.parse(CreateApp);
         const { id } = args;
-        const { pkg, yes } = flags;
-        const confirmYes = Boolean(yes && id);
+        const { pkg, yes, name, type, version, description, frontend } = flags;
+        const confirmYes = Boolean(yes);
         const createParams = await this.createSwellConfig({
             inputId: id,
             inputStorefrontApp: flags['storefront-app'],
-            inputType: flags.type,
+            inputType: type,
             inputYes: confirmYes,
+            inputName: name,
+            inputVersion: version,
+            inputDescription: description,
+            inputFrontend: frontend,
+            inputIntegrationType: flags['integration-type'],
+            inputIntegrationId: flags['integration-id'],
         });
         if (!createParams) {
             return;

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

@@ -1,6 +1,9 @@
 import { CreateCollectionCommand } from '../../create-collection-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 export default class CreateContent extends CreateCollectionCommand {
+    static args: {
+        collection: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: {
         command: string;
@@ -12,6 +15,7 @@ export default class CreateContent extends CreateCollectionCommand {
         label: 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>;
         views: 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/content.js

@@ -1,27 +1,40 @@
 import { checkbox } from '@inquirer/prompts';
-import { Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { CreateCollectionCommand } from '../../create-collection-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
-import { parseFields, parseViews, } from '../../lib/create/content.js';
-import { toFileName } from '../../lib/create/index.js';
+import { parseFields, parseViews, validateViews, } from '../../lib/create/content.js';
+import { SCHEMAS } from '../../lib/create/schemas.js';
+import { toCollectionLabel, toCollectionName, toFileName, } from '../../lib/create/index.js';
 export default class CreateContent extends CreateCollectionCommand {
-    static description = `This command assists in generating UI model configuration files. CLI will prompt for values when flags are not present.`;
+    static args = {
+        collection: Args.string({
+            default: '',
+            description: 'collection ID to create or apply to, e.g., products (required with -y)',
+        }),
+    };
+    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 models.`;
     static examples = [
         {
             command: 'swell create content',
             description: 'Create content model interactively.',
         },
         {
-            command: 'swell create content visitors -v list,edit,new',
-            description: 'Specify views delimited by semicolons.',
+            command: 'swell create content products -y',
+            description: 'Apply configuration to a standard collection (non-interactive)',
         },
         {
-            command: 'swell create content visitors -f name:short_text,description:long_text,verified:boolean,visitor_count:integer,photo:image,orders:collection',
-            description: 'Specify fields with types delimited by semicolons',
+            command: 'swell create content visitors -v list,edit,new -f name:short_text,verified:boolean -l "Visitors" -d "" -y',
+            description: 'Create custom collection with explicit fields and views (non-interactive)',
         },
         {
-            command: 'swell create content visitors -o -f verified:short_text -v list,edit,new -d "Visitor Views"',
-            description: 'Specify fields, views, and description.',
+            command: 'swell create content visitors --overwrite -y',
+            description: 'Non-interactive: force overwrite existing config file',
+        },
+        {
+            command: 'swell create content visitors -f name:short_text,description:long_text,verified:boolean,visitor_count:integer,photo:image,orders:collection',
+            description: 'Specify fields with types delimited by commas (interactive mode)',
         },
     ];
     static flags = {
@@ -33,30 +46,85 @@ export default class CreateContent extends CreateCollectionCommand {
         fields: Flags.string({
             char: 'f',
             default: '',
-            description: 'list of content model fields delimited by commas',
+            description: 'comma-separated id:type pairs (e.g., name:short_text, verified:boolean)',
         }),
         label: Flags.string({
             char: 'l',
             default: '',
-            description: 'content model label',
+            description: 'display label for the content model (defaults to capitalized collection name)',
         }),
         overwrite: Flags.boolean({
             default: false,
-            description: 'overwrite existing content model configuration file',
+            description: 'overwrite existing content model configuration file (use with -y to force overwrite)',
         }),
         views: Flags.string({
             char: 'v',
             default: '',
-            description: 'list of content model views delimited by commas, i.e. list,edit,new',
+            description: 'comma-separated views - valid: list, edit, new',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'accept all default values; non-interactive, never prompts; errors if required values are missing',
         }),
     };
     static summary = 'Initialize a content UI model config file with properties in the content folder.';
     createType = ConfigType.CONTENT;
     async run() {
-        const { flags } = await this.parse(CreateContent);
+        const { args, flags } = await this.parse(CreateContent);
+        const confirmYes = Boolean(flags.yes);
+        // NON-INTERACTIVE PATH
+        if (confirmYes) {
+            // Validate required arguments
+            const argCollection = args.collection;
+            if (!argCollection) {
+                this.error('Missing required argument for non-interactive mode: COLLECTION\n\nExample: swell create content products -y\n\nTip: run `swell models` to list standard collections you can extend.', { exit: 1 });
+            }
+            // Process and normalize collection name
+            const collection = toCollectionName(argCollection);
+            // Apply defaults for optional values
+            const label = flags.label || toCollectionLabel(collection);
+            const description = flags.description || '';
+            // Validate and parse views
+            let viewsList;
+            if (flags.views) {
+                viewsList = flags.views
+                    .split(',')
+                    .map((v) => v.trim())
+                    .filter(Boolean);
+                validateViews(viewsList, this.error.bind(this));
+            }
+            else {
+                // Default views when not specified
+                viewsList = ['list', 'edit', 'new'];
+            }
+            // Parse fields (no validation - trust user input)
+            const fieldsRaw = (flags.fields || '');
+            const fieldPairs = fieldsRaw
+                ? fieldsRaw
+                    .split(',')
+                    .map((v) => v.trim())
+                    .filter(Boolean)
+                : [];
+            // Build file body
+            const fileName = toFileName(collection);
+            const fileBody = {
+                $schema: SCHEMAS.CONTENT,
+                collection,
+                description,
+                fields: parseFields(fieldPairs),
+                label,
+                views: parseViews(viewsList),
+            };
+            // Create file with overwrite handling
+            await this.createFile({ fileBody, fileName }, flags.overwrite, 
+            /* shouldConfirm */ false);
+            return;
+        }
+        // INTERACTIVE PATH (existing logic)
         const { collection, description, label } = await this.promptCollection();
         const fileName = toFileName(collection);
         const fileBody = {
+            $schema: SCHEMAS.CONTENT,
             collection,
         };
         const { fields, overwrite, views } = flags;

package/dist/commands/create/function.js

@@ -70,10 +70,13 @@ export default class CreateFunction extends CreateConfigCommand {
         let writeFunctionFileParams = {
             description,
             events,
+            extension: undefined,
             functionName: functionName || '',
-            language: (functionName?.includes('.ts')
+            language: (functionName?.endsWith('.ts')
                 ? 'ts'
-                : 'js'),
+                : functionName?.endsWith('.js')
+                    ? 'js'
+                    : undefined),
             route,
             schedule,
             trigger: trigger,
@@ -85,6 +88,23 @@ export default class CreateFunction extends CreateConfigCommand {
         await this.writeFunctionFile(writeFunctionFileParams, overwrite);
     }
     async gatherInput(params) {
+        // Check if there are any extensions in the app configuration
+        const extensions = this.swellConfig.get('extensions') || [];
+        let { extension } = params;
+        const extensionsWithId = extensions.filter((ext) => ext.id);
+        if (extensionsWithId.length > 0 && !extension) {
+            const extensionChoices = [
+                { name: 'Not for an extension', value: '' },
+                ...extensionsWithId.map((ext) => ({
+                    name: ext.id,
+                    value: ext.id,
+                })),
+            ];
+            extension = await select({
+                choices: extensionChoices,
+                message: 'Is this function for an app extension?',
+            });
+        }
         let { language } = params;
         if (!language) {
             language = await select({
@@ -155,9 +175,9 @@ export default class CreateFunction extends CreateConfigCommand {
                 message: 'Name your function',
             });
         }
-        const { description } = params;
+        let { description } = params;
         if (!description) {
-            await input({
+            description = await input({
                 default: 'Does a thing when another other thing happens',
                 message: 'Describe what the function does',
             });
@@ -165,6 +185,7 @@ export default class CreateFunction extends CreateConfigCommand {
         return {
             description,
             events: events || '',
+            extension: extension || undefined,
             functionName,
             language,
             route: route || '',
@@ -172,13 +193,14 @@ export default class CreateFunction extends CreateConfigCommand {
             trigger,
         };
     }
-    async writeFunctionFile({ description, events, functionName, language, route, schedule, trigger, }, overwrite) {
+    async writeFunctionFile({ description, events, extension, functionName, language, route, schedule, trigger, }, overwrite) {
         const fileName = toFunctionFileName(functionName);
         await this.createFile({
             extension: language,
             fileBody: getFunctionTemplate({
                 description,
                 events,
+                extension,
                 functionName,
                 language,
                 route,

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

@@ -1,6 +1,9 @@
 import { CreateCollectionCommand } from '../../create-collection-command.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;
@@ -12,6 +15,7 @@ export default class CreateModel extends CreateCollectionCommand {
         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>;
         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;