@swell/cli 2.0.20 → 2.1.0

package/dist/commands/app/frontend/dev.js

@@ -1,26 +1,21 @@
 import { Flags } from '@oclif/core';
-import getPort, { portNumbers } from 'get-port';
-import ngrok from 'ngrok';
-import ora from 'ora';
 import { default as localConfig } from '../../../lib/config.js';
 import style from '../../../lib/style.js';
 import { PushAppCommand } from '../../../push-app-command.js';
-const FALLBACK_PORT = 3000;
+import AppDev from '../dev.js';
 export default class AppFrontendDev extends PushAppCommand {
     static examples = [
         'swell app frontend dev',
         'swell app frontend dev --no-push',
-        'swell app frontend dev --port 3000',
+        'swell app frontend dev --proxy-port 3000',
         'swell app frontend dev --storefront-select',
         'swell app frontend dev --storefront-id <id>',
     ];
     static flags = {
-        'no-push': Flags.boolean({
-            description: 'skip pushing app files initially',
-        }),
-        port: Flags.integer({
-            char: 'p',
-            description: 'override the default port to run the app locally',
+        ...AppDev.flags,
+        'proxy-port': Flags.integer({
+            description: 'specify the port for an existing frontend proxy',
+            default: 3001,
         }),
         'storefront-id': Flags.string({
             description: 'identify a storefront to preview with and push theme files to',
@@ -29,25 +24,23 @@ export default class AppFrontendDev extends PushAppCommand {
             default: false,
             description: 'prompt to select a storefront to preview with',
         }),
+        'app-dev': Flags.boolean({
+            description: 'indicates frontend app is running in app dev mode',
+            default: true,
+        }),
     };
     static orientation = {
         env: 'test',
     };
     static summary = `Run a frontend app in dev mode from your local machine.`;
-    logAppLocalUrl(storeId, sessionId) {
-        const frontendAppRoute = this.app.type === 'storefront' && this.app.storefront?.external
-            ? `/${this.app.private_id}`
-            : '';
-        this.log(`View it at ${style.link(`${this.localFrontendUrl(storeId, sessionId)}${frontendAppRoute}`)}\n`);
-    }
     async run() {
         const { flags } = await this.parse(AppFrontendDev);
-        const { port } = flags;
+        const { port, 'proxy-port': proxyPort, 'app-dev': isAppDev } = flags;
         const noPush = flags['no-push'];
         if (!(await this.ensureAppExists(undefined, false))) {
             return;
         }
-        if (!noPush) {
+        if (!noPush && !isAppDev) {
             await this.pushAppConfigs();
         }
         if (this.app.type === 'storefront') {
@@ -55,54 +48,124 @@ export default class AppFrontendDev extends PushAppCommand {
             this.logStorefrontConnected();
         }
         this.saveCurrentStorefront();
-        const projectType = this.getFrontendProjectType();
-        await this.startDevServer(projectType, port);
+        if (!isAppDev) {
+            this.log(`Starting app dev server...\n`);
+        }
+        const serverPort = await this.startProxyServer(proxyPort || port);
+        await this.execFrontendProject(serverPort, isAppDev);
     }
-    async startDevServer(projectType, port) {
+    async execFrontendProject(serverPort, isAppDev) {
+        const projectType = this.getFrontendProjectType(!isAppDev);
+        if (!projectType) {
+            return;
+        }
         const currentStore = localConfig.getDefaultStore();
-        const spinner = ora();
-        // Find an open port starting at 3000
-        const freePort = port ||
-            (await getPort({ port: portNumbers(3000, 3100) })) ||
-            FALLBACK_PORT;
-        this.log(`Starting ${projectType.name} dev server...\n`);
-        // Start ngrok proxy
-        const proxyUrl = await ngrok.connect({
-            addr: freePort,
-            region: 'us', // TODO: make it configurable
-        });
-        await this.updateLocalProxy(proxyUrl, spinner, this.storefront?.id);
-        return this.exec(projectType.devCommand.replace('${PORT}', String(freePort)), (string) => {
-            // Hide useless astro warning about image optimization
-            if (string.includes('The current configuration does not support image optimization')) {
-                return false;
+        let serverReadyDetected = false;
+        await this.execFrontend(projectType.devCommand.replace('${PORT}', String(serverPort)), (string) => {
+            // Framework-specific output handling and ready detection
+            if (projectType.slug === 'nextjs') {
+                // 1. NOISE FILTER: Hide unwanted output
+                if (string.includes('Using vars defined in .dev.vars')) {
+                    return false;
+                }
+                // 2. URL FILTER: Hide localhost/network URLs (confusing - users should use Swell tunnel)
+                if (/- Local:\s+http:\/\//i.test(string) ||
+                    /- Network:\s+http:\/\//i.test(string) ||
+                    /Ready on http:\/\/localhost/i.test(string)) {
+                    return false;
+                }
+                // 3. READY DETECTION: Detect server ready, show our message
+                if (!serverReadyDetected) {
+                    if (/✓ Ready in \d+/i.test(string) ||
+                        /✓ Starting/i.test(string)) {
+                        serverReadyDetected = true;
+                        this.log(`Started ${projectType.name} dev server on port ${serverPort}.\n`);
+                        const sessionId = localConfig.getSessionId(currentStore);
+                        setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
+                        if (!isAppDev) {
+                            this.watchForChanges();
+                        }
+                    }
+                }
             }
-            // Hide useless astro warning about .dev.vars
-            if (string.includes('There is no `.dev.vars` file')) {
-                return false;
+            else if (projectType.slug === 'astro') {
+                // 2. URL FILTER: Hide localhost/network URLs (confusing - users should use Swell tunnel)
+                if (string.includes('┃ Local') ||
+                    string.includes('┃ Network')) {
+                    return false;
+                }
+                // 3. READY DETECTION: Detect server ready, show our message
+                if (!serverReadyDetected && /watching for file changes/i.test(string)) {
+                    serverReadyDetected = true;
+                    this.log(`Started ${projectType.name} dev server on port ${serverPort}.\n`);
+                    const sessionId = localConfig.getSessionId(currentStore);
+                    setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
+                    if (!isAppDev) {
+                        this.watchForChanges();
+                    }
+                }
             }
-            // Hide astro localhost URL/network as it can confuse the user
-            if (string.includes('┃ Local') || string.includes('┃ Network')) {
-                return false;
+            else if (projectType.slug === 'angular') {
+                // 1. NOISE FILTER: Hide unwanted output
+                if (string.includes('press h + enter to show help')) {
+                    return false;
+                }
+                // 2. URL FILTER: Hide localhost/network URLs (confusing - users should use Swell tunnel)
+                if (/➜\s+Local:\s+http:\/\//i.test(string)) {
+                    return false;
+                }
+                // 3. READY DETECTION: Detect server ready, show our message
+                if (!serverReadyDetected) {
+                    if (/Application bundle generation complete/i.test(string) ||
+                        /Watch mode enabled/i.test(string)) {
+                        serverReadyDetected = true;
+                        this.log(`Started ${projectType.name} dev server on port ${serverPort}.\n`);
+                        const sessionId = localConfig.getSessionId(currentStore);
+                        setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
+                        if (!isAppDev) {
+                            this.watchForChanges();
+                        }
+                    }
+                }
             }
-            // Started, show app url (TODO for nextjs)
-            if (string.includes('watching for file changes')) {
-                spinner.succeed(`Started ${projectType.name} dev server on port ${freePort}.\n`);
-                const sessionId = localConfig.getSessionId(currentStore);
-                setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
-                this.watchForChanges();
+            else if (projectType.slug === 'hono') {
+                // 2. URL FILTER: Hide localhost URLs (confusing - users should use Swell tunnel)
+                // Note: For Hono, the ready signal IS the URL line, so we handle both in section 3
+                // 3. READY DETECTION: Detect server ready, show our message, hide the URL
+                if (!serverReadyDetected && /Ready on http:\/\/localhost:\d+/i.test(string)) {
+                    serverReadyDetected = true;
+                    this.log(`Started ${projectType.name} dev server on port ${serverPort}.\n`);
+                    const sessionId = localConfig.getSessionId(currentStore);
+                    setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
+                    if (!isAppDev) {
+                        this.watchForChanges();
+                    }
+                    return false; // Hide the "Ready on localhost" line
+                }
+            }
+            else if (projectType.slug === 'nuxt') {
+                // 2. URL FILTER: Hide localhost/network URLs (confusing - users should use Swell tunnel)
+                if (/➜ Local:\s+http:\/\//i.test(string) ||
+                    /➜ Network:/i.test(string)) {
+                    return false;
+                }
+                // 3. READY DETECTION: Detect server ready, show our message
+                if (!serverReadyDetected && /Nuxt \d+\.\d+\.\d+/i.test(string)) {
+                    serverReadyDetected = true;
+                    this.log(`Started ${projectType.name} dev server on port ${serverPort}.\n`);
+                    const sessionId = localConfig.getSessionId(currentStore);
+                    setTimeout(() => this.logAppLocalUrl(currentStore, sessionId), 100);
+                    if (!isAppDev) {
+                        this.watchForChanges();
+                    }
+                }
             }
         });
     }
-    async updateLocalProxy(proxyUrl, spinner, storefrontId) {
-        const storefront = this.app.type === 'storefront' &&
-            (await this.getAppStorefront({ storefront_id: storefrontId }));
-        await this.handleRequestErrors(async () => this.api.put({ adminPath: `/client/apps/${this.app.id}/local-proxy` }, {
-            body: {
-                proxy_url: proxyUrl,
-                storefront_id: storefront?.id || null,
-                storefront_slug: storefront?.slug || null,
-            },
-        }), () => spinner.fail('Error starting local proxy'));
+    logAppLocalUrl(storeId, sessionId) {
+        const frontendAppRoute = this.app.type === 'storefront' && this.app.storefront?.external
+            ? `/${this.app.private_id}`
+            : '';
+        this.log(`View it at ${style.link(`${this.localFrontendUrl(storeId, sessionId)}${frontendAppRoute}`)}\n`);
     }
 }

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

@@ -7,6 +7,10 @@ export declare abstract class CreateAppCommand extends SwellCommand {
     };
     private devApi;
     constructor(argv: string[], config: any);
+    addAllowedHostsToAstro(configPath: string): Promise<void>;
+    addAllowedHostsToAngular(configPath: string): Promise<void>;
+    addAllowedHostsToNuxt(configPath: string): Promise<void>;
+    private addFrontendAllowedHosts;
     createAppConfigFolders(swellConfig: any): Promise<void>;
     createFrontendApp(swellConfig: any, flags: any, directCreate?: boolean, kind?: string): Promise<boolean>;
     createStorefrontApp(swellConfig: any, flags: any, directCreate?: boolean): Promise<boolean>;

package/dist/create-app-command.js

@@ -10,6 +10,7 @@ import Api from './lib/api.js';
 import { FrontendProjectTypes, getAllConfigPaths, writeFile, writeJsonFile, } from './lib/apps/index.js';
 import style from './lib/style.js';
 import { SwellCommand } from './swell-command.js';
+import fs from 'node:fs/promises';
 const execAsync = promisify(exec);
 export class CreateAppCommand extends SwellCommand {
     static baseFlags = {
@@ -30,6 +31,134 @@ export class CreateAppCommand extends SwellCommand {
         super(argv, config);
         this.devApi = new Api(undefined, 'test');
     }
+    async addAllowedHostsToAstro(configPath) {
+        const astroConfigPath = path.join(configPath, 'frontend', 'astro.config.mjs');
+        let content;
+        try {
+            content = await fs.readFile(astroConfigPath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        if (content.includes('allowedHosts')) {
+            return;
+        }
+        const lines = content.split('\n');
+        let insertIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('defineConfig({')) {
+                insertIndex = i + 1;
+                break;
+            }
+        }
+        if (insertIndex === -1) {
+            return;
+        }
+        // Detect indentation from next line or use default
+        const nextLine = lines[insertIndex];
+        const indentMatch = nextLine?.match(/^(\s+)/);
+        const baseIndent = indentMatch ? indentMatch[1] : '  ';
+        const viteConfig = [
+            `${baseIndent}vite: {`,
+            `${baseIndent}  server: {`,
+            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
+            `${baseIndent}  },`,
+            `${baseIndent}},`,
+        ];
+        lines.splice(insertIndex, 0, ...viteConfig);
+        await fs.writeFile(astroConfigPath, lines.join('\n'), 'utf-8');
+    }
+    async addAllowedHostsToAngular(configPath) {
+        const angularJsonPath = path.join(configPath, 'frontend', 'angular.json');
+        let content;
+        try {
+            content = await fs.readFile(angularJsonPath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        let config;
+        try {
+            config = JSON.parse(content);
+        }
+        catch {
+            return;
+        }
+        const projects = config.projects;
+        if (!projects || typeof projects !== 'object') {
+            return;
+        }
+        const projectNames = Object.keys(projects);
+        if (projectNames.length === 0) {
+            return;
+        }
+        // Use first project (typically only one exists in new apps)
+        const projectName = projectNames[0];
+        const project = projects[projectName];
+        if (!project?.architect?.serve) {
+            return;
+        }
+        if (!project.architect.serve.options) {
+            project.architect.serve.options = {};
+        }
+        if (project.architect.serve.options.allowedHosts) {
+            return;
+        }
+        project.architect.serve.options.allowedHosts = ['.ngrok.app', '.loca.lt'];
+        await fs.writeFile(angularJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    async addAllowedHostsToNuxt(configPath) {
+        const nuxtConfigPath = path.join(configPath, 'frontend', 'nuxt.config.ts');
+        let content;
+        try {
+            content = await fs.readFile(nuxtConfigPath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        if (content.includes('allowedHosts')) {
+            return;
+        }
+        const lines = content.split('\n');
+        let insertIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('defineNuxtConfig({')) {
+                insertIndex = i + 1;
+                break;
+            }
+        }
+        if (insertIndex === -1) {
+            return;
+        }
+        const nextLine = lines[insertIndex];
+        const indentMatch = nextLine?.match(/^(\s+)/);
+        const baseIndent = indentMatch ? indentMatch[1] : '  ';
+        const viteConfig = [
+            `${baseIndent}vite: {`,
+            `${baseIndent}  server: {`,
+            `${baseIndent}    allowedHosts: ['.ngrok.app', '.loca.lt'],`,
+            `${baseIndent}  },`,
+            `${baseIndent}},`,
+        ];
+        lines.splice(insertIndex, 0, ...viteConfig);
+        await fs.writeFile(nuxtConfigPath, lines.join('\n'), 'utf-8');
+    }
+    async addFrontendAllowedHosts(projectType, configPath) {
+        // Configure allowedHosts for frameworks using Vite dev server
+        // This allows tunneling services (ngrok, localtunnel) to proxy requests to the local dev environment
+        switch (projectType.slug) {
+            case 'astro':
+                await this.addAllowedHostsToAstro(configPath);
+                break;
+            case 'angular':
+                await this.addAllowedHostsToAngular(configPath);
+                break;
+            case 'nuxt':
+                await this.addAllowedHostsToNuxt(configPath);
+                break;
+            // Other frameworks don't require allowedHosts configuration
+        }
+    }
     async createAppConfigFolders(swellConfig) {
         for (const type of getAllConfigPaths(swellConfig.get('type'))) {
             // Create a config folder
@@ -67,6 +196,9 @@ export class CreateAppCommand extends SwellCommand {
             if (!projectType) {
                 this.error(`Could not find project type: ${frameworkType}`);
             }
+            if (!projectType.installCommand) {
+                this.error(`Project type ${projectType.name} cannot be installed (legacy type)`);
+            }
             this.log();
             spinner.start(`Creating ${projectType?.name} frontend app (this may take a while)...`);
             try {
@@ -88,6 +220,31 @@ export class CreateAppCommand extends SwellCommand {
                 this.log();
                 return false;
             }
+            // Ensure frontend package.json has correct name for workspace
+            const frontendPkgPath = path.join(configPath, 'frontend', 'package.json');
+            try {
+                const pkgContent = await fs.readFile(frontendPkgPath, 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                if (pkg.name !== 'frontend') {
+                    pkg.name = 'frontend';
+                    await fs.writeFile(frontendPkgPath, JSON.stringify(pkg, null, 2), 'utf-8');
+                }
+            }
+            catch {
+                // Ignore if package.json doesn't exist or can't be read
+            }
+            await this.addFrontendAllowedHosts(projectType, configPath);
+            // Re-run npm install at root to properly initialize workspace structure
+            // (removes frontend/package-lock.json, hoists dependencies, creates root lock file)
+            spinner.start('Initializing workspace...');
+            try {
+                const execAsync = promisify(exec);
+                await execAsync('npm install', { cwd: configPath });
+                spinner.succeed('Workspace initialized');
+            }
+            catch (error) {
+                spinner.warn('Failed to initialize workspace');
+            }
             spinner.succeed(`${projectType?.name} initialized app in ${configPath}/frontend/`);
             if (directCreate) {
                 this.log();
@@ -212,6 +369,9 @@ export class CreateAppCommand extends SwellCommand {
         const configPath = path.dirname(config.path);
         const packageJson = {
             description: config.get('description'),
+            // Include workspace even if frontend doesn't exist yet
+            // npm tolerates missing workspace directories without errors
+            workspaces: ['frontend'],
             devDependencies: {
                 '@swell/app-types': '^1.0.5',
             },
@@ -226,7 +386,7 @@ export class CreateAppCommand extends SwellCommand {
                 target: 'esnext',
                 types: ['@swell/app-types'],
             },
-            exclude: ['node_modules'],
+            exclude: ['node_modules', 'frontend'],
             include: ['**/*.ts'],
         };
         await writeJsonFile(path.join(configPath, 'package.json'), packageJson);

package/dist/env/local.d.ts

@@ -4,5 +4,6 @@ declare namespace _default {
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
+    let LOCAL_PROXY_PROVIDER: string;
 }
 export default _default;

package/dist/env/local.js

@@ -4,4 +4,5 @@ export default {
     LOGIN_HOST: 'http://${STORE_ID}.swell.test:3000',
     APP_PAGES_HOST: 'http://${STORE_ID}--${APP_ID}--${ENV}.swell.test:4001',
     STOREFRONT_FRONTEND_HOST: 'http://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.test:4001',
+    LOCAL_PROXY_PROVIDER: '',
 };

package/dist/env/production.d.ts

@@ -4,5 +4,6 @@ declare namespace _default {
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
+    let LOCAL_PROXY_PROVIDER: string;
 }
 export default _default;

package/dist/env/production.js

@@ -4,4 +4,5 @@ export default {
     LOGIN_HOST: 'https://${STORE_ID}.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.store',
+    LOCAL_PROXY_PROVIDER: '',
 };

package/dist/env/review.d.ts

@@ -4,5 +4,6 @@ declare namespace _default {
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
+    let LOCAL_PROXY_PROVIDER: string;
 }
 export default _default;

package/dist/env/review.js

@@ -4,4 +4,5 @@ export default {
     LOGIN_HOST: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.${REVIEW_DOMAIN}.rav2.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.${REVIEW_DOMAIN}.rav2.swell.store',
+    LOCAL_PROXY_PROVIDER: '',
 };

package/dist/env/staging.d.ts

@@ -4,5 +4,6 @@ declare namespace _default {
     let LOGIN_HOST: string;
     let APP_PAGES_HOST: string;
     let STOREFRONT_FRONTEND_HOST: string;
+    let LOCAL_PROXY_PROVIDER: string;
 }
 export default _default;

package/dist/env/staging.js

@@ -4,4 +4,5 @@ export default {
     LOGIN_HOST: 'https://staging.swell.store',
     APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.staging.swell.store',
     STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.staging.swell.store',
+    LOCAL_PROXY_PROVIDER: '',
 };

package/dist/lib/apps/app-config.d.ts

@@ -53,4 +53,53 @@ export declare abstract class AppConfig {
     protected abstract preparePostData(postData: any): Promise<any>;
     abstract type: ConfigType;
 }
+export declare class AppConfigDefault extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigModel extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigContent extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigNotification extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigSetting extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigWebhook extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigFunction extends AppConfig {
+    hasValues: boolean;
+    type: ConfigType;
+    isRootFunction(): boolean;
+    preparePostData(postData: any): Promise<any>;
+}
+export declare class AppConfigAsset extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+}
+export declare class AppConfigFrontend extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+}
+export declare class AppConfigTheme extends AppConfigDefault {
+    hasValues: boolean;
+    type: ConfigType;
+    preparePostData(postData: any): Promise<any>;
+}
 export {};

package/dist/lib/apps/app-config.js

@@ -174,14 +174,14 @@ export class AppConfig {
             : this.fileData?.toString('utf8');
     }
 }
-class AppConfigDefault extends AppConfig {
+export class AppConfigDefault extends AppConfig {
     hasValues = false;
     type = ConfigType.FILE;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigModel extends AppConfig {
+export class AppConfigModel extends AppConfig {
     hasValues = true;
     type = ConfigType.MODEL;
     preparePostData(postData) {
@@ -190,7 +190,7 @@ class AppConfigModel extends AppConfig {
         return postData;
     }
 }
-class AppConfigContent extends AppConfig {
+export class AppConfigContent extends AppConfig {
     hasValues = true;
     type = ConfigType.CONTENT;
     preparePostData(postData) {
@@ -198,7 +198,7 @@ class AppConfigContent extends AppConfig {
         return postData;
     }
 }
-class AppConfigNotification extends AppConfig {
+export class AppConfigNotification extends AppConfig {
     hasValues = true;
     type = ConfigType.NOTIFICATION;
     preparePostData(postData) {
@@ -225,35 +225,42 @@ class AppConfigNotification extends AppConfig {
         return postData;
     }
 }
-class AppConfigSetting extends AppConfig {
+export class AppConfigSetting extends AppConfig {
     hasValues = true;
     type = ConfigType.SETTING;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigWebhook extends AppConfig {
+export class AppConfigWebhook extends AppConfig {
     hasValues = true;
     type = ConfigType.WEBHOOK;
     preparePostData(postData) {
         return postData;
     }
 }
-class AppConfigFunction extends AppConfig {
+export class AppConfigFunction extends AppConfig {
     hasValues = true;
     type = ConfigType.FUNCTION;
+    isRootFunction() {
+        return (this.isRootConfig('functions') &&
+            (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts')));
+    }
     async preparePostData(postData) {
-        const isFunction = this.isRootConfig('functions') &&
-            (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts'));
-        if (isFunction) {
+        if (this.isRootFunction()) {
             try {
+                // get file contents and if it's empty ignore
+                const fileData = this.prepareFileData();
+                if (!fileData) {
+                    return;
+                }
                 const { code, config } = await bundleFunction(this.filePath);
                 if (!config) {
                     throw new IgnoringFileError('Function must export a `config` object.');
                 }
                 // Save the original file and the bundled version
                 postData.file = {
-                    data: this.prepareFileData(),
+                    data: fileData,
                 };
                 postData.build_file = {
                     content_type: 'text/javascript',
@@ -269,15 +276,15 @@ class AppConfigFunction extends AppConfig {
     }
 }
 // Assets do not get installed but saved as plain files
-class AppConfigAsset extends AppConfigDefault {
+export class AppConfigAsset extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.ASSET;
 }
-class AppConfigFrontend extends AppConfigDefault {
+export class AppConfigFrontend extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.FRONTEND;
 }
-class AppConfigTheme extends AppConfigDefault {
+export class AppConfigTheme extends AppConfigDefault {
     hasValues = false;
     type = ConfigType.THEME;
     preparePostData(postData) {