@swell/cli 1.0.1-alpha → 2.0.1-alpha.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Swell Commerce Corp.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -138,4 +138,4 @@ swell model pull -m theme.origin.page --content -f models/page.json --store my-t
 
 swell model push -f models/orders.json --store my-test-store --secret-key my-dev-secret-key
 swell model push -c -f models/page.json --store my-test-store --secret-key my-dev-secret-key
-```
+```

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env ts-node
+
+// eslint-disable-next-line unicorn/prefer-top-level-await, node/shebang
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ type: 'esm', development: true, dir: import.meta.url });
+})();

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env ts-node
+
+// eslint-disable-next-line unicorn/prefer-top-level-await, node/shebang
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ type: 'esm', dir: import.meta.url });
+})();

package/dist/app-command.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '@oclif/core';
+import { SwellCommand } from './swell-command.js';
+/**
+ * A base class for Swell CLI commands that do not require an app to be saved
+ * to the API. If your command requires an app to be saved to the API, extend
+ * the `RemoteAppCommand` class instead.
+ *
+ * This class extends the `SwellCommand` class and adds:
+ *
+ * - a config instance
+ * - a shorthand attribute for the app directory
+ */
+export declare abstract class AppCommand extends SwellCommand {
+    static baseFlags: {
+        'app-path': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    appConfig: any;
+    appPath: string;
+    constructor(argv: string[], config: Config);
+    init(): Promise<void>;
+    protected initBaseFlags(): Promise<void>;
+}

package/dist/app-command.js

@@ -0,0 +1,45 @@
+import { Flags } from '@oclif/core';
+import { default as appConfig } from './lib/app-config.js';
+import { SwellCommand } from './swell-command.js';
+/**
+ * A base class for Swell CLI commands that do not require an app to be saved
+ * to the API. If your command requires an app to be saved to the API, extend
+ * the `RemoteAppCommand` class instead.
+ *
+ * This class extends the `SwellCommand` class and adds:
+ *
+ * - a config instance
+ * - a shorthand attribute for the app directory
+ */
+export class AppCommand extends SwellCommand {
+    // base flags for all AppCommands
+    // needs to be in a ES2021 format: https://github.com/oclif/oclif/issues/1100
+    static baseFlags = {
+        'app-path': Flags.string({
+            description: 'path to the app directory',
+        }),
+    };
+    // local app configuration, what developers define
+    appConfig;
+    // the local path to the app directory
+    appPath = '';
+    constructor(argv, config) {
+        super(argv, config);
+        this.appConfig = appConfig();
+        this.appPath = this.appConfig.swDirPath;
+    }
+    async init() {
+        await super.init();
+        await this.initBaseFlags();
+    }
+    async initBaseFlags() {
+        const klass = super.ctor;
+        // ensure the base flags are available
+        klass.flags = { ...klass.flags, ...AppCommand.baseFlags };
+        const { flags } = await this.parse(klass);
+        // if the user passed an app path, use it: reload the app config
+        this.appConfig = appConfig(flags['app-path']);
+        this.appPath = this.appConfig.swDirPath;
+        this.debug(`config path loaded: ${this.appConfig.path}`);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppPull extends RemoteAppCommand {
+    static args: {
+        appId: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/dist/commands/app/_pull.js

@@ -0,0 +1,45 @@
+import { Args } from '@oclif/core';
+import { dasherize, pluralize, underscore } from 'inflection';
+import snakeCase from 'lodash/snakeCase.js';
+import * as path from 'node:path';
+import { newConfig } from '../../lib/app-config.js';
+import { ConfigPaths, writeJsonFile, } from '../../lib/apps/index.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppPull extends RemoteAppCommand {
+    static args = {
+        appId: Args.string({ description: 'app id to pull' }),
+    };
+    static summary = 'Pull app configuration from remote.';
+    async run() {
+        const { args } = await this.parse(AppPull);
+        const { appId } = args;
+        this.appPath = process.cwd();
+        if (!appId) {
+            this.error('You must provide an app id to pull');
+        }
+        this.log(`Will pull app configuration for ${style.appConfigValue(appId)} in ${this.appPath}`);
+        this.app = await this.getApp(appId);
+        this.debug('run: app', this.app);
+        // save app definition
+        const config = newConfig();
+        const appConfigJson = {
+            description: this.app.description || '',
+            id: snakeCase(this.app.name),
+            name: this.app.name,
+            version: this.app.version,
+        };
+        config.clear();
+        config.set(appConfigJson);
+        // save app configs
+        for (const config of this.app?.configs || []) {
+            if (!config)
+                continue;
+            const configType = config.type;
+            const typeDirName = ConfigPaths[configType];
+            const fileName = pluralize(dasherize(underscore(config.name)).toLowerCase());
+            const filePath = path.join(this.appPath, typeDirName, `${fileName}.json`);
+            writeJsonFile(filePath, config.values);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppUninstall extends RemoteAppCommand {
+    static description: string;
+    static flags: {
+        env: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        store: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static orientation: {
+        env: string;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/app/_uninstall.js

@@ -0,0 +1,45 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import config from '../../lib/config.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppUninstall extends RemoteAppCommand {
+    static description = 'Uninstalls an existing App';
+    static flags = {
+        env: Flags.string({
+            default: 'test',
+            description: 'environment to uninstall the app from',
+        }),
+        store: Flags.string({
+            char: 's',
+            description: 'store id to uninstall the app from',
+        }),
+    };
+    static orientation = {
+        env: 'test',
+    };
+    async run() {
+        const { flags } = await this.parse(AppUninstall);
+        const { env, store } = flags;
+        this.app = await this.getAppWithConfig();
+        const storeToUninstall = store || config.getDefaultStore();
+        config.ensureLoggedIn(storeToUninstall);
+        const uninstallMsg = `${style.appConfigValue(this.app.name)} from store ${style.storeId(storeToUninstall)} with version ${style.appConfigValue(this.app.version)}`;
+        const continueUninstall = await confirm({
+            message: `Uninstalling ${uninstallMsg}. Ok to continue?`,
+        });
+        if (!continueUninstall) {
+            this.logError('Uninstall cancelled');
+            return;
+        }
+        const clientApp = await this.api.get({ adminPath: `/client/apps/${this.app.id}` }, { query: { env } });
+        if (!clientApp) {
+            this.error(`Error uninstalling ${uninstallMsg}: app not installed on store.`);
+        }
+        if (clientApp.uninstalled) {
+            this.error(`Error uninstalling ${uninstallMsg}: app already uninstalled on store.`);
+        }
+        await this.api.put({ adminPath: `/client/apps/${this.app.id}` }, { body: { env, uninstalled: true } });
+        this.log(`${style.appConfigValue(this.app.name)} app uninstalled from store ${style.storeId(storeToUninstall)}.`);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppInfo extends RemoteAppCommand {
+    static args: {
+        versions: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static summary: string;
+    run(): Promise<void>;
+    private showAppInfo;
+    private showVersions;
+}

package/dist/commands/app/info.js

@@ -0,0 +1,92 @@
+import { Args } from '@oclif/core';
+import ora from 'ora';
+import { getBorderCharacters, table } from 'table';
+import { FieldDefinitions } from '../../lib/info.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+// The app fields will be displayed in the order they are defined here
+const FIELDS_TO_DISPLAY = [
+    'name',
+    'description',
+    'version',
+    'public_id',
+    'published',
+    'date_created',
+    'date_updated',
+    'installed',
+    'client',
+];
+export default class AppInfo extends RemoteAppCommand {
+    static args = {
+        versions: Args.string({ description: 'list all app versions' }),
+    };
+    static description = `The command shows the latest information about your app including the name,
+description, version, public ID, test store, and more. If the ${style.command('versions')} argument is passed,
+it will output all versions of the app instead.`;
+    static examples = [
+        {
+            command: 'swell app info',
+            description: 'Show general information about the app.',
+        },
+        {
+            command: 'swell app info versions',
+            description: 'Show all established versions of the app.',
+        },
+    ];
+    static summary = 'Show information about your Swell app.';
+    async run() {
+        const { args } = await this.parse(AppInfo);
+        const { versions } = args;
+        if (versions) {
+            await this.showVersions();
+            return;
+        }
+        await this.showAppInfo();
+    }
+    async showAppInfo() {
+        const spinner = ora();
+        spinner.start('Retrieving app info...');
+        this.app = await this.getAppWithConfig().catch((error) => {
+            spinner.fail(`Error fetching app info: ${JSON.stringify(this.app)}`);
+            throw error;
+        });
+        if (spinner.isSpinning) {
+            spinner.stop();
+        }
+        // we pull versions to make sure that what is displayed is the latest
+        const versions = await this.getVersions();
+        // Output the app field information, e.g.:
+        //    Name: My App
+        const fieldDefinitions = new FieldDefinitions(this.app, versions);
+        for (const field of FIELDS_TO_DISPLAY) {
+            const fieldDef = fieldDefinitions.getFieldDefinition(field);
+            this.log(style.appConfigName(`${fieldDef.label}:`), fieldDef.value);
+        }
+        // dashboard url is built, not part of the app object
+        // we display it at the end for better readability and simplicity
+        this.log(style.appConfigName('Dashboard:'), style.link(this.dashboardUrl({}, this.app.client_id)));
+    }
+    async showVersions() {
+        const spinner = ora();
+        spinner.start('Retrieving app versions...');
+        this.app = await this.getAppWithConfig().catch((error) => {
+            spinner.fail(`Error fetching app info: ${JSON.stringify(this.app)}`);
+            throw error;
+        });
+        const versions = await this.handleRequestErrors(async () => this.getVersions(), () => spinner.fail('Error fetching app versions'));
+        if (versions.length === 0) {
+            spinner.warn('No versions found');
+            return;
+        }
+        spinner.succeed(`${this.app.name} app versions:\n`);
+        const displayData = versions.map((appVersion) => [
+            style.appConfigValue(appVersion.version),
+            appVersion.notes,
+            new Date(appVersion.date_created).toUTCString(),
+        ]);
+        this.log(table(displayData, {
+            border: getBorderCharacters('void'),
+            drawHorizontalLine: () => false,
+        }));
+    }
+}

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

@@ -0,0 +1,17 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppInstall extends RemoteAppCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        env: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        store: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private installApp;
+    private installConfirmationMessage;
+    private updateApp;
+    private getInstalledApp;
+    private confirmRemoveDevelopmentApp;
+}

package/dist/commands/app/install.js

@@ -0,0 +1,177 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import * as semver from 'semver';
+import ora from 'ora';
+import config from '../../lib/config.js';
+import style from '../../lib/style.js';
+import { selectLoggedInStoreId, selectEnvironmentId, } from '../../lib/stores.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppInstall extends RemoteAppCommand {
+    static description = `Without a version specified, install the latest version of the app.
+
+Without a store specified, install the app in the Live environment of the current store.`;
+    static examples = [
+        'swell install',
+        'swell install -v 3.2.7',
+        'swell install -v 1.0.0 -s my-store-id',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'target environment to install the app, defaults to live',
+        }),
+        store: Flags.string({
+            char: 's',
+            description: 'target store id to install the app, defaults to the current store',
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'version of the app to install, defaults to latest',
+            async parse(input) {
+                if (!semver.valid(input)) {
+                    throw new Error(`Invalid version: ${input}`);
+                }
+                return input;
+            },
+        }),
+    };
+    static summary = 'Install an existing app in another store environment.';
+    async run() {
+        const { flags } = await this.parse(AppInstall);
+        const { env, store, version } = flags;
+        this.app = await this.getAppWithConfig();
+        const versions = await this.getVersions(version);
+        if (versions.length === 0) {
+            this.error(`${version ? `Version ${version} not found` : 'No versions found'} for ${style.appConfigValue(this.app.name)} app. ${version
+                ? ''
+                : `Create a version with the ${style.command('swell version')} command first.`}`);
+        }
+        const versionToInstall = version
+            ? versions.find((ver) => ver.version === version)?.version
+            : versions[0].version;
+        let storeToInstall = store;
+        if (!storeToInstall) {
+            const loggedInStores = config.get('stores') || [];
+            if (loggedInStores.length > 0) {
+                storeToInstall = await selectLoggedInStoreId('Which store do you want to install the app in?');
+            }
+            if (!storeToInstall) {
+                return;
+            }
+        }
+        let envToInstall = env;
+        if (!envToInstall) {
+            envToInstall = await selectEnvironmentId();
+        }
+        if (envToInstall === 'live') {
+            envToInstall = undefined;
+        }
+        if (envToInstall && envToInstall !== 'test') {
+            this.error(`${envToInstall} is not a valid environment.`);
+        }
+        if (envToInstall === 'test' && storeToInstall === this.app.client_id) {
+            this.error(`You cannot install an app in the test environment of the same store.`);
+        }
+        config.ensureLoggedIn(storeToInstall);
+        this.api.setStoreEnv(storeToInstall, envToInstall);
+        // check if app is already installed on store
+        const existingInstalledApp = await this.getInstalledApp();
+        const existingVersion = existingInstalledApp?.id
+            ? existingInstalledApp.version
+            : null;
+        // confirm install unless params were passed explicitly
+        let extraMessage = '';
+        if (!store || !env) {
+            const continueInstall = await confirm({
+                message: this.installConfirmationMessage(storeToInstall, envToInstall, versionToInstall, existingVersion),
+            });
+            if (!continueInstall) {
+                // we don't want to throw an error as it is a valid exit
+                return;
+            }
+        }
+        else {
+            extraMessage = ` ${style.appConfigValue(this.app.name)} v${versionToInstall} on ${style.storeId(storeToInstall)} [${envToInstall ? envToInstall : 'live'}]`;
+        }
+        const shouldContinue = await this.confirmRemoveDevelopmentApp(storeToInstall);
+        if (!shouldContinue) {
+            return;
+        }
+        const spinner = ora();
+        // install or update app depending on whether it's already installed
+        let request;
+        if (existingInstalledApp?.id) {
+            spinner.start(`Updating${extraMessage}...`);
+            request = async () => this.updateApp(versionToInstall, envToInstall);
+        }
+        else {
+            spinner.start(`Installing${extraMessage}...`);
+            request = async () => this.installApp(versionToInstall, envToInstall);
+        }
+        const response = await this.handleRequestErrors(request, () => spinner.fail('Something went wrong.'));
+        if (response?.errors) {
+            spinner.fail(`Error installing app: ${JSON.stringify(response.errors)}`);
+        }
+        spinner.succeed(`Install complete. Manage app settings in your dashboard at ${style.link(this.dashboardUrl({ flags: { env: envToInstall } }, storeToInstall))}.`);
+    }
+    async installApp(version, env) {
+        return this.api.post({ adminPath: `/client/apps` }, 
+        // eslint-disable-next-line camelcase
+        { body: { app_id: this.app.id, version } });
+    }
+    installConfirmationMessage(storeToInstall, envToInstall, versionToInstall, existingVersion) {
+        const message = [];
+        if (existingVersion && semver.gt(versionToInstall, existingVersion)) {
+            message.push('Updating');
+        }
+        else if (existingVersion &&
+            semver.lt(versionToInstall, existingVersion)) {
+            message.push('Rolling back');
+        }
+        else {
+            message.push('Install');
+        }
+        let versionToShow = versionToInstall;
+        versionToShow += versionToInstall === this.app.version ? ' (latest)' : '';
+        message.push(style.appConfigValue(this.app.name), `v${versionToShow}`, `on ${style.storeId(storeToInstall)} [${envToInstall ? envToInstall : 'live'}]?`);
+        return message.join(' ');
+    }
+    async updateApp(version, env) {
+        await this.api.put({ adminPath: `/client/apps/${this.app.id}` }, { body: { version } });
+    }
+    async getInstalledApp() {
+        // check if app is already installed on store
+        return await this.api.get({ adminPath: `/client/apps/${this.app.id}` }, {});
+    }
+    async confirmRemoveDevelopmentApp(storeToInstall) {
+        const existingSourcedApps = await this.api.get({ adminPath: `/client/apps` }, {
+            query: { source_id: this.app.id },
+        });
+        if (existingSourcedApps.results[0]?.id) {
+            const continueInstall = await confirm({
+                message: `${style.storeId(storeToInstall)} has a development version of ${style.appConfigValue(this.app.name)}. Do you want to replace it with an installed instance?`,
+                default: false,
+            });
+            if (!continueInstall) {
+                return false;
+            }
+            // uninstall the existing app
+            const spinner = ora();
+            spinner.start('Removing development app...');
+            try {
+                await this.api.put({
+                    adminPath: `/client/apps/${existingSourcedApps.results[0].app_id}`,
+                }, {
+                    body: { uninstalled: true },
+                });
+                spinner.succeed('Development app removed.');
+            }
+            catch (err) {
+                spinner.fail(`Error removing development app from ${style.storeId(storeToInstall)}.`);
+                this.logError(err.message);
+                return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppPush extends RemoteAppCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static orientation: {
+        env: string;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private logDashboardUrl;
+    private pushConfigPath;
+    private pushFile;
+    private confirmRemoveInstalledApp;
+}