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

package/dist/commands/app/watch.js

@@ -1,11 +1,6 @@
 import { Flags } from '@oclif/core';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { appConfigFileExists } from '../../lib/app-config.js';
-import { appConfigFromFile, findAppConfig, getConfigTypeFromPath, hasAllowedFileExtension, } from '../../lib/apps/index.js';
-import style from '../../lib/style.js';
-import { RemoteAppCommand } from '../../remote-app-command.js';
-export default class AppWatch extends RemoteAppCommand {
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppWatch extends PushAppCommand {
     static description = `Watches configuration files including functions, and automatically pushes
 to the remote store.
 
@@ -26,85 +21,10 @@ Optionally synchronize all configs on change.`;
         env: 'test',
     };
     static summary = 'Watch for changes and push app configurations.';
-    watchListener = async (eventType, filename) => {
-        const configFile = filename;
-        const pathParsed = path.parse(configFile);
-        const fileDirs = pathParsed.dir.split(path.sep);
-        // only the first directory is relevant for us
-        const configDir = fileDirs[0];
-        // we only want to watch files in the root of the app directory
-        // and with the allowed extensions
-        if (!configDir ||
-            fileDirs.length > 1 ||
-            !hasAllowedFileExtension(configFile)) {
-            return;
-        }
-        const configType = getConfigTypeFromPath(configDir);
-        if (!configType) {
-            this.debug(`watchListener: ${filename} is not a valid config type`);
-            return;
-        }
-        let watchFileEvent;
-        // per node docs:
-        //
-        //    On most platforms, 'rename' is emitted whenever a filename appears
-        //    or disappears in the directory.
-        //
-        // we want however to identify delete file events so we can send the
-        // correct API request
-        if (eventType === 'rename') {
-            watchFileEvent = 'new';
-            if (!appConfigFileExists(path.join(this.appPath, configFile))) {
-                watchFileEvent = 'deleted';
-            }
-        }
-        else {
-            watchFileEvent = 'change';
-        }
-        try {
-            await this.handleFileChange(configFile, configType, watchFileEvent);
-        }
-        catch (error) {
-            // we don't want to break the watcher if an error is thrown while
-            // handling a file change
-            this.debug(error);
-            // for tests though, we want to break the watcher
-            if (process.env.NODE_ENV === 'test') {
-                // throwing does not break the test so we need to hard exit and log
-                // the error
-                console.error(style.error(error));
-                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
-                process.exit(1);
-            }
-        }
-        // refetch app to get updated configs
-        this.app = await this.getAppWithConfig(this.app.id);
-    };
     async run() {
         const { flags } = await this.parse(AppWatch);
         this.app = await this.getAppWithConfig();
         this.log('Watching for changes...');
-        if (flags['sync-all']) {
-            await this.syncAppConfigs();
-            fs.watch(this.appPath, { recursive: true }, async (eventType, filename) => {
-                if (filename && hasAllowedFileExtension(filename)) {
-                    await this.syncAppConfigs();
-                }
-            });
-            return;
-        }
-        fs.watch(this.appPath, { recursive: true }, this.watchListener);
-    }
-    async handleFileChange(configFile, configType, event) {
-        if (event === 'deleted') {
-            const appConfig = findAppConfig(this.app, configFile, configType);
-            if (!appConfig) {
-                return;
-            }
-            return this.removeConfig(appConfig);
-        }
-        const appConfig = appConfigFromFile(path.join(this.appPath, configFile), configType);
-        const result = await this.pushConfigFile(appConfig);
-        this.debug(`handleFileChange: ${configFile} pushed`, result);
+        await this.watchForChanges({ syncAll: flags['sync-all'] });
     }
 }

package/dist/commands/create/app.d.ts

