@swell/cli 2.0.1-alpha.13 → 2.0.1-alpha.17

package/dist/lib/apps/index.js

@@ -1,8 +1,22 @@
-import { pluralize, titleize } from 'inflection';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { appConfigFileExists } from '../app-config.js';
+import { pluralize, titleize } from 'inflection';
+import { hash as blake3hash } from 'blake3-wasm';
 import { AppConfig } from './app-config.js';
+import { toAppId } from '../create/index.js';
+var SwellJsonFields;
+(function (SwellJsonFields) {
+    SwellJsonFields["ID"] = "id";
+    SwellJsonFields["NAME"] = "name";
+    SwellJsonFields["TYPE"] = "type";
+    SwellJsonFields["KIND"] = "kind";
+    SwellJsonFields["VERSION"] = "version";
+    SwellJsonFields["DESCRIPTION"] = "description";
+    SwellJsonFields["STOREFRONT"] = "storefront";
+    SwellJsonFields["THEME"] = "theme";
+    SwellJsonFields["PERMISSIONS"] = "permissions";
+    SwellJsonFields["EXTENSIONS"] = "extensions";
+})(SwellJsonFields || (SwellJsonFields = {}));
 var ConfigType;
 (function (ConfigType) {
     ConfigType["ASSET"] = "asset";
@@ -12,6 +26,9 @@ var ConfigType;
     ConfigType["NOTIFICATION"] = "notification";
     ConfigType["SETTING"] = "setting";
     ConfigType["WEBHOOK"] = "webhook";
+    ConfigType["FRONTEND"] = "frontend";
+    ConfigType["THEME"] = "theme";
+    ConfigType["FILE"] = "file";
 })(ConfigType || (ConfigType = {}));
 // Models and content should come first in order
 const ConfigTypeBatchOrder = [
@@ -22,14 +39,46 @@ const ConfigTypeBatchOrder = [
     ConfigType.NOTIFICATION,
     ConfigType.SETTING,
     ConfigType.WEBHOOK,
+    ConfigType.THEME,
+    ConfigType.FRONTEND,
+    ConfigType.FILE,
 ];
+// 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) => {
+    return {
+        ...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' || type === 'FRONTEND' || type === 'THEME'
+                ? type.toLowerCase()
+                : pluralize(type.toLowerCase()),
+        ])),
+    };
+};
 const ConfigPaths = {
-    ...Object.fromEntries(Object.keys(ConfigType).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()),
-    ])),
+    ...getConfigPaths(StandardConfigTypes),
+};
+const StorefrontConfigPaths = {
+    ...getConfigPaths(StorefrontConfigTypes),
+};
+const ThemeConfigPaths = {
+    ...getConfigPaths(ThemeConfigTypes),
 };
 var ConfigInputFields;
 (function (ConfigInputFields) {
@@ -39,17 +88,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 = [
+    {
+        name: 'Next.js',
+        slug: 'nextjs',
+        configFileName: 'next.config',
+        deployPath: '.vercel/output/static',
+        installCommand: 'npx create-next-app@latest frontend --typescript --use-npm --src-dir --app --eslint --import-alias "@/*" --tailwind',
+        buildCommand: 'npx @cloudflare/next-on-pages',
+        devCommand: 'npx next dev --port ${PORT}',
+    },
+    {
+        name: 'Astro',
+        slug: 'astro',
+        configFileName: 'astro.config',
+        deployPath: 'dist',
+        installCommand: 'npm create astro@latest frontend -- --install --no-git --yes --skip-houston --typescript strict',
+        buildCommand: 'npx astro build',
+        devCommand: 'npx astro dev --port ${PORT}',
+    },
+];
+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 +134,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 +147,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,35 +171,57 @@ 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).substring(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);
+    const config = AppConfig.create({
         name,
-        type: configType,
-        values: {},
+        filePath,
+        appPath,
+        type: configType || 'file',
+        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;
 }
@@ -129,11 +231,11 @@ function findAppConfig(app, file, configType) {
  * @param appConfigs - 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 +244,24 @@ 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;
-        }
+        const configsByType = sorted.filter((config) => config.type === configType);
         batches.push({
             configs: configsByType,
-            label: titleize(configType),
+            label: configType === ConfigType.FILE ? 'App files' : titleize(configType),
             type: configType,
         });
     }
+    // Add base files if config types are not specified
     return batches;
 }
