@swell/cli 2.0.1-alpha.16 → 2.0.1-alpha.18

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

@@ -1,43 +1,110 @@
+/// <reference types="node" />
 import { AppConfig } from './app-config.js';
 /**
  * An app as defined by the Swell API. This is different than an app
  * configuration that developers define.
  */
 type App = {
+    categories?: Array<string>;
     client?: any;
     client_id?: string;
+    compatibilities?: {
+        [key: string]: string;
+    };
     configs?: AppConfig[];
     date_created?: string;
     date_updated?: string;
     description?: string;
+    extensions?: Array<any>;
+    features?: Array<string>;
+    frontend?: {
+        deployment?: null | object;
+        deployment_hash?: string;
+        deployment_id?: string;
+        framework?: string;
+        service?: string;
+        url?: string;
+    };
+    highlights?: Array<{
+        id: string;
+        image_src?: unknown;
+        title: string;
+    }>;
     id?: string;
-    installed?: boolean;
+    installed?: {
+        date_created: string;
+        id: string;
+    };
+    kind?: string;
+    logo_icon?: unknown;
     name?: string;
+    preview_image?: unknown;
+    preview_mobile_image?: unknown;
     private_id?: string;
     public_id?: string;
     published?: boolean;
+    purchase_options?: Array<string>;
+    storefront?: {
+        [key: string]: any;
+    };
+    styles?: Array<{
+        color: string;
+        color_alt?: string;
+        id: string;
+        label: string;
+        preview_image?: unknown;
+        preview_mobile_image?: unknown;
+    }>;
+    theme?: {
+        [key: string]: any;
+    };
+    type?: string;
+    use_cases?: Array<string>;
     version?: string;
 };
+declare enum SwellJsonFields {
+    DESCRIPTION = "description",
+    EXTENSIONS = "extensions",
+    ID = "id",
+    KIND = "kind",
+    NAME = "name",
+    PERMISSIONS = "permissions",
+    STOREFRONT = "storefront",
+    THEME = "theme",
+    TYPE = "type",
+    VERSION = "version"
+}
 type AppVersion = {
     date_created: string;
+    description?: string;
     id: string;
     name: string;
-    notes: string;
+    published?: boolean;
+    release_notes?: string;
+    released?: boolean;
+    supported?: boolean;
     version: string;
 };
 declare enum ConfigType {
     ASSET = "asset",
     CONTENT = "content",
+    FILE = "file",
+    FRONTEND = "frontend",
     FUNCTION = "function",
     MODEL = "model",
     NOTIFICATION = "notification",
     SETTING = "setting",
+    THEME = "theme",
     WEBHOOK = "webhook"
 }
+declare const StorefrontConfigTypes: string[];
+declare const ThemeConfigTypes: string[];
 type ConfigPathsType = {
     [key in ConfigType]: string;
 };
 declare const ConfigPaths: ConfigPathsType;
+declare const StorefrontConfigPaths: ConfigPathsType;
+declare const ThemeConfigPaths: ConfigPathsType;
 declare enum ConfigInputFields {
     FILE = "file",
     NAME = "name",
@@ -45,23 +112,36 @@ declare enum ConfigInputFields {
     VALUES = "values",
     VERSION = "version"
 }
-declare function hasAllowedFileExtension(file: string, configType?: ConfigType): boolean;
+type FrontendProjectType = {
+    buildCommand: string;
+    configFileName: string;
+    deployPath: string;
+    devCommand: string;
+    installCommand: string;
+    name: string;
+    slug: string;
+};
+declare const FrontendProjectTypes: Array<FrontendProjectType>;
+declare function getAppSlugId(app: App): string | undefined;
+declare function getFrontendProjectType(appPath: string): FrontendProjectType | undefined;
 declare function getConfigTypeFromPath(path: string): ConfigType | undefined;
 declare function getConfigTypeKeyFromValue(value: string): string | undefined;
-declare function fileExists(filePath: string): boolean;
+declare function filePathExists(filePath: string): boolean;
 declare function writeFile(file: string, data: string): Promise<void>;
+declare function deleteFile(file: string): Promise<void>;
 declare function writeJsonFile(file: string, data?: any): Promise<void>;
-declare function appLogoIcon(appPath: string): string | undefined;
-declare function isAppLogoIcon(file: string): boolean;
-declare function appConfigFromFile(configFile: string, configType: ConfigType): AppConfig;
-declare function findAppConfig(app: App, file: string, configType: ConfigType): AppConfig | undefined;
+declare function hashFile(filePath: string, fileContents?: Buffer): string;
+declare function hashString(contents: string): string;
+declare function appAssetImage(appPath: string, fileName: string): string | undefined;
+declare function appConfigFromFile(filePath: string, configType: ConfigType, appPath: string): AppConfig;
+declare function findAppConfig(app: App, filePath: string, configType: ConfigType): AppConfig | undefined;
 /**
  * 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
  */
-declare function batchAppConfigsByType(appConfigs: AppConfig[]): Array<any>;
-export { App, AppVersion, ConfigInputFields, ConfigPaths, ConfigPathsType, ConfigType, appConfigFromFile, appLogoIcon, batchAppConfigsByType, fileExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, hasAllowedFileExtension, isAppLogoIcon, writeFile, writeJsonFile, };
+declare function batchAppFilesByType(configs: AppConfig[]): Array<any>;
+export { App, AppVersion, ConfigInputFields, ConfigPaths, ConfigPathsType, ConfigType, FrontendProjectType, FrontendProjectTypes, StorefrontConfigPaths, StorefrontConfigTypes, SwellJsonFields, ThemeConfigPaths, ThemeConfigTypes, appAssetImage, appConfigFromFile, batchAppFilesByType, deleteFile, filePathExists, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, hashFile, hashString, writeFile, writeJsonFile, };
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, configFilePath, getAllConfigPaths, } from './paths.js';
+export { allBaseFilesInDir, allConfigDirsPaths, allConfigFilesInDir, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, globAllFilesByPath, isPathDirectory, } from './paths.js';

package/dist/lib/apps/index.js

@@ -1,16 +1,33 @@
+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';
+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 +39,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 +86,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 +132,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 +145,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 +169,71 @@ 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);
+    const config = AppConfig.create({
+        appPath,
+        file_path: filePath,
+        filePath,
         name,
-        type: configType,
-        values: {},
+        type: configType || 'file',
     });
-    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 +242,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 { 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, configFilePath, getAllConfigPaths, } 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, configFilePath, getAllConfigPaths, };
+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, configFilePath, getAllConfigPaths, };
+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/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 };