@@ -1,5 +1,5 @@
-import { SwellCommand } from '../../swell-command.js';
-export default class CreateApp extends SwellCommand {
+import { CreateAppCommand } from '../../create-app-command.js';
+export default class CreateApp extends CreateAppCommand {
     static args: {
         id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
@@ -8,14 +8,38 @@ export default class CreateApp extends SwellCommand {
         command: string;
         description: string;
     }[];
-    static flags: {
-        pkg: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-    };
+    static flags: any;
+    appType: string;
+    createSwellConfig({ allowOverwrite, inputId, inputStorefrontApp, inputType, inputYes, nestedPath, }: {
+        allowOverwrite?: boolean;
+        inputId: string;
+        inputStorefrontApp?: string;
+        inputType?: string;
+        inputYes?: boolean;
+        nestedPath?: boolean;
+    }): Promise<{
+        appId: string;
+        config: any;
+        installedStorefrontApp: any;
+        swellConfigJson: {
+            theme: {
+                storefront: {
+                    app: string;
+                };
+            };
+            description: string;
+            id: string;
+            name: string;
+            type: string;
+            version: string;
+        } | {
+            permissions: never[];
+            description: string;
+            id: string;
+            name: string;
+            type: string;
+            version: string;
+        };
+    } | undefined>;
     run(): Promise<void>;
-    private createAppConfigFolders;
-    private doesPackageManagerExist;
-    private findPackageManager;
-    private setupPackage;
-    private tryPackageSetup;
 }

package/dist/commands/create/app.js

@@ -1,23 +1,19 @@
 import { confirm, input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { exec } from 'node:child_process';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import ora from 'ora';
-import { appConfigFileExists, newConfig } from '../../lib/app-config.js';
-import { getAllConfigPaths, writeJsonFile } from '../../lib/apps/index.js';
+import { CreateAppCommand } from '../../create-app-command.js';
+import { newConfig, swellConfigFileExists } from '../../lib/app-config.js';
 import { toAppId, toAppName } from '../../lib/create/index.js';
 import style from '../../lib/style.js';
-import { SwellCommand } from '../../swell-command.js';
-const execAsync = promisify(exec);
-export default class CreateApp extends SwellCommand {
+export default class CreateApp extends CreateAppCommand {
     static args = {
         id: Args.string({
             default: '',
             description: `id of the app to create`,
         }),
     };
-    static description = 'Initialize an app with config file and folder structure.';
+    static description = 'Create an app.';
     static examples = [
         {
             command: 'swell create app',
@@ -43,69 +39,123 @@ export default class CreateApp extends SwellCommand {
             description: `use npm or yarn to install default dependencies, or none to disable`,
             options: ['npm', 'yarn', 'none'],
         }),
-        yes: Flags.boolean({
-            char: 'y',
-            description: `accept all default values`,
+        type: Flags.string({
+            char: 't',
+            description: `create a specific app type`,
+            options: ['admin', 'integration', 'storefront', 'theme'],
         }),
     };
-    async run() {
-        const { args, flags } = await this.parse(CreateApp);
-        const { id } = args;
-        const { pkg, yes } = flags;
-        let confirmYes = yes && id;
+    appType = '';
+    async createSwellConfig({ allowOverwrite = true, inputId, inputStorefrontApp, inputType, inputYes, nestedPath = true, }) {
+        let confirmYes = inputYes;
+        const type = inputType ||
+            (confirmYes
+                ? 'admin'
+                : await select({
+                    choices: [
+                        { name: 'Admin', value: 'admin' },
+                        { name: 'Integration', value: 'integration' },
+                        { name: 'Storefront', value: 'storefront' },
+                        { name: 'Theme', value: 'theme' },
+                    ],
+                    message: `What is the primary purpose of the app?`,
+                }));
+        const typeLabel = type === 'theme' ? 'theme' : 'app';
+        const typeLabelTitle = type === 'theme' ? 'Theme' : 'App';
         const name = confirmYes
-            ? toAppName(id)
+            ? toAppName(inputId)
             : await input({
-                default: id ? toAppName(id) : '',
-                message: 'App name',
+                default: inputId ? toAppName(inputId) : '',
+                message: `${typeLabelTitle} name`,
                 validate: (answer) => answer.length > 2,
             });
-        let appId = toAppId(id || '');
+        let appId = toAppId(inputId || '');
         if (!appId) {
             appId = await input({
                 default: toAppId(name),
-                message: 'App ID',
+                message: `${typeLabelTitle} ID`,
                 validate: (answer) => answer.length > 2,
             });
             appId = toAppId(appId);
-            confirmYes = yes && appId;
+            confirmYes = Boolean(inputYes && appId);
         }
+        const version = confirmYes
+            ? '1.0.0'
+            : await input({
+                default: '1.0.0',
+                message: `${typeLabelTitle} version`,
+            });
         const description = confirmYes
             ? ''
             : await input({
                 default: 'Something special',
-                message: 'Describe what the app does',
+                message: `Describe your ${typeLabel}`,
             });
-        const type = confirmYes
-            ? 'admin'
-            : await select({
-                choices: [
-                    { name: 'Admin', value: 'admin' },
-                    { name: 'Integration', value: 'integration' },
-                    { name: 'Storefront', value: 'storefront' },
-                ],
-                message: 'What is the primary purpose of the app?',
-            });
-        const appConfigJson = {
+        let storefrontInstalledApps;
+        let storefrontAppId;
+        let installedStorefrontApp;
+        if (type === 'theme') {
+            storefrontInstalledApps = await this.getInstalledStorefrontApps();
+            if (storefrontInstalledApps === false) {
+                return;
+            }
+            storefrontAppId =
+                inputStorefrontApp ||
+                    (storefrontInstalledApps.length > 1
+                        ? await select({
+                            choices: storefrontInstalledApps.map(({ app, id }) => ({
+                                name: app.name,
+                                value: id,
+                            })),
+                            message: `Which storefront app is your theme for?`,
+                        })
+                        : storefrontInstalledApps[0].id);
+            installedStorefrontApp = storefrontInstalledApps.find((installedApp) => inputStorefrontApp
+                ? inputStorefrontApp === installedApp.app_private_id ||
+                    inputStorefrontApp === installedApp.app_public_id ||
+                    inputStorefrontApp === installedApp.app_id ||
+                    inputStorefrontApp === toAppId(installedApp.app_private_id)
+                : installedApp.id === storefrontAppId);
+            if (!installedStorefrontApp) {
+                this.error(`Could not find an installed storefront app by id: ${storefrontAppId}`);
+            }
+        }
+        const swellConfigJson = {
             description,
             id: appId,
-            integrations: [],
             name,
-            permissions: [],
             type,
-            version: '1.0.0',
+            version,
+            ...(type === 'theme'
+                ? {
+                    theme: {
+                        storefront: {
+                            app: toAppId(installedStorefrontApp.app_private_id),
+                        },
+                    },
+                }
+                : {
+                    permissions: [],
+                }),
         };
-        const config = newConfig(appId);
-        if (!confirmYes && appConfigFileExists(config.path)) {
-            const continueCreateApp = await confirm({
-                message: `An app already exists in the target folder ${appId}. Overwrite?`,
-            });
-            if (!continueCreateApp) {
-                return;
+        const appPath = path.join(process.cwd(), appId);
+        if (swellConfigFileExists(appPath)) {
+            if (allowOverwrite) {
+                if (!confirmYes) {
+                    const continueCreateApp = await confirm({
+                        message: `An app already exists in the target path ${appPath}. Overwrite?`,
+                    });
+                    if (!continueCreateApp) {
+                        return;
+                    }
+                }
+            }
+            else {
+                this.error(`An app already exists in the target path ${appPath}.`);
             }
         }
-        this.log(`\nCreating app ${style.appConfigValue(name)} in ${config.path}`);
-        this.log(`\n${JSON.stringify(appConfigJson, null, 4)}\n`);
+        this.log(`\nCreating ${this.appType === 'theme' ? 'theme' : 'app'} ${style.appConfigValue(name)} in ${appPath}/swell.json`);
+        this.log(`\n${JSON.stringify(swellConfigJson, null, 2)}\n`);
         const confirmCreateApp = confirmYes
             ? true
             : await confirm({
@@ -114,100 +164,53 @@ export default class CreateApp extends SwellCommand {
         if (!confirmCreateApp) {
             return;
         }
+        const config = newConfig(nestedPath ? appId : '');
+        config.clear();
+        config.set(swellConfigJson);
+        return { appId, config, installedStorefrontApp, swellConfigJson };
+    }
+    async run() {
+        const { args, flags } = await this.parse(CreateApp);
+        const { id } = args;
+        const { pkg, yes } = flags;
+        const confirmYes = Boolean(yes && id);
+        const createParams = await this.createSwellConfig({
+            inputId: id,
+            inputStorefrontApp: flags['storefront-app'],
+            inputType: flags.type,
+            inputYes: confirmYes,
+        });
+        if (!createParams) {
+            return;
+        }
+        const { appId, config, installedStorefrontApp } = createParams;
         !confirmYes && this.log();
         const spinner = ora();
         spinner.start('Creating app...');
-        config.clear();
-        config.set(appConfigJson);
         if (pkg !== 'none') {
             await this.tryPackageSetup(appId, config, pkg);
         }
         await this.createAppConfigFolders(config);
-        spinner.succeed(`${style.appConfigValue(name)} app created.`);
-        this.log('\nNext steps:');
-        this.log(`Run ${style.command('swell app push')} to push configurations to your test store.`);
-        this.log(`Run ${style.command('swell app install')} to install the app in another store or environment.`);
-    }
-    async createAppConfigFolders(config) {
-        for (const type of getAllConfigPaths()) {
-            // Create a config folder
-            // eslint-disable-next-line no-await-in-loop
-            await execAsync(`mkdir -p ${type}`, {
-                cwd: path.dirname(config.path),
-            });
-            // Create gitkeep file
-            // eslint-disable-next-line no-await-in-loop
-            await execAsync(`touch ${path.join(type, '.gitkeep')}`, {
-                cwd: path.dirname(config.path),
-            });
-        }
-    }
-    async doesPackageManagerExist(packageManager) {
-        try {
-            await execAsync(`${packageManager} --version`);
-            return true;
-        }
-        catch {
-            this.debug(`Could not find ${packageManager} on your system. Please install ${packageManager} and try again.`);
-            return false;
+        spinner.succeed(`${style.appConfigValue(config.get('name'))} app created.\n`);
+        let createdFrontend;
+        let createdTheme;
+        if (installedStorefrontApp) {
+            createdTheme = await this.createThemeApp(config, flags, installedStorefrontApp);
         }
-    }
-    async findPackageManager(pkg = '') {
-        const packageManager = pkg;
-        // Determine if system has yarn or npm install
-        if (packageManager) {
-            if (await this.doesPackageManagerExist(packageManager)) {
-                return packageManager;
-            }
+        else if (config.get('type') === 'storefront') {
+            createdFrontend = await this.createStorefrontApp(config, flags);
         }
         else {
-            if (await this.doesPackageManagerExist('npm')) {
-                return 'npm';
-            }
-            if (await this.doesPackageManagerExist('yarn')) {
-                return 'yarn';
-            }
+            createdFrontend = await this.createFrontendApp(config, flags);
         }
-    }
-    async setupPackage(name, config, pkg) {
-        const execAsync = promisify(exec);
-        const packageJson = {
-            description: config.get('description'),
-            devDependencies: {
-                '@swell/app-types': '^1.0.5',
-            },
-            name,
-            scripts: {},
-            version: config.get('version'),
-        };
-        const tsConfig = {
-            compilerOptions: {
-                lib: ['esnext', 'webworker'],
-                module: 'esnext',
-                target: 'esnext',
-                types: ['@swell/app-types'],
-            },
-            exclude: ['node_modules'],
-            include: ['**/*.ts'],
-        };
-        await writeJsonFile(path.join(path.dirname(config.path), 'package.json'), packageJson);
-        await writeJsonFile(path.join(path.dirname(config.path), 'tsconfig.json'), tsConfig);
-        try {
-            const packageManager = await this.findPackageManager(pkg);
-            await execAsync(`${packageManager} install`, {
-                cwd: path.dirname(config.path),
-            });
-        }
-        catch (error) {
-            this.error(error.message);
-        }
-    }
-    async tryPackageSetup(name, config, pkg) {
-        try {
-            await this.setupPackage(name, config, pkg);
+        this.log('\nNext steps:');
+        this.log(`Run ${style.command('swell app push')} to push configurations to your test store.`);
+        this.log(`Run ${style.command('swell app install')} to install the app in another store or environment.`);
+        if (createdFrontend) {
+            this.log(`Run ${style.command('swell app frontend dev')} to start a local dev server for your frontend app.`);
         }
-        catch (error) {
-            this.log(`There was an error setting up the package manager: ${error.message}`);
+        else if (createdTheme) {
+            this.log(`Run ${style.command('swell app theme dev')} to start a local dev server for your theme.`);
         }
     }
 }

package/dist/commands/create/frontend.d.ts

@@ -0,0 +1,12 @@
+import { CreateAppCommand } from '../../create-app-command.js';
+export default class CreateFrontend extends CreateAppCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        pkg: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/create/frontend.js

@@ -0,0 +1,38 @@
+import { Flags } from '@oclif/core';
+import ora from 'ora';
+import { CreateAppCommand } from '../../create-app-command.js';
+import swellConfig from '../../lib/app-config.js';
+export default class CreateFrontend extends CreateAppCommand {
+    static description = 'Initialize a frontend app framework and folder structure.';
+    static examples = [
+        {
+            command: 'swell create frontend',
+            description: 'Create frontend app following command prompts.',
+        },
+        {
+            command: 'swell create frontend -y',
+            description: 'Create frontend app and accept all default values.',
+        },
+    ];
+    static flags = {
+        pkg: Flags.string({
+            char: 'p',
+            default: 'npm',
+            description: `use npm or yarn to install default dependencies, or none to disable`,
+            options: ['npm', 'yarn', 'none'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CreateFrontend);
+        const newSwellConfig = swellConfig();
+        const appType = newSwellConfig?.get('type');
+        const spinner = ora();
+        if (appType === 'theme') {
+            spinner.fail(`You can't create app frontend in a theme.`);
+            return;
+        }
+        await (appType === 'storefront'
+            ? this.createStorefrontApp(newSwellConfig, flags, true)
+            : this.createFrontendApp(newSwellConfig, flags, true));
+    }
+}

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

@@ -1,6 +1,6 @@
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
-export default class CreateFunction extends CreateCommand {
+export default class CreateFunction extends CreateConfigCommand {
     static args: {
         functionName: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
         trigger: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/create/function.js

@@ -1,11 +1,11 @@
 import { input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { getFunctionTemplate, } from '../../lib/create/function.js';
 import { toFunctionFileName } from '../../lib/create/index.js';
 const PERMITTED_TRIGGERS = ['cron', 'model', 'route'];
-export default class CreateFunction extends CreateCommand {
+export default class CreateFunction extends CreateConfigCommand {
     static args = {
         functionName: Args.string({
             description: 'function name, used in an http route if applicable',

package/dist/commands/create/notification.d.ts

@@ -1,6 +1,6 @@
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
-export default class CreateNotification extends CreateCommand {
+export default class CreateNotification extends CreateConfigCommand {
     static args: {
         model: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
         name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/create/notification.js

@@ -1,10 +1,10 @@
 import { input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
 import { capitalize, singularize } from 'inflection';
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { toFileName, toNotificationLabel } from '../../lib/create/index.js';
-export default class CreateNotification extends CreateCommand {
+export default class CreateNotification extends CreateConfigCommand {
     static args = {
         model: Args.string({
             description: 'data model to trigger the notification by',

package/dist/commands/env.d.ts

@@ -0,0 +1,12 @@
+import { Config } from '@oclif/core';
+import { SwellCommand } from '../swell-command.js';
+export default class Env extends SwellCommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        reviewBranch: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static hidden: boolean;
+    constructor(argv: string[], config: Config);
+    run(): Promise<void>;
+}

package/dist/commands/env.js

@@ -0,0 +1,31 @@
+import { Args } from '@oclif/core';
+import { env, setEnv } from '../lib/config.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Env extends SwellCommand {
+    static args = {
+        name: Args.string({
+            description: 'name of the environment (production, staging, local, review)',
+        }),
+        reviewBranch: Args.string({
+            description: 'name of a review branch',
+        }),
+    };
+    static description = `Internal: Display the current environment configuration.`;
+    static hidden = true;
+    constructor(argv, config) {
+        super(argv, config);
+        this.requiresAuth = false;
+    }
+    async run() {
+        const { args } = await this.parse(Env);
+        const { name, reviewBranch } = args;
+        if (name) {
+            const newEnv = setEnv(name, reviewBranch);
+            this.log(`Environment set to ${style.appEnv(name)}:`, JSON.stringify(newEnv, null, 2));
+        }
+        else {
+            this.log('Current environment:', JSON.stringify(env.store, null, 2));
+        }
+    }
+}