-export { ConfigInputFields, ConfigPaths, ConfigType, 
+export { SwellJsonFields, ConfigInputFields, ConfigPaths, StorefrontConfigPaths, StorefrontConfigTypes, ThemeConfigTypes, ThemeConfigPaths, ConfigType, FrontendProjectTypes, 
 // functions
-appConfigFromFile, appLogoIcon, batchAppConfigsByType, fileExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, hasAllowedFileExtension, isAppLogoIcon, writeFile, writeJsonFile, };
+getAppSlugId, appConfigFromFile, appAssetImage, batchAppFilesByType, filePathExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, writeFile, writeJsonFile, deleteFile, hashFile, hashString, getFrontendProjectType, };
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, } from './paths.js';
+export { globAllFilesByPath, allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, allConfigFilesInDir, allBaseFilesInDir, isPathDirectory, getAllConfigPaths, } 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 { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, allConfigFilesInDir, allBaseFilesInDir, globAllFilesByPath, isPathDirectory, getAllConfigPaths, };

package/dist/lib/apps/paths.js

@@ -1,49 +1,84 @@
 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 { globbySync } from 'globby';
+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,
+        // Explicitly ignore node_modules and lock files just in case
+        ignore: [
+            '**/.swellrc',
+            '**/.git/**',
+            '**/node_modules/**',
+            '**/package-lock.json',
+            '**/yarn.lock',
+            ...(options?.ignore || []),
+        ],
+        expandDirectories: true,
+    });
+    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 (error) {
+        // Handle error (e.g., file not found)
+        return false;
+    }
+}
+export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, allConfigFilesInDir, allBaseFilesInDir, globAllFilesByPath, isPathDirectory, getAllConfigPaths, };

package/dist/lib/bundle.js

@@ -24,7 +24,7 @@ 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();
@@ -32,7 +32,6 @@ export async function bundleFunction(filePath) {
         return { code, config, dependencies, moduleExports };
     }
     catch (error) {
-        console.log(error);
         throw new Error(`Unable to compile function ${filePath}: ${error.message}`);
     }
 }
