@swell/cli 2.0.1-alpha.8 → 2.0.2-alpha.0

package/dist/commands/app/push.js

@@ -1,170 +1,96 @@
-import { confirm } from '@inquirer/prompts';
-import { Flags, Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import * as path from 'node:path';
-import ora from 'ora';
-import { appConfigFileExists } from '../../lib/app-config.js';
-import { ConfigPaths, allConfigFilesPathsByType, appConfigFromFile, getConfigTypeFromPath, getConfigTypeKeyFromValue, } from '../../lib/apps/index.js';
+import { ConfigPaths, filePathExists, isPathDirectory, } from '../../lib/apps/index.js';
 import style from '../../lib/style.js';
-import { RemoteAppCommand } from '../../remote-app-command.js';
-import { default as swellConfig } from '../../lib/config.js';
-export default class AppPush extends RemoteAppCommand {
-    static description = `Push all app configurations, a specific file, or a specific configuration
-type to an app in your store's test environment. If the app does not exist yet,
-it will be created and its global ID saved to a .swellrc file.
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppPush extends PushAppCommand {
+    static args = {
+        file: Args.string({
+            char: 'f',
+            description: 'relative path to a configuration file or directory to push',
+        }),
+    };
+    static delayOrientation = true;
+    static description = `Push all app files, a specific file, or a specific configuration
+type to an app in your store's test environment.
+
+If the app does not exist, it will be created and its global ID saved to a .swellrc file.
 
 - If no file is specified, all configuration files will be pushed to the store.
   This includes the app icon (assets/icon.png) and swell.json.
 - If a file is specified, only that file will be pushed to the store.
 - If a directory is specified, only files in that directory will be pushed.
 
-App configuration directories:
+App file directories:
 ${Object.values(ConfigPaths)
         .map((dir) => style.path(`${dir}/`))
         .join('\n')}`;
     static examples = [
         'swell app push',
-        'swell app push -f content',
-        'swell app push -f models/products.json',
+        'swell app push content',
+        'swell app push models/products.json',
     ];
-    static args = {
-        file: Args.string({
-            char: 'f',
-            description: 'relative path to a configuration file or directory to push',
-        }),
-    };
-    // Deprecating the flags in favor of args
     static flags = {
-        file: Flags.string({
-            char: 'f',
-            description: 'relative path to a configuration file or directory to push',
+        force: Flags.boolean({
+            default: false,
+            description: 'force push all configurations',
+        }),
+        'no-deploy': Flags.boolean({
+            description: 'skip deploying app frontend',
         }),
     };
     static orientation = {
         env: 'test',
     };
-    static summary = 'Push configuration files to your Swell app.';
+    static summary = 'Push local files to your Swell app.';
+    resolvePushPaths(file) {
+        // Join the appPath and file to get the absolute filePath
+        const filePath = path.resolve(process.cwd(), file);
+        // Check if filePath is outside of appPath
+        const relativePath = path.relative(this.appPath, filePath);
+        if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+            this.error(`Path ${style.path(file)} is outside of the current app directory.`);
+        }
+        return { filePath, relativePath };
+    }
     async run() {
         const { args, flags } = await this.parse(AppPush);
-        const { file: fileArg } = args;
-        const { file: fileFlag } = flags;
-        const file = fileArg || fileFlag;
-        const currentStore = swellConfig.getDefaultStore();
-        this.api.setStoreEnv(currentStore, 'test');
-        this.app = await this.getAppWithConfig('', false);
-        const confirmExistingApp = await this.confirmRemoveInstalledApp(currentStore);
-        if (confirmExistingApp === false) {
+        const { file } = args;
+        const { force } = flags;
+        const noDeploy = flags['no-deploy'];
+        if (this.swellConfig.store?.type === 'theme') {
+            await this.config.runCommand('theme:push', [
+                ...(file ? [file] : []),
+                ...(force ? ['--force'] : []),
+                '--sync-app',
+            ]);
             return;
         }
-        // If app exists but owned by another client, offer to create a new instance
-        if (this.app.client_id && this.app.client_id !== currentStore) {
-            if (!confirmExistingApp?.id) {
-                const otherAppName = this.app.name || this.appConfig.get('name');
-                const confirmPushNew = await confirm({
-                    message: `${style.appConfigValue(otherAppName)} has a dev version in another ${this.app.client_id
-                        ? `store ${style.dim(`(${this.app.client_id})`)}`
-                        : 'environment'}. Do you want to create a new development instance in ${style.storeId(currentStore)}?`,
-                    default: false,
-                });
-                if (!confirmPushNew) {
-                    return;
-                }
-            }
-            // create a new app
-            this.app = await this.getCreateUpdateApp();
-            if (!this.app) {
-                return;
-            }
-        }
-        else if (!file) {
-            // update existing app if not targeting a file
-            this.app = await this.getCreateUpdateApp(this.app);
+        await this.logOrientation();
+        if (!(await this.ensureAppExists(file))) {
+            return;
         }
         if (file) {
-            const filePath = path.join(this.appPath, file);
-            if (!appConfigFileExists(filePath)) {
-                this.error(`Path ${style.path(file)} does not exist`);
-            }
-            const filePathParsed = path.parse(file);
-            // if no directory is identified and no extension, it means the user
-            // passed in a config directory
-            if (!filePathParsed.dir && !filePathParsed.ext) {
-                await this.pushConfigPath(filePathParsed.base);
-                this.logDashboardUrl(flags, currentStore);
+            const { filePath, relativePath } = this.resolvePushPaths(file);
+            // Push individual files if not referring to the whole app path
+            if (filePath !== this.appPath) {
+                if (!filePathExists(filePath)) {
+                    this.error(`Path ${style.path(file)} does not exist.`);
+                }
+                // Targeting a directory
+                await (isPathDirectory(filePath)
+                    ? this.pushFilePath(relativePath, force)
+                    : this.pushFile(relativePath));
+                this.log();
+                this.logDashboardUrl(flags);
                 return;
             }
-            await this.pushFile(filePath);
-            this.logDashboardUrl(flags, currentStore);
-            return;
-        }
-        const syncResult = await this.syncAppConfigs();
-        const { installed, removed } = syncResult;
-        this.log(`Pushed ${installed.length} ${installed.length === 1 ? 'configuration' : 'configurations'}${removed.length > 0 ? ` (removed ${removed.length}).` : '.'}`);
-        this.logDashboardUrl(flags, currentStore);
-    }
-    logDashboardUrl(flags, storeId) {
-        this.log(`View the ${style.appConfigValue(this.app.name)} app in your dashboard at ${style.link(this.dashboardUrl(flags, storeId))}.`);
-    }
-    async pushConfigPath(path) {
-        const configType = getConfigTypeFromPath(path);
-        const configTypeKey = getConfigTypeKeyFromValue(configType);
-        if (!configTypeKey) {
-            this.error(`Invalid config path: ${path}`);
-        }
-        let pushedFiles = 0;
-        for (const { configFile } of allConfigFilesPathsByType(this.appPath, configTypeKey)) {
-            const appConfig = appConfigFromFile(configFile, configType);
-            // eslint-disable-next-line no-await-in-loop
-            await this.pushConfigFile(appConfig);
-            pushedFiles += 1;
         }
-        if (pushedFiles === 0) {
-            this.log(`No valid files to push found for ${style.path(path)}.`);
-        }
-        else {
-            this.log(`Pushed ${style.path(path)} to ${style.appConfigValue(this.app.name)}.`);
-        }
-    }
-    async pushFile(file) {
-        const configType = getConfigTypeFromPath(path.basename(path.dirname(file)));
-        if (!configType) {
-            this.error(`File ${file} is not a valid file to push.`);
-        }
-        const appConfig = appConfigFromFile(file, configType);
-        await this.pushConfigFile(appConfig);
-    }
-    async confirmRemoveInstalledApp(currentStore) {
-        if (!this.app.private_id) {
-            return true;
-        }
-        const existingInstalledApp = await this.api.get({
-            adminPath: `/client/apps/${this.app.private_id}`,
-        }, { query: { versioned: true } });
-        if (existingInstalledApp) {
-            const continuePush = await confirm({
-                message: `${style.storeId(currentStore)} has an installed version of ${style.appConfigValue(this.app.name)} v${existingInstalledApp.version}. Do you want to replace it with a development instance?`,
-                default: false,
-            });
-            if (!continuePush) {
-                return false;
-            }
-            // uninstall the existing app
-            const spinner = ora();
-            spinner.start('Removing installed app...');
-            try {
-                await this.api.put({
-                    adminPath: `/client/apps/${this.app.id}`,
-                }, {
-                    body: { uninstalled: true },
-                });
-                spinner.succeed('Installed app removed.');
-                this.log();
-            }
-            catch (err) {
-                spinner.fail(`Error removing installed app from ${style.storeId(currentStore)}.`);
-                this.logError(err.message);
-                return false;
-            }
+        await this.pushAppConfigs(force);
+        if (!noDeploy) {
+            await this.deployAppFrontend(force);
+            this.log();
         }
-        return existingInstalledApp;
+        this.logDashboardUrl(flags);
     }
 }

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

@@ -0,0 +1,13 @@
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppRelease extends PushAppCommand {
+    static args: {
+        version: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: any;
+    static summary: string;
+    run(): Promise<void>;
+    validateReleaseDetails(): void;
+    private validateCreateVersion;
+}

package/dist/commands/app/release.js

@@ -0,0 +1,148 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { CLIError } from '@oclif/errors';
+import * as fs from 'node:fs';
+import ora from 'ora';
+import * as semver from 'semver';
+import style from '../../lib/style.js';
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppRelease extends PushAppCommand {
+    static args = {
+        version: Args.string({
+            description: 'semver version to release',
+            async parse(input) {
+                const parsedInput = semver.valid(input);
+                if (parsedInput) {
+                    return parsedInput;
+                }
+                throw new CLIError(`Invalid version: ${input}`);
+            },
+        }),
+    };
+    static description = `App released are reviewed by the Swell team for quality and functionality before publishing.
+
+If the version does not exist, you will be prompted to create it.
+
+Use the --amend flag to update the description or release notes of an existing release version.
+
+Use the --supported=false flag to indicate the version is not officially supported by the developer.
+  
+The app must be connected to a partner account with access to publish.`;
+    static examples = [
+        'swell app release',
+        'swell app release 2.0.0',
+        'swell app release 2.0.0 --amend --release-notes ./releases/v2.0.0.md',
+    ];
+    static flags = {
+        amend: Flags.boolean({
+            description: 'amend the description or release notes of an existing release',
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'description of the changes in this version for internal use',
+        }),
+        'no-git-tag': Flags.boolean({
+            description: 'if the version is being created, do not create a git tag',
+        }),
+        'not-supported': Flags.boolean({
+            description: 'indicates the version is not officially supported by the developer',
+        }),
+        'release-notes': Flags.string({
+            description: 'relative path to a file containing release notes',
+        }),
+    };
+    static summary = 'Release a new version of your an app for publishing to the App Store.';
+    async run() {
+        const { args, flags } = await this.parse(AppRelease);
+        const { amend, message, 'not-supported': notSupported, 'release-notes': releaseNotesFile, } = flags;
+        if (!(await this.ensureAppExists(undefined, false))) {
+            return;
+        }
+        let releaseNotes;
+        if (releaseNotesFile) {
+            try {
+                releaseNotes = fs.readFileSync(releaseNotesFile, 'utf8');
+            }
+            catch {
+                this.error(`Release notes could not be loaded from \`${releaseNotesFile}\``);
+            }
+        }
+        const appVersion = await this.validateCreateVersion(args.version, flags);
+        if (!appVersion) {
+            return;
+        }
+        if (appVersion.released && !amend) {
+            throw new Error(`Version ${appVersion.version} has already been released. Use --amend to update version details.`);
+        }
+        const releaseData = {
+            description: message || appVersion.description,
+            release_notes: releaseNotesFile ? releaseNotes : appVersion.release_notes,
+            supported: notSupported
+                ? false
+                : appVersion.supported === undefined
+                    ? true
+                    : appVersion.supported,
+        };
+        if (!amend) {
+            const continueVersion = await confirm({
+                message: `Release ${style.appConfigValue(this.app.name)} version ${appVersion.version}?`,
+            });
+            if (!continueVersion) {
+                return;
+            }
+        }
+        const spinner = ora();
+        this.log();
+        spinner.start(`${amend ? 'Updating release' : 'Releasing'} version ${style.appConfigValue(appVersion.version)}`);
+        await this.updateVersion(appVersion.version, {
+            ...releaseData,
+            released: true,
+        }, spinner);
+        spinner.succeed(`${style.appConfigValue(this.app.name)} release ${appVersion.version} ${amend ? 'updated' : 'released'}.`);
+    }
+    validateReleaseDetails() {
+        if (!this.app.description) {
+            throw new Error('App must have a description');
+        }
+        const requiresPreviewImages = this.app.type === 'storefront' &&
+            (!this.app.kind || this.app.kind === 'shop') &&
+            this.app.storefront?.theme.provider !== 'app';
+        if (requiresPreviewImages) {
+            if (!this.app.preview_image) {
+                throw new Error('Storefront app must have a preview image to release');
+            }
+        }
+        else if (this.app.type !== 'theme' && !this.app.logo_icon) {
+            throw new Error('App must have a logo icon to release');
+        }
+    }
+    async validateCreateVersion(inputVersion, flags) {
+        let version = inputVersion;
+        if (!version) {
+            version = this.app.version;
+            if (!version) {
+                throw new Error('No version specified');
+            }
+        }
+        this.validateReleaseDetails();
+        let appVersion = await this.getVersion(version);
+        if (!appVersion) {
+            if (flags.amend) {
+                throw new Error(`Version ${version} does not exist.`);
+            }
+            else {
+                await this.config.runCommand('app:version', [
+                    version,
+                    ...(flags.message ? [`-m ${JSON.stringify(flags.message)}`] : []),
+                    ...(flags['no-git-tag'] ? ['--no-git-tag'] : []),
+                ]);
+                this.log();
+                appVersion = await this.getVersion(version);
+                if (!appVersion) {
+                    throw new Error(`An error occurred while creating version ${version}.`);
+                }
+            }
+        }
+        return appVersion;
+    }
+}

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

