@swell/cli 2.0.20 → 2.2.0

package/dist/create-app-command.js

@@ -2,27 +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';
 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;
@@ -30,6 +38,118 @@ export class CreateAppCommand extends SwellCommand {
         super(argv, config);
         this.devApi = new Api(undefined, 'test');
     }
+    async addAllowedHostsToAngular(configPath) {
+        const angularJsonPath = path.join(configPath, 'frontend', 'angular.json');
+        let content;
+        try {
+            content = await fs.readFile(angularJsonPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        let config;
+        try {
+            config = JSON.parse(content);
+        }
+        catch {
+            return;
+        }
+        const { projects } = config;
+        if (!projects || typeof projects !== 'object') {
+            return;
+        }
+        const projectNames = Object.keys(projects);
+        if (projectNames.length === 0) {
+            return;
+        }
+        // Use first project (typically only one exists in new apps)
+        const projectName = projectNames[0];
+        const project = projects[projectName];
+        if (!project?.architect?.serve) {
+            return;
+        }
+        if (!project.architect.serve.options) {
+            project.architect.serve.options = {};
+        }
+        if (project.architect.serve.options.allowedHosts) {
+            return;
+        }
+        project.architect.serve.options.allowedHosts = ['.ngrok.app', '.loca.lt'];
+        await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    async addAllowedHostsToAstro(configPath) {
+        const astroConfigPath = path.join(configPath, 'frontend', 'astro.config.mjs');
+        let content;
+        try {
+            content = await fs.readFile(astroConfigPath, '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('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'), 'utf8');
+    }
+    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;
+            }
+        }
+        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'))) {
             // Create a config folder
@@ -42,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
                         ? []
                         : [
@@ -57,16 +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 (frameworkType && frameworkType !== 'none') {
+            const projectType = this.getProjectType(frameworkType);
             this.log();
             spinner.start(`Creating ${projectType?.name} frontend app (this may take a while)...`);
             try {
@@ -88,6 +207,31 @@ export class CreateAppCommand extends SwellCommand {
                 this.log();
                 return false;
             }
+            // Ensure frontend package.json has correct name for workspace
+            const frontendPkgPath = path.join(configPath, 'frontend', 'package.json');
+            try {
+                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), 'utf8');
+                }
+            }
+            catch {
+                // Ignore if package.json doesn't exist or can't be read
+            }
+            await this.addFrontendAllowedHosts(projectType, configPath);
+            // Re-run npm install at root to properly initialize workspace structure
+            // (removes frontend/package-lock.json, hoists dependencies, creates root lock file)
+            spinner.start('Initializing workspace...');
+            try {
+                const execAsync = promisify(exec);
+                await execAsync('npm install', { cwd: configPath });
+                spinner.succeed('Workspace initialized');
+            }
+            catch {
+                spinner.warn('Failed to initialize workspace');
+            }
             spinner.succeed(`${projectType?.name} initialized app in ${configPath}/frontend/`);
             if (directCreate) {
                 this.log();
@@ -207,11 +351,31 @@ 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);
         const packageJson = {
             description: config.get('description'),
+            // Include workspace even if frontend doesn't exist yet
+            // npm tolerates missing workspace directories without errors
+            workspaces: ['frontend'],
             devDependencies: {
                 '@swell/app-types': '^1.0.5',
             },
@@ -226,7 +390,7 @@ export class CreateAppCommand extends SwellCommand {
                 target: 'esnext',
                 types: ['@swell/app-types'],
             },
-            exclude: ['node_modules'],
+            exclude: ['node_modules', 'frontend'],
             include: ['**/*.ts'],
         };
         await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
@@ -250,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

@@ -4,5 +4,7 @@ declare namespace _default {
     let LOGIN_HOST: string;
     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

@@ -4,4 +4,6 @@ export default {
     LOGIN_HOST: 'http://${STORE_ID}.swell.test:3000',
     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

@@ -4,5 +4,7 @@ declare namespace _default {
     let LOGIN_HOST: string;
     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

@@ -4,4 +4,6 @@ export default {
     LOGIN_HOST: 'https://${STORE_ID}.swell.store',
     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

@@ -4,5 +4,7 @@ declare namespace _default {
     let LOGIN_HOST: string;
     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

@@ -4,4 +4,6 @@ export default {
     LOGIN_HOST: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
     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

@@ -4,5 +4,7 @@ declare namespace _default {
     let LOGIN_HOST: string;
     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

@@ -4,4 +4,6 @@ export default {
     LOGIN_HOST: 'https://staging.swell.store',
     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/app-config.d.ts

@@ -53,4 +53,53 @@ export declare abstract class AppConfig {
     protected abstract preparePostData(postData: any): Promise<any>;
     abstract type: ConfigType;
 }
+export declare class AppConfigDefault extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigModel extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigContent extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigNotification extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigSetting extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigWebhook extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigFunction extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    isRootFunction(): boolean;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigAsset extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+}
+export declare class AppConfigFrontend extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+}
+export declare class AppConfigTheme extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
 export {};