@swell/cli 2.0.11 → 2.0.12

package/dist/lib/apps/index.js

@@ -4,8 +4,10 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { toAppId } from '../create/index.js';
 import { AppConfig } from './app-config.js';
-const PUSH_CONCURRENCY = 3;
-var SwellJsonFields;
+export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
+export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, } from './paths.js';
+export const PUSH_CONCURRENCY = 3;
+export var SwellJsonFields;
 (function (SwellJsonFields) {
     SwellJsonFields["DESCRIPTION"] = "description";
     SwellJsonFields["EXTENSIONS"] = "extensions";
@@ -18,7 +20,7 @@ var SwellJsonFields;
     SwellJsonFields["TYPE"] = "type";
     SwellJsonFields["VERSION"] = "version";
 })(SwellJsonFields || (SwellJsonFields = {}));
-var ConfigType;
+export var ConfigType;
 (function (ConfigType) {
     ConfigType["ASSET"] = "asset";
     ConfigType["CONTENT"] = "content";
@@ -56,30 +58,35 @@ const StandardConfigTypes = [
     'WEBHOOK',
     'THEME',
 ];
-const StorefrontConfigTypes = ['FRONTEND', 'ASSET', 'SETTING'];
-const ThemeConfigTypes = ['THEME', 'ASSET'];
-const getConfigPaths = (types) => ({
-    ...Object.fromEntries(Object.keys(ConfigType)
-        .filter((type) => !types || types.find((inType) => inType === type))
-        .map((type) => [
-        type,
+export const StorefrontConfigTypes = [
+    'FRONTEND',
+    'ASSET',
+    'SETTING',
+];
+export const ThemeConfigTypes = ['THEME', 'ASSET'];
+const getConfigPaths = (types) => 
+// eslint-disable-next-line unicorn/no-array-reduce
+Object.keys(ConfigType).reduce((acc, type) => {
+    if (types.includes(type)) {
         // a bit of a hack to make the path singular for content configs
         // need to refactor this to a function if we add more exceptions
-        type === 'CONTENT' || type === 'FRONTEND' || type === 'THEME'
-            ? type.toLowerCase()
-            : pluralize(type.toLowerCase()),
-    ])),
-});
-const ConfigPaths = {
+        acc[type] =
+            type === 'CONTENT' || type === 'FRONTEND' || type === 'THEME'
+                ? type.toLowerCase()
+                : pluralize(type.toLowerCase());
+    }
+    return acc;
+}, {});
+export const ConfigPaths = {
     ...getConfigPaths(StandardConfigTypes),
 };
-const StorefrontConfigPaths = {
+export const StorefrontConfigPaths = {
     ...getConfigPaths(StorefrontConfigTypes),
 };
-const ThemeConfigPaths = {
+export const ThemeConfigPaths = {
     ...getConfigPaths(ThemeConfigTypes),
 };
-var ConfigInputFields;
+export var ConfigInputFields;
 (function (ConfigInputFields) {
     ConfigInputFields["FILE"] = "file";
     ConfigInputFields["NAME"] = "name";
@@ -87,7 +94,7 @@ var ConfigInputFields;
     ConfigInputFields["VALUES"] = "values";
     ConfigInputFields["VERSION"] = "version";
 })(ConfigInputFields || (ConfigInputFields = {}));
-const FrontendProjectTypes = [
+export const FrontendProjectTypes = [
     {
         buildCommand: 'npx @cloudflare/next-on-pages',
         configFileName: 'next.config',
@@ -108,10 +115,10 @@ const FrontendProjectTypes = [
     },
 ];
 const frontendProjectConfigExtensions = ['.mjs', '.js'];
-function getAppSlugId(app) {
+export function getAppSlugId(app) {
     return toAppId(app.private_id) || app.public_id || app.id;
 }
-function getFrontendProjectType(appPath) {
+export function getFrontendProjectType(appPath) {
     for (const projectType of FrontendProjectTypes) {
         for (const extension of frontendProjectConfigExtensions) {
             const configFile = path.join(appPath, 'frontend', `${projectType.configFileName}${extension}`);
@@ -121,7 +128,7 @@ function getFrontendProjectType(appPath) {
         }
     }
 }
-function getConfigTypeFromPath(path) {
+export function getConfigTypeFromPath(path) {
     for (const type in ConfigPaths) {
         if (ConfigPaths[type] === path) {
             const configType = ConfigType[type];
@@ -130,10 +137,10 @@ function getConfigTypeFromPath(path) {
     }
     return undefined;
 }
-function getConfigTypeKeyFromValue(value) {
+export function getConfigTypeKeyFromValue(value) {
     return Object.keys(ConfigType).find((key) => ConfigType[key] === value);
 }
-function filePathExists(filePath) {
+export function filePathExists(filePath) {
     try {
         // eslint-disable-next-line no-bitwise
         fs.accessSync(filePath, fs.constants.R_OK | fs.constants.W_OK);
@@ -146,58 +153,54 @@ function filePathExists(filePath) {
         return false;
     }
 }
-async function writeFile(file, data) {
+export async function filePathExistsAsync(filePath) {
+    try {
+        // eslint-disable-next-line no-bitwise
+        await fs.promises.access(filePath, fs.constants.R_OK | fs.constants.W_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+export async function writeFile(file, data) {
     // Convert from base64 if needed
     let contents;
     try {
-        const isBase64 = Buffer.from(data, 'base64').toString('base64') === data;
-        contents = isBase64 ? Buffer.from(data, 'base64') : data;
+        const decoded = Buffer.from(data, 'base64');
+        const isBase64 = decoded.toString('base64') === data;
+        contents = isBase64 ? decoded : data;
     }
     catch {
         contents = data;
     }
-    return new Promise((resolve, _reject) => {
-        fs.mkdir(path.dirname(file), { recursive: true }, (error) => {
-            if (error) {
-                throw error;
-            }
-            fs.writeFile(file, contents || '', (error) => {
-                if (error) {
-                    throw error;
-                }
-                resolve();
-            });
-        });
-    });
+    await fs.promises.mkdir(path.dirname(file), { recursive: true });
+    await fs.promises.writeFile(file, contents);
 }
-function deleteFile(file) {
-    return new Promise((resolve, _reject) => {
-        fs.unlink(file, (error) => {
-            if (error) {
-                throw error;
-            }
-            resolve();
-        });
-    });
+export function deleteFile(file) {
+    return fs.promises.unlink(file);
 }
-async function writeJsonFile(file, data = {}) {
+export async function writeJsonFile(file, data = {}) {
     return writeFile(file, `${JSON.stringify(data, null, 2)}\n`);
 }
 // Hash method adapted from wrangler-sdk
-function hashFile(filePath, fileContents, relativePath) {
+export function hashFile(filePath, fileContents, relativePath) {
     const contents = fileContents ?? fs.readFileSync(filePath);
     // Include relative file path because we typically cache by hash including file metadata
     // This allows de-duplication of cache entries for the same file contents
     return hashString(contents, relativePath || '');
 }
-function hashString(...contents) {
+export function hashString(...contents) {
     const hash = createBlake3Hash();
     for (const content of contents) {
         hash.update(content);
     }
     return hash.digest('hex', { length: 16 });
 }
-function appAssetImage(appPath, fileName) {
+export function appAssetImage(appPath, fileName) {
     const assetsDirPath = path.join(appPath, ConfigPaths['ASSET']);
     if (!filePathExists(assetsDirPath)) {
         return;
@@ -208,7 +211,7 @@ function appAssetImage(appPath, fileName) {
         }
     }
 }
-function appConfigFromFile(filePath, configType, appPath) {
+export function appConfigFromFile(filePath, configType, appPath) {
     const { name } = path.parse(filePath);
     const config = AppConfig.create({
         name,
@@ -223,7 +226,7 @@ function appConfigFromFile(filePath, configType, appPath) {
     }
     return config;
 }
-function findAppConfig(app, filePath, configType) {
+export function findAppConfig(app, filePath, configType) {
     const { name } = path.parse(filePath);
     const config = app?.configs?.find((c) => c && c.type === configType && c.name === name);
     return config;
@@ -234,7 +237,7 @@ function findAppConfig(app, filePath, configType) {
  * @param {AppConfig[]} configs - List of app configs
  * @returns {BatchAppFiles[]} Batches of files to push
  */
-function batchAppFilesByType(configs) {
+export function batchAppFilesByType(configs) {
     const modelsWithExtends = configs.filter((config) => config.type === 'model' && config.values.extends);
     const modelsWithoutExtends = configs.filter((config) => config.type === 'model' && !config.values.extends);
     const contentTypesWithCollection = configs.filter((config) => config.type === 'content' && config.values.collection);
@@ -266,8 +269,3 @@ function batchAppFilesByType(configs) {
     // Add base files if config types are not specified
     return batches;
 }
-export { PUSH_CONCURRENCY, ConfigInputFields, ConfigPaths, ConfigType, FrontendProjectTypes, StorefrontConfigPaths, StorefrontConfigTypes, SwellJsonFields, ThemeConfigPaths, ThemeConfigTypes, appAssetImage, appConfigFromFile, batchAppFilesByType, deleteFile, filePathExists, findAppConfig, 
-// functions
-getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, hashFile, hashString, writeFile, writeJsonFile, };
-export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
-export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, } from './paths.js';

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

@@ -1,25 +1,26 @@
+import { type GlobbyFilterFunction } from 'globby';
 import { ConfigType } from './index.js';
-declare function globAllFilesByPath(appPath: string, dirPath?: string): string[];
-declare function allConfigDirsPaths(appPath: string): Generator<{
+export declare function globAllFilesByPath(appPath: string, dirPath?: string): Promise<string[]>;
+export declare function getGlobIgnorePathsChecker(appPath: string): Promise<GlobbyFilterFunction>;
+export declare function allConfigDirsPaths(appPath: string): Generator<{
     configDir: string;
     configType: ConfigType;
 }>;
-declare function allConfigFilesPaths(appPath: string): Generator<{
+export declare function allConfigFilesPaths(appPath: string): Generator<{
     configDir: string;
     configFile: string;
     configType: ConfigType;
 }, void, unknown>;
-declare function allConfigFilesPathsByType(appPath: string, configTypeKey: string): Generator<{
+export declare function allConfigFilesPathsByType(appPath: string, configTypeKey: string): Generator<{
     configDir: string;
     configFile: string;
     configType: ConfigType;
 }, void, unknown>;
-declare function allConfigFilesInDir(appPath: string, dirPath: string, configType: ConfigType): Generator<{
+export declare function allConfigFilesInDir(appPath: string, dirPath: string, configType: ConfigType): Generator<{
     configDir: string;
     configFile: string;
     configType: ConfigType;
 }, void, unknown>;
-declare function allBaseFilesInDir(appPath: string): Generator<string, void, unknown>;
-declare function getAllConfigPaths(appType: string): Array<string>;
-declare function isPathDirectory(path: string): boolean;
-export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, };
+export declare function allBaseFilesInDir(appPath: string): Generator<string, void, unknown>;
+export declare function getAllConfigPaths(appType: string): string[];
+export declare function isPathDirectory(path: string): boolean;

package/dist/lib/apps/paths.js

@@ -1,9 +1,9 @@
-import { globbySync } from 'globby';
+import { globby, globbySync, isGitIgnored, } from 'globby';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { ConfigPaths, ConfigType, StorefrontConfigPaths, ThemeConfigPaths, filePathExists, } from './index.js';
-function globFiles(pattern, appPath, dirPath = '.', options = {}) {
-    const filePaths = globbySync(`${dirPath}${path.sep}${pattern}`, {
+function globOptions(appPath, options) {
+    return {
         cwd: appPath,
         dot: true,
         gitignore: true,
@@ -18,75 +18,80 @@ function globFiles(pattern, appPath, dirPath = '.', options = {}) {
             '**/yarn.lock',
             ...(options?.ignore || []),
         ],
-    });
-    return filePaths;
+    };
+}
+function globFilesSync(pattern, appPath, dirPath = '.', options = {}) {
+    return globbySync(`${dirPath}${path.sep}${pattern}`, globOptions(appPath, options));
+}
+function globFiles(pattern, appPath, dirPath = '.', options = {}) {
+    return globby(`${dirPath}${path.sep}${pattern}`, globOptions(appPath, options));
 }
-function globAllFilesByPath(appPath, dirPath) {
+export function globAllFilesByPath(appPath, dirPath) {
     return globFiles('**', appPath, dirPath);
 }
-function getConfirDirsPaths(appPath) {
+export function getGlobIgnorePathsChecker(appPath) {
+    return isGitIgnored({ cwd: appPath });
+}
+function getConfigDirsPaths(appPath) {
     const configDirsPaths = [];
-    for (const type in ConfigType) {
-        if (Object.prototype.hasOwnProperty.call(ConfigType, type)) {
-            const configType = ConfigType[type];
-            const configPath = ConfigPaths[type];
-            if (!configPath) {
-                continue;
-            }
-            const configDir = path.join(appPath, configPath);
-            if (filePathExists(configDir)) {
-                configDirsPaths.push({ configDir: configPath, configType });
-            }
+    for (const [type, configType] of Object.entries(ConfigType)) {
+        const configPath = ConfigPaths[type];
+        if (!configPath) {
+            continue;
+        }
+        const configDir = path.join(appPath, configPath);
+        if (filePathExists(configDir)) {
+            configDirsPaths.push({ configDir: configPath, configType });
         }
     }
     return configDirsPaths;
 }
-function* allConfigDirsPaths(appPath) {
-    for (const { configDir, configType } of getConfirDirsPaths(appPath)) {
+export function* allConfigDirsPaths(appPath) {
+    for (const { configDir, configType } of getConfigDirsPaths(appPath)) {
         yield { configDir, configType };
     }
 }
-function* allConfigFilesPaths(appPath) {
+export function* allConfigFilesPaths(appPath) {
     for (const { configDir, configType } of allConfigDirsPaths(appPath)) {
         yield* allConfigFilesInDir(appPath, configDir, configType);
     }
 }
-function* allConfigFilesPathsByType(appPath, configTypeKey) {
+export function* allConfigFilesPathsByType(appPath, configTypeKey) {
     const configPath = ConfigPaths[configTypeKey];
     yield* allConfigFilesInDir(appPath, configPath, ConfigType[configTypeKey]);
 }
-function* allConfigFilesInDir(appPath, dirPath, configType) {
-    const filePaths = globFiles('**', appPath, dirPath);
+export function* allConfigFilesInDir(appPath, dirPath, configType) {
+    const filePaths = globFilesSync('**', appPath, dirPath);
     for (const configFile of filePaths) {
         yield { configDir: dirPath, configFile, configType };
     }
 }
-function* allBaseFilesInDir(appPath) {
+export function* allBaseFilesInDir(appPath) {
     // Only get base files excluding config directories
-    const configPaths = getConfirDirsPaths(appPath);
-    const baseFiles = globFiles('**', appPath, '.', {
+    const configPaths = getConfigDirsPaths(appPath);
+    const baseFiles = globFilesSync('**', appPath, '.', {
         ignore: configPaths.map((config) => `${config.configDir}/**`),
     });
     for (const path of baseFiles) {
         yield path;
     }
 }
-function getAllConfigPaths(appType) {
+export function getAllConfigPaths(appType) {
     const configPaths = [];
     const ConfigPathsByType = appType === 'storefront'
         ? StorefrontConfigPaths
         : appType === 'theme'
             ? ThemeConfigPaths
             : ConfigPaths;
-    for (const type in ConfigPathsByType) {
-        if (Object.prototype.hasOwnProperty.call(ConfigPaths, type)) {
+    for (const type of Object.keys(ConfigPathsByType)) {
+        if (Object.hasOwn(ConfigPaths, type)) {
             const configPath = ConfigPaths[type];
             configPaths.push(configPath);
         }
     }
     return configPaths;
 }
-function isPathDirectory(path) {
+export function isPathDirectory(path) {
     try {
         const stat = fs.statSync(path);
         return stat.isDirectory();
@@ -96,4 +101,3 @@ function isPathDirectory(path) {
         return false;
     }
 }
-export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, };

package/dist/lib/config.d.ts

@@ -7,8 +7,11 @@ declare function get(key: string): any;
 declare function getAll(): any;
 declare function getDefaultStore(): string;
 declare function setDefaultStore(storeId: string): void;
-declare function getDefaultStorefront(appPath: string): string;
-declare function setDefaultStorefront(appPath: string, storefrontId: string): void;
+declare function getDefaultStorefront(appPath: string): {
+    id: string;
+    env?: string;
+};
+declare function setDefaultStorefront(appPath: string, storefrontId: string, env?: string): void;
 declare function getSessionId(storeId: string): any;
 /**
  * Set store data for later access.

package/dist/lib/config.js

@@ -105,13 +105,21 @@ function setDefaultStore(storeId) {
 function getDefaultStorefront(appPath) {
     const storeId = getDefaultStore();
     const defaultStorefronts = configStore.get('defaultStorefronts') || {};
-    return defaultStorefronts[storeId]?.[appPath];
+    const value = defaultStorefronts[storeId]?.[appPath];
+    // Backward compatibility with env, which was only used in test env before 3/2025
+    if (typeof value === 'string') {
+        return { id: value, env: 'test' };
+    }
+    return value;
 }
-function setDefaultStorefront(appPath, storefrontId) {
+function setDefaultStorefront(appPath, storefrontId, env) {
     const storeId = getDefaultStore();
     const defaultStorefronts = configStore.get('defaultStorefronts') || {};
     defaultStorefronts[storeId] = defaultStorefronts[storeId] || {};
-    defaultStorefronts[storeId][appPath] = storefrontId;
+    defaultStorefronts[storeId][appPath] = {
+        id: storefrontId,
+        env,
+    };
     return configStore.set('defaultStorefronts', defaultStorefronts);
 }
 function getSessionId(storeId) {

package/dist/lib/stores.js

@@ -140,11 +140,11 @@ async function selectEnvironmentId(message) {
     return select({
         choices: [
             {
-                name: '[live]',
+                name: 'Live',
                 value: '',
             },
             {
-                name: '[test]',
+                name: 'Test',
                 value: 'test',
             },
         ],

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

@@ -1,15 +1,23 @@
 /// <reference types="node" />
+import type { GlobbyFilterFunction } from 'globby';
+import * as fs from 'node:fs';
 import { App, AppConfig, ConfigType, FrontendProjectType } from './lib/apps/index.js';
 import { RemoteAppCommand } from './remote-app-command.js';
 type WatchFileEvent = 'change' | 'deleted' | 'new';
+interface WatchingChange {
+    action: 'push' | 'remove';
+    appConfig: AppConfig;
+    configFile: string;
+}
 export declare abstract class PushAppCommand extends RemoteAppCommand {
     frontendPath: string;
     logWatchChanges: boolean;
-    onWatchChange?: ((appConfig?: AppConfig, result?: any) => void) | undefined;
-    watchingChangeQueue: Array<any>;
-    watchingChangeQueueRunning: boolean;
-    watchingFiles: Array<string>;
-    watchListener: (eventType: string, filename: Buffer | null | string) => Promise<void>;
+    onWatchChange?: (appConfig?: AppConfig, result?: any) => void;
+    watchingChangeQueue: Map<string, WatchingChange>;
+    watchingFiles: Set<string>;
+    watchingIgnoreFilter: GlobbyFilterFunction | null;
+    watchingTimer: NodeJS.Timeout | null;
+    watchListener: (eventType: fs.WatchEventType, filename: null | string) => Promise<void>;
     buildFrontend(projectType: FrontendProjectType): Promise<void>;
     chooseAppToPull(query?: any): Promise<App>;
     createAppStorefront(hasOtherStorefronts?: boolean): Promise<any>;
@@ -43,11 +51,18 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     }, flags?: {
         'storefront-id'?: string;
         'storefront-select'?: boolean;
+        env?: string;
     }): Promise<any>;
     getStorefrontToPush(flags?: {
         'storefront-id'?: string;
         'storefront-select'?: boolean;
+        env?: string;
     }): Promise<any>;
+    setStorefrontEnv(flags: {
+        'storefront-id'?: string;
+        'storefront-select'?: boolean;
+        env?: string;
+    }, defaultStorefront?: any): Promise<void>;
     handleWatchFileChange(configFile: string, configType: ConfigType, event: WatchFileEvent): Promise<void>;
     logAppFrontendUrl(): void;
     logDashboardUrl(flags: {
@@ -60,12 +75,12 @@ export declare abstract class PushAppCommand extends RemoteAppCommand {
     resolveAppPath(appId?: string, targetPath?: string): string;
     runWatchChangeQueue(): Promise<void>;
     saveCurrentStorefront(): void;
-    setWatchingFiles(): void;
+    setWatchingFiles(): Promise<void>;
     updateFrontendDeployment(currentStore: string, projectType: FrontendProjectType, deploymentUrl: string, deploymentHash: string): Promise<void>;
     watchForChanges({ logChanges, onChange, syncAll, }?: {
-        logChanges?: boolean | undefined;
-        onChange?: (() => void) | undefined;
-        syncAll?: boolean | undefined;
+        logChanges?: boolean;
+        onChange?: () => void;
+        syncAll?: boolean;
     }): Promise<void>;
     wranglerDeployFrontend(projectType: FrontendProjectType): Promise<string>;
     private confirmRemoveInstalledApp;