@swell/cli 2.1.0 → 2.2.0

package/dist/create-app-command.js

@@ -2,28 +2,35 @@ import { confirm, select } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import { $ } from 'execa';
 import { exec } from 'node:child_process';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import Stream from 'node:stream';
 import { promisify } from 'node:util';
 import ora from 'ora';
 import Api from './lib/api.js';
-import { FrontendProjectTypes, getAllConfigPaths, writeFile, writeJsonFile, } from './lib/apps/index.js';
+import { FrontendProjectTypes, getFrontendProjectValidValues, getAllConfigPaths, getFrontendProjectSlugs, writeFile, writeJsonFile, } from './lib/apps/index.js';
 import style from './lib/style.js';
 import { SwellCommand } from './swell-command.js';
-import fs from 'node:fs/promises';
 const execAsync = promisify(exec);
 export class CreateAppCommand extends SwellCommand {
     static baseFlags = {
         frontend: Flags.string({
-            description: `create a starter framework for a hosted frontend`,
-            options: FrontendProjectTypes.map(({ slug }) => slug),
+            description: `create a starter framework for a hosted frontend (default in -y: none)`,
+            options: getFrontendProjectSlugs(true, false),
         }),
         'storefront-app': Flags.string({
             description: `id of an installed storefront app to create a theme for, if applicable`,
         }),
+        'integration-type': Flags.string({
+            description: `integration type for integration app, if applicable`,
+            options: ['generic', 'payment', 'shipping', 'tax'],
+        }),
+        'integration-id': Flags.string({
+            description: `unique identifier for the integration service (required for payment/shipping/tax; use 'card' for credit cards)`,
+        }),
         yes: Flags.boolean({
             char: 'y',
-            description: `accept all default values`,
+            description: `accept all default values; non-interactive, never prompts; errors if required values are missing`,
         }),
     };
     devApi;
@@ -31,48 +38,11 @@ export class CreateAppCommand extends SwellCommand {
         super(argv, config);
         this.devApi = new Api(undefined, 'test');
     }
-    async addAllowedHostsToAstro(configPath) {
-        const astroConfigPath = path.join(configPath, 'frontend', 'astro.config.mjs');
-        let content;
-        try {
-            content = await fs.readFile(astroConfigPath, 'utf-8');
-        }
-        catch {
-            return;
-        }
-        if (content.includes('allowedHosts')) {
-            return;
-        }
-        const lines = content.split('\n');
-        let insertIndex = -1;
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes('defineConfig({')) {
-                insertIndex = i + 1;
-                break;
-            }
-        }
-        if (insertIndex === -1) {
-            return;
-        }
-        // Detect indentation from next line or use default
-        const nextLine = lines[insertIndex];
-        const indentMatch = nextLine?.match(/^(\s+)/);
-        const baseIndent = indentMatch ? indentMatch[1] : '  ';
-        const viteConfig = [
-            `${baseIndent}vite: {`,
-            `${baseIndent}  server: {`,
-            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
-            `${baseIndent}  },`,
-            `${baseIndent}},`,
-        ];
-        lines.splice(insertIndex, 0, ...viteConfig);
-        await fs.writeFile(astroConfigPath, lines.join('\n'), 'utf-8');
-    }
     async addAllowedHostsToAngular(configPath) {
         const angularJsonPath = path.join(configPath, 'frontend', 'angular.json');
         let content;
         try {
-            content = await fs.readFile(angularJsonPath, 'utf-8');
+            content = await fs.readFile(angularJsonPath, 'utf8');
         }
         catch {
             return;
@@ -84,7 +54,7 @@ export class CreateAppCommand extends SwellCommand {
         catch {
             return;
         }
-        const projects = config.projects;
+        const { projects } = config;
         if (!projects || typeof projects !== 'object') {
             return;
         }
@@ -105,13 +75,13 @@ export class CreateAppCommand extends SwellCommand {
             return;
         }
         project.architect.serve.options.allowedHosts = ['.ngrok.app', '.loca.lt'];
-        await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+        await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf8');
     }
-    async addAllowedHostsToNuxt(configPath) {
-        const nuxtConfigPath = path.join(configPath, 'frontend', 'nuxt.config.ts');
+    async addAllowedHostsToAstro(configPath) {
+        const astroConfigPath = path.join(configPath, 'frontend', 'astro.config.mjs');
         let content;
         try {
-            content = await fs.readFile(nuxtConfigPath, 'utf-8');
+            content = await fs.readFile(astroConfigPath, 'utf8');
         }
         catch {
             return;
@@ -121,8 +91,8 @@ export class CreateAppCommand extends SwellCommand {
         }
         const lines = content.split('\n');
         let insertIndex = -1;
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes('defineNuxtConfig({')) {
+        for (const [i, line] of lines.entries()) {
+            if (line.includes('defineConfig({')) {
                 insertIndex = i + 1;
                 break;
             }
@@ -130,6 +100,7 @@ export class CreateAppCommand extends SwellCommand {
         if (insertIndex === -1) {
             return;
         }
+        // Detect indentation from next line or use default
         const nextLine = lines[insertIndex];
         const indentMatch = nextLine?.match(/^(\s+)/);
         const baseIndent = indentMatch ? indentMatch[1] : '  ';
@@ -141,23 +112,43 @@ export class CreateAppCommand extends SwellCommand {
             `${baseIndent}},`,
         ];
         lines.splice(insertIndex, 0, ...viteConfig);
-        await fs.writeFile(nuxtConfigPath, lines.join('\n'), 'utf-8');
+        await fs.writeFile(astroConfigPath, lines.join('\n'), 'utf8');
     }
-    async addFrontendAllowedHosts(projectType, configPath) {
-        // Configure allowedHosts for frameworks using Vite dev server
-        // This allows tunneling services (ngrok, localtunnel) to proxy requests to the local dev environment
-        switch (projectType.slug) {
-            case 'astro':
-                await this.addAllowedHostsToAstro(configPath);
-                break;
-            case 'angular':
-                await this.addAllowedHostsToAngular(configPath);
-                break;
-            case 'nuxt':
-                await this.addAllowedHostsToNuxt(configPath);
+    async addAllowedHostsToNuxt(configPath) {
+        const nuxtConfigPath = path.join(configPath, 'frontend', 'nuxt.config.ts');
+        let content;
+        try {
+            content = await fs.readFile(nuxtConfigPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        if (content.includes('allowedHosts')) {
+            return;
+        }
+        const lines = content.split('\n');
+        let insertIndex = -1;
+        for (const [i, line] of lines.entries()) {
+            if (line.includes('defineNuxtConfig({')) {
+                insertIndex = i + 1;
                 break;
-            // Other frameworks don't require allowedHosts configuration
+            }
+        }
+        if (insertIndex === -1) {
+            return;
         }
+        const nextLine = lines[insertIndex];
+        const indentMatch = nextLine?.match(/^(\s+)/);
+        const baseIndent = indentMatch ? indentMatch[1] : '  ';
+        const viteConfig = [
+            `${baseIndent}vite: {`,
+            `${baseIndent}  server: {`,
+            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
+            `${baseIndent}  },`,
+            `${baseIndent}},`,
+        ];
+        lines.splice(insertIndex, 0, ...viteConfig);
+        await fs.writeFile(nuxtConfigPath, lines.join('\n'), 'utf8');
     }
     async createAppConfigFolders(swellConfig) {
         for (const type of getAllConfigPaths(swellConfig.get('type'))) {
@@ -171,13 +162,11 @@ export class CreateAppCommand extends SwellCommand {
     async createFrontendApp(swellConfig, flags, directCreate, kind) {
         const spinner = ora();
         const configPath = path.dirname(swellConfig.path);
-        const frameworkType = flags.frontend ||
+        // use 'none' by default for non-interactive mode
+        const inputFrontend = flags.yes ? flags.frontend || 'none' : flags.frontend;
+        const frameworkType = inputFrontend ||
             (await select({
                 choices: [
-                    ...FrontendProjectTypes.map(({ name, slug }) => ({
-                        name,
-                        value: slug,
-                    })),
                     ...(directCreate
                         ? []
                         : [
@@ -186,19 +175,17 @@ export class CreateAppCommand extends SwellCommand {
                                 value: null,
                             },
                         ]),
+                    ...FrontendProjectTypes.map(({ name, slug }) => ({
+                        name,
+                        value: slug,
+                    })),
                 ],
                 message: directCreate
                     ? `Choose framework for your hosted${kind ? ` ${kind} ` : ' '}app frontend`
                     : `Install framework for a hosted${kind ? ` ${kind} ` : ' '}app frontend?`,
             }));
-        if (frameworkType) {
-            const projectType = FrontendProjectTypes.find((type) => type.slug === frameworkType);
-            if (!projectType) {
-                this.error(`Could not find project type: ${frameworkType}`);
-            }
-            if (!projectType.installCommand) {
-                this.error(`Project type ${projectType.name} cannot be installed (legacy type)`);
-            }
+        if (frameworkType && frameworkType !== 'none') {
+            const projectType = this.getProjectType(frameworkType);
             this.log();
             spinner.start(`Creating ${projectType?.name} frontend app (this may take a while)...`);
             try {
@@ -223,11 +210,11 @@ export class CreateAppCommand extends SwellCommand {
             // Ensure frontend package.json has correct name for workspace
             const frontendPkgPath = path.join(configPath, 'frontend', 'package.json');
             try {
-                const pkgContent = await fs.readFile(frontendPkgPath, 'utf-8');
+                const pkgContent = await fs.readFile(frontendPkgPath, 'utf8');
                 const pkg = JSON.parse(pkgContent);
                 if (pkg.name !== 'frontend') {
                     pkg.name = 'frontend';
-                    await fs.writeFile(frontendPkgPath, JSON.stringify(pkg, null, 2), 'utf-8');
+                    await fs.writeFile(frontendPkgPath, JSON.stringify(pkg, null, 2), 'utf8');
                 }
             }
             catch {
@@ -242,7 +229,7 @@ export class CreateAppCommand extends SwellCommand {
                 await execAsync('npm install', { cwd: configPath });
                 spinner.succeed('Workspace initialized');
             }
-            catch (error) {
+            catch {
                 spinner.warn('Failed to initialize workspace');
             }
             spinner.succeed(`${projectType?.name} initialized app in ${configPath}/frontend/`);
@@ -364,6 +351,23 @@ export class CreateAppCommand extends SwellCommand {
         spinner.stop();
         return storefrontInstalledApps;
     }
+    getProjectType(frameworkType) {
+        const projectType = FrontendProjectTypes.find((type) => type.slug === frameworkType);
+        if (!projectType) {
+            this.error(`Could not find project type: ${frameworkType}\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: swell create app reviews --type admin --frontend astro -y`, {
+                exit: 1,
+            });
+        }
+        if (!projectType.installCommand) {
+            this.error(`Project type ${projectType.name} cannot be installed (legacy type)\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: swell create app reviews --type admin --frontend astro -y`, {
+                exit: 1,
+            });
+        }
+        return {
+            ...projectType,
+            installCommand: projectType.installCommand || '',
+        };
+    }
     async setupPackage(name, config, pkg) {
         const execAsync = promisify(exec);
         const configPath = path.dirname(config.path);
@@ -410,4 +414,23 @@ export class CreateAppCommand extends SwellCommand {
             this.log(`There was an error setting up the package manager: ${error.message}`);
         }
     }
+    async addFrontendAllowedHosts(projectType, configPath) {
+        // Configure allowedHosts for frameworks using Vite dev server
+        // This allows tunneling services (ngrok, localtunnel) to proxy requests to the local dev environment
+        switch (projectType.slug) {
+            case 'astro': {
+                await this.addAllowedHostsToAstro(configPath);
+                break;
+            }
+            case 'angular': {
+                await this.addAllowedHostsToAngular(configPath);
+                break;
+            }
+            case 'nuxt': {
+                await this.addAllowedHostsToNuxt(configPath);
+                break;
+            }
+            // Other frameworks don't require allowedHosts configuration
+        }
+    }
 }

package/dist/create-collection-command.js

@@ -41,7 +41,10 @@ export class CreateCollectionCommand extends CreateConfigCommand {
         }),
     };
     async promptCollection() {
-        const { args, flags } = await this.parse(CreateCollectionCommand);
+        // Parse using the concrete command class so child-command flags
+        // (e.g., --events, --fields) are recognized during interactive flows.
+        const klass = super.ctor;
+        const { args, flags } = await this.parse(klass);
         let { description, label } = flags;
         let { collection } = args;
         let isStandardCollection = false;

package/dist/create-config-command.js

@@ -35,6 +35,10 @@ export class CreateConfigCommand extends AppCommand {
                 }
             }
         }
+        else if (filePathExists(filePath) && !overwrite) {
+            // Non-interactive mode: never prompt; fail fast on potential overwrite
+            this.error(`A ${this.createType} file already exists at ${filePath}.\n\nUse --overwrite to replace the existing file in non-interactive mode.`, { exit: 1 });
+        }
         typeof fileBody === 'string'
             ? await writeFile(filePath, fileBody)
             : await writeJsonFile(filePath, fileBody);

package/dist/env/local.d.ts

@@ -5,5 +5,6 @@ declare namespace _default {
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
     let LOCAL_PROXY_PROVIDER: string;
+    let SCHEMAS_BASE_URL: string;
 }
 export default _default;

package/dist/env/local.js

@@ -5,4 +5,5 @@ export default {
     APP_PAGES_HOST: 'http://${STORE_ID}--${APP_ID}--${ENV}.swell.test:4001',
     STOREFRONT_FRONTEND_HOST: 'http://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.test:4001',
     LOCAL_PROXY_PROVIDER: '',
+    SCHEMAS_BASE_URL: 'https://pub-3672563ccb924eeba4d45be1296a0aee.r2.dev',
 };

package/dist/env/production.d.ts

@@ -5,5 +5,6 @@ declare namespace _default {
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
     let LOCAL_PROXY_PROVIDER: string;
+    let SCHEMAS_BASE_URL: string;
 }
 export default _default;

package/dist/env/production.js

@@ -5,4 +5,5 @@ export default {
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.store',
     LOCAL_PROXY_PROVIDER: '',
+    SCHEMAS_BASE_URL: 'https://json.swell.store',
 };

package/dist/env/review.d.ts

@@ -5,5 +5,6 @@ declare namespace _default {
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
     let LOCAL_PROXY_PROVIDER: string;
+    let SCHEMAS_BASE_URL: string;
 }
 export default _default;

package/dist/env/review.js

@@ -5,4 +5,5 @@ export default {
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.${REVIEW_DOMAIN}.rav2.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.${REVIEW_DOMAIN}.rav2.swell.store',
     LOCAL_PROXY_PROVIDER: '',
+    SCHEMAS_BASE_URL: 'https://pub-3672563ccb924eeba4d45be1296a0aee.r2.dev',
 };

package/dist/env/staging.d.ts

@@ -5,5 +5,6 @@ declare namespace _default {
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
     let LOCAL_PROXY_PROVIDER: string;
+    let SCHEMAS_BASE_URL: string;
 }
 export default _default;

package/dist/env/staging.js

@@ -5,4 +5,5 @@ export default {
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.staging.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.staging.swell.store',
     LOCAL_PROXY_PROVIDER: '',
+    SCHEMAS_BASE_URL: 'https://pub-3672563ccb924eeba4d45be1296a0aee.r2.dev',
 };

package/dist/lib/api.d.ts

@@ -1,16 +1,27 @@
+export declare enum HttpMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete"
+}
 export default class Api {
     envId: string | undefined;
     secretKey: string | undefined;
     storeId: string | undefined;
     constructor(storeId?: string, envId?: string, secretKey?: string);
     api(pathOpts: Api.Paths, options: Api.RequestOptions): Promise<any>;
-    delete(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     get(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
-    isAdmin(): boolean;
+    getAll(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<{
+        count: number;
+        results: any[];
+    }>;
     post(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     put(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
-    setStoreEnv(storeId: string, envId?: string): Promise<void>;
+    delete(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     isTestEnvEnabled(): Promise<boolean>;
-    truncatePath(path: string | undefined): string | undefined;
-    waitForAsyncResponse(response: any, pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+    setEnv(envId: string): Promise<void>;
+    setStoreEnv(storeId: string, envId?: string): Promise<void>;
+    private isAdmin;
+    private truncatePath;
+    private waitForAsyncResponse;
 }

package/dist/lib/api.js

@@ -2,6 +2,14 @@ import fetch from 'node-fetch';
 import { stringify } from 'qs';
 import config from './config.js';
 import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "get";
+    HttpMethod["POST"] = "post";
+    HttpMethod["PUT"] = "put";
+    HttpMethod["DELETE"] = "delete";
+})(HttpMethod || (HttpMethod = {}));
+const GET_ALL_LIMIT = 1000;
 const defaultHeaders = (opts) => ({
     'Content-Type': 'application/json',
     ...opts,
@@ -59,6 +67,9 @@ export default class Api {
         if (!path)
             throw new Error('Operation not supported.');
         const res = await fetch(path, fetchOptions);
+        if (options.rawResponse) {
+            return res;
+        }
         const resData = await res.text();
         if (!res.ok) {
             // Try to parse error message
@@ -84,31 +95,46 @@ export default class Api {
             return null;
         }
     }
-    async delete(pathOpts, options = {}) {
-        // ensure post body is stringified
-        if (options.body)
-            options.body = JSON.stringify(options.body);
-        const response = await this.api(pathOpts, {
-            method: 'DELETE',
-            ...options,
-        });
-        return this.waitForAsyncResponse(response, pathOpts, options);
-    }
     async get(pathOpts, options = {}) {
         return this.api(pathOpts, {
-            method: 'GET',
+            method: HttpMethod.GET,
             ...options,
         });
     }
-    isAdmin() {
-        return !this.secretKey;
+    async getAll(pathOpts, options = {}) {
+        const result = {
+            results: [],
+            count: 0,
+        };
+        let page = 1;
+        do {
+            // eslint-disable-next-line no-await-in-loop
+            const pageResult = await this.api(pathOpts, {
+                method: HttpMethod.GET,
+                ...options,
+                query: {
+                    limit: GET_ALL_LIMIT,
+                    ...options.query,
+                    page,
+                },
+            });
+            if (pageResult && pageResult.results) {
+                result.results = [...result.results, ...pageResult.results];
+                result.count = pageResult.count;
+                page++;
+            }
+            else {
+                break;
+            }
+        } while (result.count > result.results.length && result.results.length > 0);
+        return result;
     }
     async post(pathOpts, options = {}) {
         // ensure post body is stringified
         if (options.body)
             options.body = JSON.stringify(options.body);
         const response = await this.api(pathOpts, {
-            method: 'POST',
+            method: HttpMethod.POST,
             ...options,
         });
         return this.waitForAsyncResponse(response, pathOpts, options);
@@ -118,20 +144,20 @@ export default class Api {
         if (options.body)
             options.body = JSON.stringify(options.body);
         const response = await this.api(pathOpts, {
-            method: 'PUT',
+            method: HttpMethod.PUT,
             ...options,
         });
         return this.waitForAsyncResponse(response, pathOpts, options);
     }
-    async setStoreEnv(storeId, envId) {
-        if (envId) {
-            const hasTestEnv = await this.isTestEnvEnabled();
-            if (!hasTestEnv) {
-                throw new Error('Test environment is not enabled for this store.');
-            }
-        }
-        this.storeId = storeId;
-        this.envId = envId;
+    async delete(pathOpts, options = {}) {
+        // ensure post body is stringified
+        if (options.body)
+            options.body = JSON.stringify(options.body);
+        const response = await this.api(pathOpts, {
+            method: HttpMethod.DELETE,
+            ...options,
+        });
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     async isTestEnvEnabled() {
         const clientRecord = await this.get({
@@ -139,6 +165,22 @@ export default class Api {
         });
         return clientRecord.test_enabled !== false;
     }
+    async setEnv(envId) {
+        const hasTestEnv = await this.isTestEnvEnabled();
+        if (!hasTestEnv) {
+            throw new Error('Test environment is not enabled for this store.');
+        }
+        this.envId = envId;
+    }
+    async setStoreEnv(storeId, envId) {
+        if (envId) {
+            await this.setEnv(envId);
+        }
+        this.storeId = storeId;
+    }
+    isAdmin() {
+        return !this.secretKey;
+    }
     truncatePath(path) {
         return path?.startsWith('/') ? path.slice(1) : path;
     }
@@ -151,7 +193,7 @@ export default class Api {
             setTimeout(resolve, 1000);
         });
         const asyncResponse = await this.api(onAsyncGetPath(response), {
-            method: 'GET',
+            method: HttpMethod.GET,
             onAsyncGetPath,
         });
         if (asyncResponse?.async_error) {

package/dist/lib/app-config.js

@@ -7,6 +7,7 @@ import * as path from 'node:path';
 const schema = {
     compatibilities: { type: 'object' },
     description: { type: 'string' },
+    extensions: { type: 'array' },
     id: { type: 'string' },
     integrations: { type: 'array' },
     name: { type: 'string' },

package/dist/lib/apps/index.d.ts

@@ -125,6 +125,8 @@ export interface FrontendProjectType {
     slug: string;
 }
 export declare const FrontendProjectTypes: FrontendProjectType[];
+export declare function getFrontendProjectSlugs(withNone?: boolean, withLegacy?: boolean): string[];
+export declare function getFrontendProjectValidValues(withNone?: boolean, withLegacy?: boolean): string;
 export declare function getAppSlugId(app: App): string | undefined;
 export declare function getFrontendProjectType(appPath: string): FrontendProjectType | undefined;
 export declare function getConfigTypeFromPath(path: string): ConfigType | undefined;