@swell/cli 2.1.0 → 2.2.1

package/dist/push-app-command.d.ts

@@ -26,8 +26,8 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     deployFrontend(projectType: FrontendProjectType): Promise<string>;
     ensureAppExists(file?: string, shouldCreate?: boolean): Promise<boolean>;
     ensureLoggedIn(): Promise<true | undefined>;
-    execFrontend(command: string, onOutput?: (string: string) => any | false): Promise<void>;
     exec(command: string, cwd?: string, onOutput?: (string: string) => any | false): Promise<void>;
+    execFrontend(command: string, onOutput?: (string: string) => any | false): Promise<void>;
     getAllAppStorefronts(params?: {
         type?: string;
     }): Promise<any>;
@@ -51,19 +51,19 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
         appId?: string;
         targetPath?: string;
     }, flags?: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }): Promise<any>;
     getStorefrontToPush(flags?: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }): Promise<any>;
     setStorefrontEnv(flags: {
+        env?: string;
         'storefront-id'?: string;
         'storefront-select'?: boolean;
-        env?: string;
     }, defaultStorefront?: any): Promise<void>;
     handleWatchFileChange(configFile: string, configType: ConfigType, event: WatchFileEvent): Promise<void>;
     logAppFrontendUrl(): void;
@@ -78,15 +78,15 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     runWatchChangeQueue(): Promise<void>;
     saveCurrentStorefront(): void;
     setWatchingFiles(): Promise<void>;
+    startProxyServer(port?: number): Promise<number>;
     updateFrontendDeployment(currentStore: string, projectType: FrontendProjectType, deploymentUrl: string, deploymentHash: string): Promise<void>;
+    updateLocalProxy(proxyUrl: string, storefrontId?: string): Promise<void>;
     watchForChanges({ logChanges, onChange, syncAll, }?: {
         logChanges?: boolean;
         onChange?: (appConfig?: AppConfig, result?: any) => void;
         syncAll?: boolean;
     }): Promise<void>;
-    startProxyServer(port?: number): Promise<number>;
-    updateLocalProxy(proxyUrl: string, storefrontId?: string): Promise<void>;
-    wranglerDeployFrontend(projectType: FrontendProjectType): Promise<string>;
+    wranglerDeployFrontend(_projectType: FrontendProjectType): Promise<string>;
     private confirmRemoveInstalledApp;
 }
 export {};

package/dist/push-app-command.js

@@ -1,19 +1,19 @@
 import { confirm, input, select } from '@inquirer/prompts';
 import { $ } from 'execa';
+import getPort, { portNumbers } from 'get-port';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import Stream from 'node:stream';
-import getPort, { portNumbers } from 'get-port';
 import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
-import { ConfigType, FrontendProjectTypes, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
-import { selectEnvironmentId } from './lib/stores.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
 import { getGlobIgnorePathsChecker } from './lib/apps/paths.js';
 import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.js';
+import { getProxyUrl } from './lib/proxy.js';
+import { selectEnvironmentId } from './lib/stores.js';
 import style from './lib/style.js';
 import { RemoteAppCommand } from './remote-app-command.js';
-import { getProxyUrl } from './lib/proxy.js';
 const PUSH_CONCURRENCY = 3;
 const WATCH_WINDOW_MS = 100;
 const DEV_SERVER_FALLBACK_PORT = 3000;
@@ -307,9 +307,6 @@ export class PushAppCommand extends RemoteAppCommand {
             return true;
         }
     }