@@ -44,13 +43,13 @@ function getSwellFunctionWrapper() {
 async function minifyCode(code) {
     try {
         const result = await esbuild.transform(code, {
-            minifyWhitespace: true,
             minifyIdentifiers: false,
             minifySyntax: false,
+            minifyWhitespace: true,
         });
         return result.code;
     }
-    catch (err) {
-        throw new Error('Compilation error:', err.message);
+    catch (error) {
+        throw new Error('Compilation error:', error.message);
     }
 }

package/dist/lib/config.d.ts

@@ -2,8 +2,10 @@ declare const env: any;
 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,9 +30,11 @@ 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;
 };

package/dist/lib/config.js

@@ -68,6 +68,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,9 +134,11 @@ const config = {
     get,
     getAll,
     getDefaultStore,
+    getDefaultStorefront,
     getSessionId,
     getUser,
     setDefaultStore,
+    setDefaultStorefront,
     setStore,
     setUser,
 };

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,13 +1,19 @@
+/* eslint-disable no-template-curly-in-string */
 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';
 // 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') || 'https://${STORE_ID}.swell.store/admin/api';
 // url host for admin login
 export const LOGIN_HOST = env.get('LOGIN_HOST') || 'https://${STORE_ID}.swell.store';
+// url host for app frontend
+export const APP_PAGES_HOST = env.get('APP_PAGES_HOST') ||
+    'https://${STORE_ID}--${APP_ID}--${ENV}.swell.store';
+// url host for storefront app frontend
+export const STOREFRONT_FRONTEND_HOST = env.get('STOREFRONT_FRONTEND_HOST') ||
+    env.get('STOREFRONT_PAGES_HOST') ||
+    'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.store';
 // helpers to get constants with replacements
 export function getAdminApiBaseUrl(storeId) {
     return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);
@@ -15,3 +21,16 @@ export function getAdminApiBaseUrl(storeId) {
 export function getLoginHost(storeId) {
     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');
+}

package/dist/lib/create/content.d.ts

@@ -1,8 +1,8 @@
 interface CreateContentFileBody {
     collection: string;
-    label?: string;
     description?: string;
     fields?: ContentFieldProps[];
+    label?: string;
     views?: ContentViewProps[];
 }
 interface ContentViewProps {
@@ -12,7 +12,7 @@ interface ContentViewProps {
     tabs: [];
 }
 type ContentView = 'edit' | 'list' | 'new';
-type ContentType = 'asset' | 'basic_html' | 'blocks' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'currency' | 'customer_lookup' | 'date' | 'datetime' | 'document' | 'dropdown' | 'email' | 'field_group' | 'generic_lookup' | 'icon' | 'image' | 'long_text' | 'lookup' | 'markdown' | 'number' | 'percent' | 'phone' | 'product_lookup' | 'radio' | 'rich_html' | 'select' | 'short_text' | 'slider' | 'slug' | 'tags' | 'text' | 'textarea' | 'time' | 'toggle' | 'url' | 'variant_lookup' | 'video';
+type ContentType = 'asset' | 'basic_html' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'color_scheme' | 'color_scheme_group' | 'currency' | 'customer_lookup' | 'date' | 'datetime' | 'document' | 'dropdown' | 'email' | 'field_group' | 'font_family' | 'generic_lookup' | 'html' | 'icon' | 'image' | 'long_text' | 'lookup' | 'markdown' | 'number' | 'percent' | 'phone' | 'product_lookup' | 'radio' | 'rich_html' | 'rich_text' | 'select' | 'short_text' | 'slider' | 'slug' | 'tags' | 'text' | 'textarea' | 'time' | 'toggle' | 'url' | 'variant_lookup' | 'video';
 interface ContentFieldProps {
     id: string;
     label: string;

package/dist/lib/create/content.js

@@ -8,8 +8,8 @@ const parseViews = (views) => {
         viewResponse.push({
             id: viewId,
             ...(viewId === 'list' ? { nav: {} } : {}),
-            tabs: [],
             fields: [],
+            tabs: [],
         });
     }
     return viewResponse;

package/dist/lib/create/function.d.ts

@@ -7,11 +7,11 @@ interface CreateFunctionArgs {
 interface WriteFunctionFileParams {
     description: string;
     events: string;
-    route: string;
     functionName: string;
     language: FunctionLanguage;
+    route: string;
     schedule: string;
     trigger: FunctionType;
 }
-declare const getFunctionTemplate: ({ description, events, route, schedule, language, trigger, }: WriteFunctionFileParams) => string;
+declare const getFunctionTemplate: ({ description, events, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
 export { CreateFunctionArgs, FunctionLanguage, FunctionType, WriteFunctionFileParams, getFunctionTemplate, };

package/dist/lib/create/function.js

@@ -1,9 +1,9 @@
-const getFunctionTemplate = ({ description, events, route, schedule, language, trigger, }) => {
+const getFunctionTemplate = ({ description, events, language, route, schedule, trigger, }) => {
     let typeAppend = ``;
     if (trigger === 'model') {
         const eventsList = events
             .split(/\s*,\s*/g)
-            .filter((e) => e)
+            .filter(Boolean)
             .map((eventName) => `'${eventName}'`)
             .join(', ');
         typeAppend = `,