@swell/cli 2.0.1-alpha.9 → 2.0.2

package/dist/lib/apps/index.js

@@ -1,16 +1,34 @@
+import { hash as blake3hash } from 'blake3-wasm';
 import { pluralize, titleize } from 'inflection';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { appConfigFileExists } from '../app-config.js';
+import { toAppId } from '../create/index.js';
 import { AppConfig } from './app-config.js';
+const PUSH_CONCURRENCY = 3;
+var SwellJsonFields;
+(function (SwellJsonFields) {
+    SwellJsonFields["DESCRIPTION"] = "description";
+    SwellJsonFields["EXTENSIONS"] = "extensions";
+    SwellJsonFields["ID"] = "id";
+    SwellJsonFields["KIND"] = "kind";
+    SwellJsonFields["NAME"] = "name";
+    SwellJsonFields["PERMISSIONS"] = "permissions";
+    SwellJsonFields["STOREFRONT"] = "storefront";
+    SwellJsonFields["THEME"] = "theme";
+    SwellJsonFields["TYPE"] = "type";
+    SwellJsonFields["VERSION"] = "version";
+})(SwellJsonFields || (SwellJsonFields = {}));
 var ConfigType;
 (function (ConfigType) {
     ConfigType["ASSET"] = "asset";
     ConfigType["CONTENT"] = "content";
+    ConfigType["FILE"] = "file";
+    ConfigType["FRONTEND"] = "frontend";
     ConfigType["FUNCTION"] = "function";
     ConfigType["MODEL"] = "model";
     ConfigType["NOTIFICATION"] = "notification";
     ConfigType["SETTING"] = "setting";
+    ConfigType["THEME"] = "theme";
     ConfigType["WEBHOOK"] = "webhook";
 })(ConfigType || (ConfigType = {}));
 // Models and content should come first in order
@@ -22,14 +40,44 @@ const ConfigTypeBatchOrder = [
     ConfigType.NOTIFICATION,
     ConfigType.SETTING,
     ConfigType.WEBHOOK,
+    ConfigType.THEME,
+    ConfigType.FRONTEND,
+    ConfigType.FILE,
 ];
-const ConfigPaths = {
-    ...Object.fromEntries(Object.keys(ConfigType).map((type) => [
+// Configs available for different app types
+const StandardConfigTypes = [
+    'MODEL',
+    'CONTENT',
+    'ASSET',
+    'FUNCTION',
+    'FRONTEND',
+    'NOTIFICATION',
+    'SETTING',
+    '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,
         // 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' ? 'content' : pluralize(type.toLowerCase()),
+        type === 'CONTENT' || type === 'FRONTEND' || type === 'THEME'
+            ? type.toLowerCase()
+            : pluralize(type.toLowerCase()),
     ])),
+});
+const ConfigPaths = {
+    ...getConfigPaths(StandardConfigTypes),
+};
+const StorefrontConfigPaths = {
+    ...getConfigPaths(StorefrontConfigTypes),
+};
+const ThemeConfigPaths = {
+    ...getConfigPaths(ThemeConfigTypes),
 };
 var ConfigInputFields;
 (function (ConfigInputFields) {
@@ -39,17 +87,39 @@ var ConfigInputFields;
     ConfigInputFields["VALUES"] = "values";
     ConfigInputFields["VERSION"] = "version";
 })(ConfigInputFields || (ConfigInputFields = {}));