-    async execFrontend(command, onOutput) {
-        return this.exec(command, this.frontendPath, onOutput);
-    }
     async exec(command, cwd, onOutput) {
         const $$ = $({
             cwd: cwd || this.appPath,
@@ -334,6 +331,9 @@ export class PushAppCommand extends RemoteAppCommand {
             await $$ `${command}`;
         }
     }
+    async execFrontend(command, onOutput) {
+        return this.exec(command, this.frontendPath, onOutput);
+    }
     async getAllAppStorefronts(params) {
         const query = Object.entries(params || {})
             .map(([key, value]) => `${key}=${value}`)
@@ -435,7 +435,7 @@ export class PushAppCommand extends RemoteAppCommand {
                 this.showFrontendMigrationError();
             }
             // Frontend directory doesn't exist at all
-            this.error(`No valid frontend app found in ${this.frontendPath}. Supported frameworks include: ${FrontendProjectTypes.map((type) => type.slug).join(', ')}.`);
+            this.error(`No valid frontend app found in ${this.frontendPath}. Supported frameworks include: ${getFrontendProjectValidValues(false)}.`);
         }
         return projectType;
     }
@@ -561,8 +561,8 @@ export class PushAppCommand extends RemoteAppCommand {
                 await this.api.setStoreEnv(currentStore, defaultStorefront?.env);
             }
         }