@@ -1,18 +1,19 @@
-import { RemoteAppCommand } from '../../remote-app-command.js';
-export default class AppVersion extends RemoteAppCommand {
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppVersion extends PushAppCommand {
     static args: {
         nextVersion: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
     static flags: {
-        'git-tag': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        amend: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         message: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'no-git-tag': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     static summary: string;
     run(): Promise<void>;
+    private createRemoteVersion;
     private gitCommit;
     private gitTag;
-    private updateRemote;
     private validateAndComputeVersion;
 }

package/dist/commands/app/version.js

@@ -2,10 +2,10 @@ import { confirm, input } from '@inquirer/prompts';
 import git from '@npmcli/git';
 import { Args, Flags } from '@oclif/core';
 import { CLIError } from '@oclif/errors';
-import * as semver from 'semver';
 import ora from 'ora';
+import * as semver from 'semver';
 import style from '../../lib/style.js';
-import { RemoteAppCommand } from '../../remote-app-command.js';
+import { PushAppCommand } from '../../push-app-command.js';
 const RELEASE_TYPES = [
     'major',
     'premajor',
@@ -15,8 +15,7 @@ const RELEASE_TYPES = [
     'prepatch',
     'prerelease',
 ];
-const TAG_VERSION_PREFIX = 'v';
-export default class AppVersion extends RemoteAppCommand {
+export default class AppVersion extends PushAppCommand {
     static args = {
         nextVersion: Args.string({
             description: `semver version or release type: ${[
@@ -45,47 +44,64 @@ The version change will be committed to the Git repository using the provided
 message or a default similar to the tag, e.g. "v1.0.1".
 
 By default, it creates a Git tag for the specified version. You can disable this
-behavior by using the --git-tag=false option.`;
+behavior by using the --no-git-tag option.`;
     static examples = [
         'swell app version',
         'swell app version minor',
         'swell app version 1.0.0 -m "First release"',
     ];
     static flags = {
-        'git-tag': Flags.boolean({
-            default: true,
-            description: 'create a git tag for this version (default true)',
+        amend: Flags.boolean({
+            description: 'amend the description an existing version',
         }),
         message: Flags.string({
             char: 'm',
-            description: 'description of the changes in this version',
+            description: 'description of the changes in this version for internal use',
+        }),
+        'no-git-tag': Flags.boolean({
+            description: 'do not create a git tag for this version',
         }),
     };
     static summary = 'Increment the version of your Swell app.';
     async run() {
         const { args, flags } = await this.parse(AppVersion);
-        const { 'git-tag': gitTag } = flags;
+        const { amend, 'no-git-tag': noGitTag } = flags;
         let { message } = flags;
         let { nextVersion } = args;
-        // load app from remote
-        this.app = await this.getAppWithConfig();
+        if (!(await this.ensureAppExists(undefined, false))) {
+            return;
+        }
         const remoteVersion = this.app.version;
-        const versions = await this.getVersions();
-        // if the user didn't set a version, show the current one
+        if (amend) {
+            const amendVersion = nextVersion || remoteVersion;
+            const appVersion = await this.getVersion(amendVersion);
+            if (appVersion) {
+                await this.updateVersion(amendVersion, {
+                    description: message,
+                });
+            }
+            else {
+                this.error(`Version ${amendVersion} does not exist yet.`);
+            }
+            return;
+        }
+        // If the user didn't specify a version, show the latest one
         if (!nextVersion) {
-            if (versions.length > 0) {
-                const lastVersion = versions[0].version;
-                this.log(`${style.appConfigValue(this.app.name)} latest version is ${style.appConfigValue(lastVersion)}`);
+            const latestVersion = await this.getVersion();
+            if (latestVersion) {
+                this.log(`${style.appConfigValue(this.app.name)} latest remote version is ${style.appConfigValue(latestVersion.version)}.`);
             }
             else {
-                this.log(`${style.appConfigValue(this.app.name)} has not been versioned yet`);
+                this.error(`${style.appConfigValue(this.app.name)} has not been versioned yet.`);
             }
             return;
         }
         nextVersion = this.validateAndComputeVersion(nextVersion, remoteVersion);
+        await this.pushAppConfigs();
+        await this.deployAppFrontend(false, false);
         if (!message) {
             message = await input({
-                message: 'Describe the changes in this version',
+                message: `Describe the changes in version ${nextVersion}:`,
             });
         }
         const continueVersion = await confirm({
@@ -95,50 +111,57 @@ behavior by using the --git-tag=false option.`;
             return;
         }
         if (!message) {
-            message = `${TAG_VERSION_PREFIX}${nextVersion}`;
+            message = nextVersion;
         }
+        this.log();
         const spinner = ora();
-        spinner.start('Creating version...');
+        spinner.start('Creating version');
         try {
-            await this.updateRemote(nextVersion, message, spinner);
+            await this.createRemoteVersion(nextVersion, message, spinner);
             await this.gitCommit(message);
-            if (gitTag)
+            if (!noGitTag)
                 await this.gitTag(nextVersion);
         }
-        catch (err) {
-            spinner.fail(err.message);
+        catch (error) {
+            spinner.fail(error.message);
             return;
         }
         spinner.succeed(`${style.appConfigValue(this.app.name)} version ${nextVersion} created.`);
     }
+    async createRemoteVersion(nextVersion, message, spinner) {
+        // update the version on the remote
+        const versionResponse = await this.api.post({ adminPath: `/apps/${this.app.id}/versions` }, {
+            body: { description: message, version: nextVersion },
+            onAsyncGetPath: (response) => ({
+                adminPath: `/apps/${this.app.id}/versions/${response.id}`,
+            }),
+            spinner,
+        });
+        if (!versionResponse || !versionResponse.version) {
+            spinner.fail('Something went wrong.');
+        }
+        // update the local app config file since remote was successful
+        this.swellConfig.set('version', nextVersion);
+    }
     async gitCommit(message) {
         // check if there are changes in the app config file
         // if there are no changes, there is nothing to commit
-        const configStatus = await git.spawn(['status', this.appConfig.path], {
-            cwd: this.appConfig.cwd,
+        const configStatus = await git.spawn(['status', this.swellConfig.path], {
+            cwd: this.swellConfig.cwd,
         });
         if (configStatus.stdout.includes('nothing to commit')) {
             return;
         }
         // add the app config file to commit - this will contain the new version
-        await git.spawn(['add', this.appConfig.path]);
+        await git.spawn(['add', this.swellConfig.path]);
         // commit the version change to git. It skips the git hooks with -n
         await git.spawn(['commit', '-n', '-m', message]);
     }
     async gitTag(nextVersion) {
-        const tag = `${TAG_VERSION_PREFIX}${nextVersion}`;
+        const tag = nextVersion;
         // tag the version in git
         await git.spawn(['tag', tag], { cwd: process.cwd() });
     }
-    async updateRemote(nextVersion, message, spinner) {
-        // update the version on the remote
-        const versionResponse = await this.api.post({ adminPath: `/apps/${this.app.id}/versions` }, { body: { description: message, version: nextVersion } });
-        if (!versionResponse || !versionResponse.version) {
-            spinner.fail('Something went wrong.');
-        }
-        // update the local app config file since remote was successful
-        this.appConfig.set('version', nextVersion);
-    }
     validateAndComputeVersion(nextVersion, remoteVersion) {
         let version = nextVersion;
         // compute the value of the next version and check if it's valid
@@ -146,10 +169,8 @@ behavior by using the --git-tag=false option.`;
             // increment the version
             version = semver.inc(remoteVersion, version);
         }
-        this.debug(`next version: ${version}`, `remote version: ${remoteVersion}`);
-        if (semver.eq(version, remoteVersion) ||
-            semver.lt(version, remoteVersion)) {
-            this.error(`The version you are trying to create ${version} needs to be greater than the current version ${remoteVersion}`);
+        if (semver.lt(version, remoteVersion)) {
+            this.error(`Version ${version} must be greater than the current version ${remoteVersion}.`);
         }
         return version;
     }

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

@@ -1,5 +1,5 @@
-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: string;
     static examples: string[];
     static flags: {
@@ -9,7 +9,5 @@ export default class AppWatch extends RemoteAppCommand {
         env: string;
     };
     static summary: string;
-    private watchListener;
     run(): Promise<void>;
-    private handleFileChange;
 }