-function hasAllowedFileExtension(file, configType) {
-    let allowedFileExtensions = new Set([
-        '.js',
-        '.json',
-        '.tpl',
-        '.ts',
-    ]);
-    if (configType === ConfigType.NOTIFICATION) {
-        allowedFileExtensions = new Set(['.json']);
+const FrontendProjectTypes = [
+    {
+        buildCommand: 'npx @cloudflare/next-on-pages',
+        configFileName: 'next.config',
+        deployPath: '.vercel/output/static',
+        devCommand: 'npx next dev --port ${PORT}',
+        installCommand: 'npx create-next-app@latest frontend --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind',
+        name: 'Next.js',
+        slug: 'nextjs',
+    },
+    {
+        buildCommand: 'npx astro build',
+        configFileName: 'astro.config',
+        deployPath: 'dist',
+        devCommand: 'npx astro dev --port ${PORT}',
+        installCommand: 'npm create astro@latest frontend -- --install --no-git --yes --skip-houston --typescript strict',
+        name: 'Astro',
+        slug: 'astro',
+    },
+];
+const frontendProjectConfigExtensions = ['.mjs', '.js'];
+function getAppSlugId(app) {
+    return toAppId(app.private_id) || app.public_id || app.id;
+}
+function getFrontendProjectType(appPath) {
+    for (const projectType of FrontendProjectTypes) {
+        for (const extension of frontendProjectConfigExtensions) {
+            const configFile = path.join(appPath, 'frontend', `${projectType.configFileName}${extension}`);
+            if (filePathExists(configFile)) {
+                return projectType;
+            }
+        }
     }
-    return allowedFileExtensions.has(path.parse(file).ext);
 }
 function getConfigTypeFromPath(path) {
     for (const type in ConfigPaths) {
@@ -63,7 +133,7 @@ function getConfigTypeFromPath(path) {
 function getConfigTypeKeyFromValue(value) {
     return Object.keys(ConfigType).find((key) => ConfigType[key] === value);
 }
-function fileExists(filePath) {
+function filePathExists(filePath) {
     try {
         // eslint-disable-next-line no-bitwise
         fs.accessSync(filePath, fs.constants.R_OK | fs.constants.W_OK);
@@ -76,13 +146,22 @@ function fileExists(filePath) {
         return false;
     }
 }
-function writeFile(file, data) {
+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;
+    }
+    catch {
+        contents = data;
+    }
     return new Promise((resolve, _reject) => {
         fs.mkdir(path.dirname(file), { recursive: true }, (error) => {
             if (error) {
                 throw error;
             }
-            fs.writeFile(file, data, (error) => {
+            fs.writeFile(file, contents || '', (error) => {
                 if (error) {
                     throw error;
                 }
@@ -91,49 +170,73 @@ function writeFile(file, data) {
         });
     });
 }
+function deleteFile(file) {
+    return new Promise((resolve, _reject) => {
+        fs.unlink(file, (error) => {
+            if (error) {
+                throw error;
+            }
+            resolve();
+        });
+    });
+}
 async function writeJsonFile(file, data = {}) {
     return writeFile(file, `${JSON.stringify(data, null, 2)}\n`);
 }
-function appLogoIcon(appPath) {
+// Hash method adapted from wrangler-sdk
+function hashFile(filePath, fileContents) {
+    const contents = fileContents ?? fs.readFileSync(filePath);
+    const base64Contents = contents.toString('base64');
+    const extension = path.extname(filePath).slice(1);
+    return hashString(base64Contents + extension);
+}
+function hashString(contents) {
+    return blake3hash(contents).toString('hex').slice(0, 32);
+}
+function appAssetImage(appPath, fileName) {
     const assetsDirPath = path.join(appPath, ConfigPaths['ASSET']);
-    if (!appConfigFileExists(assetsDirPath)) {
+    if (!filePathExists(assetsDirPath)) {
         return;
     }
     for (const configFile of fs.readdirSync(assetsDirPath)) {
-        if (isAppLogoIcon(configFile)) {
+        if (path.parse(configFile).name === fileName) {
             return path.join(assetsDirPath, configFile);
         }
     }
 }
-function isAppLogoIcon(file) {
-    return path.parse(file).name === 'icon';
-}
-function appConfigFromFile(configFile, configType) {
-    const { name } = path.parse(configFile);
-    const appConfig = AppConfig.create({
-        localPath: configFile,
+function appConfigFromFile(filePath, configType, appPath) {
+    const { name } = path.parse(filePath);
+    // Nested files are considered 'file' type
+    const type = (filePath.split(path.sep).length > 2 ? 'file' : configType || 'file');
+    const config = AppConfig.create({
         name,
-        type: configType,
-        values: {},
+        filePath,
+        appPath,
+        type,
+        file_path: filePath,
     });
-    return appConfig;
+    // Do not allow files larger than 10MB
+    if (config.mbSize && config.mbSize > 10) {
+        throw new Error(`App file size too large: ${config.filePath} (${config.mbSize} MB)`);
+    }
+    return config;
 }
-function findAppConfig(app, file, configType) {
-    const { name } = path.parse(file);
+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;
 }
 /**
  * Get files to push in batches prioritized by dependencies
  *
- * @param appConfigs - List of app configs
+ * @param configs - List of app configs
  * @returns {Array} Batches of files to push
  */
-function batchAppConfigsByType(appConfigs) {
-    const modelsWithExtends = appConfigs.filter((item) => item.type === 'model' && item.values.extends);
-    const modelsWithoutExtends = appConfigs.filter((item) => item.type === 'model' && !item.values.extends);
-    const contentTypesWithCollection = appConfigs.filter((item) => item.type === 'content' && item.values.collection);
-    const contentTypesWithoutCollection = appConfigs.filter((item) => item.type === 'content' && !item.values.collection);
+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);
+    const contentTypesWithoutCollection = configs.filter((config) => config.type === 'content' && !config.values.collection);
     const prioritized = [
         ...modelsWithExtends,
         ...modelsWithoutExtends,
@@ -142,26 +245,28 @@ function batchAppConfigsByType(appConfigs) {
     ];
     const sorted = [
         ...prioritized,
-        ...appConfigs.filter((item) => !prioritized.includes(item)),
+        ...configs.filter((config) => !prioritized.includes(config)),
     ];
     const batches = [];
     // eslint-disable-next-line guard-for-in
-    for (const key in ConfigTypeBatchOrder) {
-        const configType = ConfigTypeBatchOrder[key];
-        const configsByType = sorted.filter((item) => item.type === configType);
-        if (configsByType.length === 0) {
-            continue;
-        }
+    for (const type of Object.keys(ConfigTypeBatchOrder)) {
+        const configsByType = sorted.filter((config) => config.type === type);
+        const label = type === ConfigType.FILE ? 'App files' : titleize(type);
+        const concurrency = type === ConfigType.NOTIFICATION || type === ConfigType.ASSET
+            ? 1
+            : PUSH_CONCURRENCY;
         batches.push({
             configs: configsByType,
-            label: titleize(configType),
-            type: configType,
+            type,
+            label,
+            concurrency,
         });
     }
+    // Add base files if config types are not specified
     return batches;
 }
-export { ConfigInputFields, ConfigPaths, ConfigType, 
+export { PUSH_CONCURRENCY, ConfigInputFields, ConfigPaths, ConfigType, FrontendProjectTypes, StorefrontConfigPaths, StorefrontConfigTypes, SwellJsonFields, ThemeConfigPaths, ThemeConfigTypes, appAssetImage, appConfigFromFile, batchAppFilesByType, deleteFile, filePathExists, findAppConfig, 
 // functions
-appConfigFromFile, appLogoIcon, batchAppConfigsByType, fileExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, hasAllowedFileExtension, isAppLogoIcon, writeFile, writeJsonFile, };
+getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, hashFile, hashString, writeFile, writeJsonFile, };
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, } from './paths.js';
+export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, } from './paths.js';

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

@@ -1,18 +1,25 @@
-import { AppConfig, ConfigType } from './index.js';
+import { ConfigType } from './index.js';
+declare function globAllFilesByPath(appPath: string, dirPath?: string): string[];
 declare function allConfigDirsPaths(appPath: string): Generator<{
-    configDirPath: string;
+    configDir: string;
     configType: ConfigType;
 }>;
 declare function allConfigFilesPaths(appPath: string): Generator<{
-    configDirPath: string;
+    configDir: string;
     configFile: string;
     configType: ConfigType;
 }, void, unknown>;
 declare function allConfigFilesPathsByType(appPath: string, configTypeKey: string): Generator<{
-    configDirPath: string;
+    configDir: string;
     configFile: string;
     configType: ConfigType;
 }, void, unknown>;
-declare function configFilePath(appPath: string, config: AppConfig): string;
-declare function getAllConfigPaths(): Array<string>;
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, };
+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, };

package/dist/lib/apps/paths.js

@@ -1,49 +1,84 @@
+import { globbySync } from 'globby';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { appConfigFileExists } from '../app-config.js';
-import { ConfigPaths, ConfigType, hasAllowedFileExtension, } from './index.js';
-function* allConfigDirsPaths(appPath) {
+import { ConfigPaths, ConfigType, StorefrontConfigPaths, ThemeConfigPaths, filePathExists, } from './index.js';
+function globFiles(pattern, appPath, dirPath = '.', options = {}) {
+    const filePaths = globbySync(`${dirPath}${path.sep}${pattern}`, {
+        cwd: appPath,
+        dot: true,
+        gitignore: true,
+        ...options,
+        expandDirectories: true,
+        // Explicitly ignore node_modules and lock files just in case
+        ignore: [
+            '**/.swellrc',
+            '**/.git/**',
+            '**/node_modules/**',
+            '**/package-lock.json',
+            '**/yarn.lock',
+            ...(options?.ignore || []),
+        ],
+    });
+    return filePaths;
+}
+function globAllFilesByPath(appPath, dirPath) {
+    return globFiles('**', appPath, dirPath);
+}
+function getConfirDirsPaths(appPath) {
+    const configDirsPaths = [];
     for (const type in ConfigType) {
         if (Object.prototype.hasOwnProperty.call(ConfigType, type)) {
             const configType = ConfigType[type];
             const configPath = ConfigPaths[type];
-            const configDirPath = path.join(appPath, configPath);
-            if (appConfigFileExists(configDirPath)) {
-                yield { configDirPath, configType };
+            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)) {
+        yield { configDir, configType };
+    }
 }
 function* allConfigFilesPaths(appPath) {
-    for (const { configDirPath, configType } of allConfigDirsPaths(appPath)) {
-        yield* allConfigFilesInDir(configDirPath, configType);
+    for (const { configDir, configType } of allConfigDirsPaths(appPath)) {
+        yield* allConfigFilesInDir(appPath, configDir, configType);
     }
 }
 function* allConfigFilesPathsByType(appPath, configTypeKey) {
     const configPath = ConfigPaths[configTypeKey];
-    const configDirPath = path.join(appPath, configPath);
-    yield* allConfigFilesInDir(configDirPath, ConfigType[configTypeKey]);
-}
-function* allConfigFilesInDir(configDirPath, configType) {
-    for (const file of fs.readdirSync(configDirPath)) {
-        const configFile = path.join(configDirPath, file);
-        // ignore sub-directories, e.g. functions/lib
-        // ignore files that don't have the allowed extensions
-        if (fs.lstatSync(configFile).isDirectory() ||
-            !hasAllowedFileExtension(configFile, configType)) {
-            continue;
-        }
-        yield { configDirPath, configFile, configType };
+    yield* allConfigFilesInDir(appPath, configPath, ConfigType[configTypeKey]);
+}
+function* allConfigFilesInDir(appPath, dirPath, configType) {
+    const filePaths = globFiles('**', appPath, dirPath);
+    for (const configFile of filePaths) {
+        yield { configDir: dirPath, configFile, configType };
     }
 }
-function configFilePath(appPath, config) {
-    const configPath = ConfigPaths[config.type.toLocaleUpperCase()];
-    const fileExt = config.file?.ext || '.json';
-    return path.join(appPath, configPath, [config.name, fileExt].join(''));
+function* allBaseFilesInDir(appPath) {
+    // Only get base files excluding config directories
+    const configPaths = getConfirDirsPaths(appPath);
+    const baseFiles = globFiles('**', appPath, '.', {
+        ignore: configPaths.map((config) => `${config.configDir}/**`),
+    });
+    for (const path of baseFiles) {
+        yield path;
+    }
 }
-function getAllConfigPaths() {
+function getAllConfigPaths(appType) {
     const configPaths = [];
-    for (const type in ConfigPaths) {
+    const ConfigPathsByType = appType === 'storefront'
+        ? StorefrontConfigPaths
+        : appType === 'theme'
+            ? ThemeConfigPaths
+            : ConfigPaths;
+    for (const type in ConfigPathsByType) {
         if (Object.prototype.hasOwnProperty.call(ConfigPaths, type)) {
             const configPath = ConfigPaths[type];
             configPaths.push(configPath);
@@ -51,4 +86,14 @@ function getAllConfigPaths() {
     }
     return configPaths;
 }
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, };
+function isPathDirectory(path) {
+    try {
+        const stat = fs.statSync(path);
+        return stat.isDirectory();
+    }
+    catch {
+        // Handle error (e.g., file not found)
+        return false;
+    }
+}
+export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, };

package/dist/lib/bundle.js

@@ -24,15 +24,14 @@ export async function bundleFunction(filePath) {
             .join('\n');
         // Remove comments with to get a unique hash in the API
         // Because esbuild puts the file name as a comment
-        code = code.replace(/^[\n]?\/\/.*/gm, '');
+        code = code.replaceAll(/^\n?\/\/.*/gm, '');
         // eslint-disable-next-line no-new-func
         const evalFn = new Function(`${code}\nreturn { ...moduleExports }`);
         const { config, ...moduleExports } = evalFn();
-        code += getSwellFunctionWrapper();
+        code = await minifyCode(code + getSwellFunctionWrapper());
         return { code, config, dependencies, moduleExports };
     }
     catch (error) {
-        console.log(error);
         throw new Error(`Unable to compile function ${filePath}: ${error.message}`);
     }
 }
@@ -41,3 +40,16 @@ function getSwellFunctionWrapper() {
     const __dirname = path.dirname(__filename);
     return fs.readFileSync(path.join(__dirname, './swell-function-wrapper.js'), 'utf8');
 }
+async function minifyCode(code) {
+    try {
+        const result = await esbuild.transform(code, {
+            minifyIdentifiers: false,
+            minifySyntax: false,
+            minifyWhitespace: true,
+        });
+        return result.code;
+    }
+    catch (error) {
+        throw new Error('Compilation error:', error.message);
+    }
+}

package/dist/lib/config.d.ts

@@ -1,9 +1,14 @@
 declare const env: any;
+declare function setEnv(name: string, reviewBranch?: string): {
+    [key: string]: string;
+};
 declare function ensureLoggedIn(storeId: string): Promise<any>;
 declare function get(key: string): any;
 declare function getAll(): any;
-declare function getDefaultStore(): 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 getSessionId(storeId: string): any;
 /**
  * Set store data for later access.
@@ -28,10 +33,12 @@ declare const config: {
     get: typeof get;
     getAll: typeof getAll;
     getDefaultStore: typeof getDefaultStore;
+    getDefaultStorefront: typeof getDefaultStorefront;
     getSessionId: typeof getSessionId;
     getUser: typeof getUser;
     setDefaultStore: typeof setDefaultStore;
+    setDefaultStorefront: typeof setDefaultStorefront;
     setStore: typeof setStore;
     setUser: typeof setUser;
 };
-export { config as default, env };
+export { config as default, env, setEnv };

package/dist/lib/config.js

@@ -2,6 +2,10 @@ import Conf from 'conf';
 import Configstore from 'configstore';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import localEnv from '../env/local.js';
+import prodEnv from '../env/production.js';
+import reviewEnv from '../env/review.js';
+import stagingEnv from '../env/staging.js';
 import style from './style.js';
 const configPath = process.env.NODE_ENV === 'test'
     ? path.resolve(process.cwd(), 'test', '.swell', 'config.json')
@@ -28,6 +32,36 @@ const env = new Conf({
     projectName: 'swell',
     projectSuffix: '',
 });
+function setEnv(name, reviewBranch) {
+    let newEnv = {};
+    if (name.startsWith('prod')) {
+        newEnv = { ...prodEnv };
+    }
+    else if (name.startsWith('stag')) {
+        newEnv = { ...stagingEnv };
+    }
+    else if (name.startsWith('local')) {
+        newEnv = { ...localEnv };
+    }
+    else if (name.startsWith('rev') || name.startsWith('ra')) {
+        if (reviewBranch) {
+            const reviewAppEnv = { ...reviewEnv };
+            const reviewDomain = reviewBranch.replaceAll('/', '-');
+            for (const key of Object.keys(reviewAppEnv)) {
+                reviewAppEnv[key] = reviewAppEnv[key].replace('${REVIEW_DOMAIN}', reviewDomain);
+            }
+            newEnv = reviewAppEnv;
+        }
+        else {
+            throw new Error('Review environment requires a branch name.');
+        }
+    }
+    else {
+        throw new Error(`Invalid environment '${name}'. Should be one of 'prod', 'staging', 'review', or 'local'.`);
+    }
+    env.set(newEnv);
+    return newEnv;
+}
 /**
  * Get specified attributes for given object.
  *
@@ -68,6 +102,18 @@ function getDefaultStore() {
 function setDefaultStore(storeId) {
     return configStore.set('defaultStore', storeId);
 }
+function getDefaultStorefront(appPath) {
+    const storeId = getDefaultStore();
+    const defaultStorefronts = configStore.get('defaultStorefronts') || {};
+    return defaultStorefronts[storeId]?.[appPath];
+}
+function setDefaultStorefront(appPath, storefrontId) {
+    const storeId = getDefaultStore();
+    const defaultStorefronts = configStore.get('defaultStorefronts') || {};
+    defaultStorefronts[storeId] = defaultStorefronts[storeId] || {};
+    defaultStorefronts[storeId][appPath] = storefrontId;
+    return configStore.set('defaultStorefronts', defaultStorefronts);
+}
 function getSessionId(storeId) {
     if (!configStore.has('stores'))
         return;
@@ -122,10 +168,12 @@ const config = {
     get,
     getAll,
     getDefaultStore,
+    getDefaultStorefront,
     getSessionId,
     getUser,
     setDefaultStore,
+    setDefaultStorefront,
     setStore,
     setUser,
 };
-export { config as default, env };
+export { config as default, env, setEnv };

package/dist/lib/constants.d.ts

@@ -1,5 +1,10 @@
 export declare const API_BASE_URL: any;
 export declare const ADMIN_API_BASE_URL: any;
 export declare const LOGIN_HOST: any;
+export declare const APP_PAGES_HOST: any;
+export declare const STOREFRONT_FRONTEND_HOST: any;
 export declare function getAdminApiBaseUrl(storeId: string): any;
 export declare function getLoginHost(storeId?: string): any;
+export declare function getAppFrontendHost(storeId: string, installedAppId: string): any;
+export declare function getStorefrontFrontendHost(storefrontSlug: string, branchId?: string): any;
+export declare function getLocalFrontendHost(storeId: string, sessionId: string): any;

package/dist/lib/constants.js

@@ -1,17 +1,35 @@
+import defaultEnv from '../env/production.js';
 import { env } from './config.js';
 // note: env values stored in ~/.swell/env.json
 // url for backend api calls
-export const API_BASE_URL = env.get('API_BASE_URL') || 'https://api.swell.store';
+export const API_BASE_URL = env.get('API_BASE_URL') || defaultEnv.API_BASE_URL;
 // url for admin api calls
-export const ADMIN_API_BASE_URL = 
-// eslint-disable-next-line no-template-curly-in-string
-env.get('ADMIN_API_BASE_URL') || 'https://${STORE_ID}.swell.store/admin/api';
+export const ADMIN_API_BASE_URL = env.get('ADMIN_API_BASE_URL') || defaultEnv.ADMIN_API_BASE_URL;
 // url host for admin login
-export const LOGIN_HOST = env.get('LOGIN_HOST') || 'https://${STORE_ID}.swell.store';
+export const LOGIN_HOST = env.get('LOGIN_HOST') || defaultEnv.LOGIN_HOST;
+// url host for app frontend
+export const APP_PAGES_HOST = env.get('APP_PAGES_HOST') || defaultEnv.APP_PAGES_HOST;
+// url host for storefront app frontend
+export const STOREFRONT_FRONTEND_HOST = env.get('STOREFRONT_FRONTEND_HOST') ||
+    env.get('STOREFRONT_PAGES_HOST') || // Deprecated
+    defaultEnv.STOREFRONT_FRONTEND_HOST;
 // helpers to get constants with replacements
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);
 }
 export function getLoginHost(storeId) {
-    return LOGIN_HOST.replace('${STORE_ID}', storeId || 'app');
+    return LOGIN_HOST.replace('${STORE_ID}', storeId || 'login');
+}
+export function getAppFrontendHost(storeId, installedAppId) {
+    return APP_PAGES_HOST.replace('${STORE_ID}', storeId)
+        .replace('${APP_ID}', installedAppId)
+        .replace('${ENV}', 'app');
+}
+export function getStorefrontFrontendHost(storefrontSlug, branchId) {
+    return STOREFRONT_FRONTEND_HOST.replace('${STOREFRONT_SLUG}', storefrontSlug).replace('${BRANCH_PREFIX}', branchId ? `${branchId}.` : '');
+}
+export function getLocalFrontendHost(storeId, sessionId) {
+    return APP_PAGES_HOST.replace('${STORE_ID}', storeId)
+        .replace('${APP_ID}', sessionId)
+        .replace('${ENV}', 'local');
 }