-        else if (flags['env']) {
-            await this.api.setStoreEnv(currentStore, flags['env']);
+        else if (flags.env) {
+            await this.api.setStoreEnv(currentStore, flags.env);
         }
         else {
             const hasTestEnv = await this.api.isTestEnvEnabled();
@@ -703,8 +703,9 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         const queue = [...this.watchingChangeQueue.values()];
         this.watchingChangeQueue.clear();
+        // Process queue in batches with concurrency control
+        /* eslint-disable no-await-in-loop */
         while (queue.length > 0) {
-            // eslint-disable-next-line no-await-in-loop
             try {
                 await Promise.all(queue
                     .splice(0, PUSH_CONCURRENCY)
@@ -715,10 +716,11 @@ export class PushAppCommand extends RemoteAppCommand {
                     this.onWatchChange?.(appConfig, action, result);
                 }));
             }
-            catch (_err) {
-                //noop
+            catch {
+                // noop
             }
         }
+        /* eslint-enable no-await-in-loop */
         // refetch app to get updated configs
         this.app = await this.getAppWithConfig(this.app.id);
         // Process next accumulated changes
@@ -733,6 +735,16 @@ export class PushAppCommand extends RemoteAppCommand {
     async setWatchingFiles() {
         this.watchingFiles = new Set(await globAllFilesByPath(this.appPath));
     }
+    async startProxyServer(port) {
+        // Find an open port starting at 3000
+        const freePort = port ||
+            (await getPort({ port: portNumbers(3000, 3100) })) ||
+            DEV_SERVER_FALLBACK_PORT;
+        // Start proxy
+        const proxyUrl = await getProxyUrl(freePort);
+        await this.updateLocalProxy(proxyUrl, this.storefront?.id);
+        return freePort;
+    }
     async updateFrontendDeployment(currentStore, projectType, deploymentUrl, deploymentHash) {
         const spinner = ora();
         spinner.start('Updating frontend deployment...');
@@ -750,6 +762,17 @@ export class PushAppCommand extends RemoteAppCommand {
         }), () => spinner.fail('Error updating app deployment'));
         spinner.succeed('Updated frontend deployment.\n');
     }
+    async updateLocalProxy(proxyUrl, storefrontId) {
+        const storefront = this.app.type === 'storefront' &&
+            (await this.getAppStorefront({ storefront_id: storefrontId }));
+        await this.handleRequestErrors(async () => this.api.put({ adminPath: `/client/apps/${this.app.id}/local-proxy` }, {
+            body: {
+                proxy_url: proxyUrl,
+                storefront_id: storefront?.id || null,
+                storefront_slug: storefront?.slug || null,
+            },
+        }));
+    }
     async watchForChanges({ logChanges, onChange, syncAll, } = {}) {
         this.watchingIgnoreFilter = await getGlobIgnorePathsChecker(this.appPath);
         this.logWatchChanges = logChanges ?? true;
@@ -765,28 +788,7 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         fs.watch(this.appPath, { recursive: true }, this.watchListener);
     }
-    async startProxyServer(port) {
-        // Find an open port starting at 3000
-        const freePort = port ||
-            (await getPort({ port: portNumbers(3000, 3100) })) ||
-            DEV_SERVER_FALLBACK_PORT;
-        // Start proxy
-        const proxyUrl = await getProxyUrl(freePort);
-        await this.updateLocalProxy(proxyUrl, this.storefront?.id);
-        return freePort;
-    }
-    async updateLocalProxy(proxyUrl, storefrontId) {
-        const storefront = this.app.type === 'storefront' &&
-            (await this.getAppStorefront({ storefront_id: storefrontId }));
-        await this.handleRequestErrors(async () => this.api.put({ adminPath: `/client/apps/${this.app.id}/local-proxy` }, {
-            body: {
-                proxy_url: proxyUrl,
-                storefront_id: storefront?.id || null,
-                storefront_slug: storefront?.slug || null,
-            },
-        }));
-    }
-    async wranglerDeployFrontend(projectType) {
+    async wranglerDeployFrontend(_projectType) {
         let deploymentUrl;
         let interactiveError = false;
         let pagesProjectError = false;
@@ -795,7 +797,7 @@ export class PushAppCommand extends RemoteAppCommand {
             await this.execFrontend(`npx wrangler deploy`, (string) => {
                 // Dependent on wrangler output
                 // Parse the deployment URL from the wrangler output.
-                const match = string.match(/^\s*(https:\/\/\S+\.workers\.dev)\s*[\s\S]*?Current Version ID: [\w-]+/m);
+                const match = string.match(/^\s*(https:\/\/\S+\.workers\.dev)\s*[\S\s]*?Current Version ID: [\w-]+/m);
                 if (match && match.length > 0) {
                     deploymentUrl = match[1];
                     return false;

package/dist/remote-app-command.d.ts

@@ -5,11 +5,11 @@ import { App, AppConfig, AppVersion } from './lib/apps/index.js';
  * configurations.
  */
 export declare abstract class RemoteAppCommand extends AppCommand {
-    appType: string;
     static delayOrientation: boolean;
     static orientation: AppCommandOrientation;
     app: App;
     appCreated: boolean;
+    appType: string;
     storefront?: any;
     storefrontLocalUrl?: string;
     themeSyncApp?: boolean;

package/dist/remote-app-command.js

@@ -15,7 +15,6 @@ import style from './lib/style.js';
  * configurations.
  */
 export class RemoteAppCommand extends AppCommand {
-    appType = 'any';
     // allows child commands to set orientation
     static delayOrientation = false;
     // most of the times this will be the target environment
@@ -24,6 +23,7 @@ export class RemoteAppCommand extends AppCommand {
     app = {};
     // Indicates the app was created during the command execution
     appCreated = false;
+    appType = 'any';
     // API instance of the target storefront, if applicable
     storefront = null;
     // Indicates we are syncing with a local app frontend via proxy
@@ -638,7 +638,9 @@ export class RemoteAppCommand extends AppCommand {
         const { env, store } = flags;
         if (this.app.name) {
             // Show theme version if not syncing app
-            const version = !this.themeSyncApp && this.app.type === 'theme' && this.storefront?.theme_version
+            const version = !this.themeSyncApp &&
+                this.app.type === 'theme' &&
+                this.storefront?.theme_version
                 ? this.storefront?.theme_version
                 : this.app.version;
             orientationOutput.push(`[${this.app.type === 'theme' ? 'theme' : 'app'}] ${style.appName(this.app.name)}${version ? ` v${version}` : ''}`);

package/dist/swell-api-command.d.ts

@@ -0,0 +1,13 @@
+import { HttpMethod } from './lib/api.js';
+import { SwellCommand } from './swell-command.js';
+export declare abstract class SwellApiCommand extends SwellCommand {
+    protected abstract get method(): HttpMethod;
+    protected request(command: typeof SwellApiCommand, requestOptions?: Api.RequestOptions): Promise<void>;
+    protected catch(error: Error): Promise<any>;
+    private parseCommand;
+    private processBody;
+    private isFilePath;
+    private handleResponse;
+    private onSuccess;
+    private onError;
+}

package/dist/swell-api-command.js

@@ -0,0 +1,75 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { FetchError } from 'node-fetch';
+import { SwellCommand } from './swell-command.js';
+export class SwellApiCommand extends SwellCommand {
+    async request(command, requestOptions = {}) {
+        const { paths, options } = await this.parseCommand(command);
+        const response = await this.api[this.method](paths, {
+            rawResponse: true,
+            ...options,
+            ...requestOptions,
+        });
+        await this.handleResponse(response);
+    }
+    async catch(error) {
+        if (error instanceof FetchError) {
+            const message = `Could not connect to Swell API. Please try again later: ${error.message}`;
+            return this.onError(message, { exit: 2, code: error.code });
+        }
+        return this.onError(error.message, { exit: 1 });
+    }
+    async parseCommand(options, argv) {
+        const parsedInput = await super.parse(options, argv);
+        const { args, flags } = parsedInput;
+        const { path } = args;
+        const { live, body } = flags;
+        if (!live) {
+            await this.api.setEnv('test');
+        }
+        if (!path.startsWith('/')) {
+            throw new Error('Path must start with a forward slash (/)');
+        }
+        return {
+            ...parsedInput,
+            paths: { adminPath: `/data${path}` },
+            options: {
+                body: await this.processBody(body),
+            },
+        };
+    }
+    async processBody(body) {
+        if (!body) {
+            return;
+        }
+        const bodyData = this.isFilePath(body)
+            ? await fs.promises.readFile(path.resolve(body), 'utf8')
+            : body;
+        return JSON.parse(bodyData);
+    }
+    isFilePath(filePath) {
+        return (path.isAbsolute(filePath) ||
+            filePath.startsWith('./') ||
+            filePath.startsWith('../'));
+    }
+    async handleResponse(response) {
+        const responseText = await response.text();
+        if (responseText.length <= 2) {
+            throw new Error('Not found');
+        }
+        const result = JSON.parse(responseText);
+        if (result.error || result.errors || !response.ok) {
+            throw new Error(responseText);
+        }
+        this.onSuccess(result);
+    }
+    onSuccess(result) {
+        this.log(JSON.stringify(result, null, 2));
+    }
+    onError(message, { code, exit }) {
+        this.error(message, {
+            code,
+            exit,
+        });
+    }
+}

package/dist/swell-command.d.ts

@@ -14,8 +14,8 @@ export declare abstract class SwellCommand extends Command {
     api: Api;
     requiresAuth: boolean;
     constructor(argv: string[], config: Config);
-    catch(error: any): Promise<void>;
     debugJson(...args: any[]): void;
     logError(message: string): void;
     logSuccess(message: string): void;
+    protected catch(error: any): Promise<void>;
 }

package/dist/swell-command.js

@@ -21,15 +21,6 @@ export class SwellCommand extends Command {
         super(argv, config);
         this.api = new Api();
     }
-    async catch(error) {
-        if (error instanceof GitUnknownError) {
-            this.error(style.error(`git: ${error.stderr || error.stdout || error.message}`));
-        }
-        else if (error instanceof FetchError) {
-            this.error(`Could not connect to Swell API. Please try again later: ${error.message}`);
-        }
-        throw error;
-    }
     debugJson(...args) {
         const stringified = args.map((arg) => typeof arg === 'string' ? arg : JSON.stringify(arg, null, 4));
         this.debug(...stringified);
@@ -40,4 +31,13 @@ export class SwellCommand extends Command {
     logSuccess(message) {
         this.log(`${style.success(message)}`);
     }
+    async catch(error) {
+        if (error instanceof GitUnknownError) {
+            this.error(style.error(`git: ${error.stderr || error.stdout || error.message}`));
+        }
+        else if (error instanceof FetchError) {
+            this.error(`Could not connect to Swell API. Please try again later: ${error.message}`);
+        }
+        throw error;
+    }
 }