@swell/cli 1.0.2 → 2.0.1-alpha.10

package/dist/remote-app-command.js

@@ -0,0 +1,388 @@
+import { inflect } from 'inflection';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import ora from 'ora';
+import { AppCommand } from './app-command.js';
+import { appConfigFileExists, readRcFile, writeRcFile, } from './lib/app-config.js';
+import { FunctionProcessingError, IgnoringFileError, allConfigFilesPaths, appConfigFromFile, appLogoIcon, batchAppConfigsByType, configFilePath, isAppLogoIcon, } from './lib/apps/index.js';
+import { toAppId } from './lib/create/index.js';
+import { default as swellConfig } from './lib/config.js';
+import { getLoginHost } from './lib/constants.js';
+import style from './lib/style.js';
+/**
+ * Extends the AppCommand with methods that ease managing remote apps and
+ * configurations.
+ */
+export class RemoteAppCommand extends AppCommand {
+    // allows child commands to set orientation
+    // most of the times this will be the target environment
+    static orientation;
+    // an API instance of the current app definition
+    app = {};
+    dashboardUrl(flags = {}, storeId) {
+        const { env } = flags;
+        const envFlag = env || this.ctor.orientation?.env;
+        const outputEnv = envFlag === 'live' ? '' : !envFlag ? '' : 'test';
+        return `${getLoginHost(storeId)}/admin/${outputEnv ? `${outputEnv}/` : ''}apps/${this.app.id}`;
+    }
+    async deleteConfig(configId) {
+        if (!this.app) {
+            this.error('App is not defined');
+        }
+        return this.api.delete({
+            adminPath: `/apps/${this.app.id}/configs/${configId}`,
+        });
+    }
+    async getApp(id = '') {
+        const app = await this.api.get({ adminPath: `/apps/${id}` });
+        // Get app configs for processing
+        app.configs = [];
+        const configsResponse = await this.api.get({ adminPath: `/apps/${id}/configs` }, { query: { limit: 1000 } });
+        this.debugJson('getApp: configsResponse', configsResponse);
+        // for each config, we check if there's a local file and we add it to the
+        // AppConfig object
+        for (const config of configsResponse.results || []) {
+            const localPath = configFilePath(this.appPath, config);
+            if (appConfigFileExists(localPath)) {
+                config.localPath = localPath;
+            }
+            app.configs.push(config);
+        }
+        this.debugJson('getApp: remote app', app);
+        return app;
+    }
+    async getAppWithConfig(id = '', errorNotFound = true) {
+        const swellId = this.app?.id;
+        const appConfigId = this.appConfig.get('id');
+        if (!appConfigId) {
+            this.error(`App ${style.appConfigName('id')} is not defined in swell.json.`);
+        }
+        let appId = id || swellId;
+        if (!appId) {
+            const privateId = this.app?.private_id;
+            if (!privateId) {
+                this.error(`App ${style.appConfigName('id')} is not defined in swell.json.`);
+            }
+            if (privateId !== appConfigId) {
+                this.error(`App ${style.appConfigName('id')} must be declared in snake_case: ${style.appConfigValue(appConfigId)}.`);
+            }
+            appId = privateId;
+        }
+        // we initialize the app with the id so we can use it in the API calls
+        let app = {};
+        try {
+            app = await this.getApp(appId);
+        }
+        catch (error) {
+            this.debug('getApp: app not found', error);
+            let errorJson;
+            try {
+                errorJson = JSON.parse(error.message);
+            }
+            catch {
+                // if there's a JSON parse error, throw the original error
+                this.error(error);
+            }
+            // if the app doesn't exist, we don't want to throw an error as we might
+            // want to create it.
+            //
+            // if the `id` was passed as argument though, we want to throw an error so
+            // we don't create a loop.
+            //
+            // we don't throw an error ever sometimes, like when pushing an app
+            const shouldThrow = !errorNotFound && (errorJson.error.message !== 'App not found' || id);
+            if (shouldThrow) {
+                const errorMessage = typeof errorJson.error === 'string'
+                    ? errorJson.error
+                    : errorJson.error.message;
+                this.error(errorMessage);
+            }
+            if (swellId && swellId !== id && swellId !== this.app?.id) {
+                app = await this.getAppWithConfig(swellId);
+            }
+        }
+        return app;
+    }
+    async getCreateUpdateApp(updateApp) {
+        const spinner = ora();
+        let remoteApp;
+        try {
+            remoteApp = await readRcFile(this.swellRcPath());
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        /* eslint-disable camelcase */
+        const body = {
+            ...this.appConfig.store,
+            // we store locally the private id as the id, but we need to switch it
+            // when posting to the API
+            id: undefined,
+            logo_icon: null,
+            ...(this.appConfig.store.id
+                ? { private_id: this.appConfig.store.id }
+                : undefined),
+            ...(remoteApp?.id ? { source_id: remoteApp.id } : undefined),
+        };
+        const logoIcon = appLogoIcon(this.appPath);
+        if (logoIcon) {
+            const icon = fs.readFileSync(logoIcon, { encoding: 'base64' });
+            body.logo_icon = icon;
+        }
+        /* eslint-enable camelcase */
+        let app = updateApp || {};
+        let appCreated = false;
+        if (!app.id) {
+            // May already have a dev instance
+            let existingDevApp;
+            try {
+                existingDevApp = await this.api.get({
+                    adminPath: `/apps/${this.appConfig.store.id}`,
+                });
+            }
+            catch (err) {
+                // noop
+            }
+            spinner.start(`Creating app...`);
+            if (existingDevApp) {
+                app = await this.handleRequestErrors(async () => this.api.put({ adminPath: `/apps/${existingDevApp.id}` }, { body }), () => spinner.fail('Error creating app'));
+            }
+            else {
+                app = await this.handleRequestErrors(async () => this.api.post({ adminPath: '/apps' }, { body }), () => spinner.fail('Error creating app'));
+                appCreated = true;
+            }
+        }
+        else if (app.id) {
+            spinner.start(`Updating app...`);
+            app = await this.handleRequestErrors(async () => this.api.put({ adminPath: `/apps/${app.id}` }, { body }), () => spinner.fail('Error updating app'));
+        }
+        if (app?.id) {
+            await writeRcFile(this.swellRcPath(), { id: app.id });
+            // if not failed, we want to display correct messaging
+            if (spinner.isSpinning) {
+                if (appCreated) {
+                    spinner.succeed('Development app created.');
+                    this.log();
+                }
+                else {
+                    spinner.stop();
+                }
+                this.log('App details');
+                spinner.succeed('app details');
+                if (logoIcon) {
+                    spinner.succeed('app logo');
+                }
+            }
+            this.log();
+            return app;
+        }
+        return {};
+    }
+    async handleRequestErrors(request, spinnerError) {
+        try {
+            const response = await request();
+            if (response?.status !== 200 && response?.errors) {
+                this.showErrors(response.errors, spinnerError);
+                this.error('API request failed');
+            }
+            return response;
+        }
+        catch (error) {
+            let jsonError;
+            try {
+                jsonError = JSON.parse(error.message);
+            }
+            catch {
+                // noop, likely JSON parse error
+            }
+            if (jsonError && jsonError.error) {
+                this.showErrors(jsonError, spinnerError);
+                this.error('API request failed');
+            }
+            throw error;
+        }
+    }
+    async init() {
+        await super.init();
+        this.app = this.initApp();
+        const klass = this.ctor;
+        const { flags } = await this.parse(klass);
+        if (klass.orientation) {
+            this.showOrientation(klass.orientation, flags);
+        }
+    }
+    async postConfig(configJson) {
+        if (!this.app) {
+            this.error('App is not defined');
+        }
+        this.debug('postConfig: configJson', configJson);
+        return this.api.post({ adminPath: `/apps/${this.app.id}/configs` }, { body: configJson });
+    }
+    async pushConfigFile(appConfig) {
+        const { localPath } = appConfig;
+        const spinner = ora();
+        let postData;
+        if (!localPath) {
+            throw new Error('Missing local config path');
+        }
+        // we don't want to treat the app logo asset as config file
+        // it is dealt with at the app level
+        if (isAppLogoIcon(localPath)) {
+            return;
+        }
+        const pathDesc = localPath.split('/').slice(-2).join('/');
+        spinner.start(`Pushing ${pathDesc}`);
+        try {
+            postData = await appConfig.postData();
+            if (!postData) {
+                spinner.stop();
+                return;
+            }
+        }
+        catch (error) {
+            if (error instanceof IgnoringFileError) {
+                spinner.fail(`Ignoring file: ${error.message} in ${localPath}`);
+                return;
+            }
+            if (error instanceof FunctionProcessingError) {
+                this.debug(error);
+                this.debug(error.originalError);
+                spinner.fail(`${error.message} ${error.originalError?.message?.toLowerCase()}`);
+                return;
+            }
+            spinner.fail(error.message);
+            throw error;
+        }
+        const result = await this.handleRequestErrors(async () => this.postConfig(postData), () => spinner.fail(`Error pushing ${pathDesc}`));
+        spinner.succeed(`Pushed ${pathDesc}`);
+        return result;
+    }
+    async removeConfig(config) {
+        const spinner = ora();
+        spinner.start(`Removing ${config.type} ${config.name}`);
+        const result = await this.handleRequestErrors(async () => this.deleteConfig(config.id), () => spinner.fail(`Error removing ${config.type} ${config.name}`));
+        spinner.warn(`Removed ${config.type} ${config.name}`);
+        return result;
+    }
+    showErrors(errors, spinnerError) {
+        const actualErrors = Object.keys(errors).filter((err) => Object.prototype.hasOwnProperty.call(errors, err));
+        if (spinnerError) {
+            spinnerError();
+        }
+        else {
+            this.logError(inflect('Error', actualErrors.length));
+        }
+        for (const err of actualErrors) {
+            // we need to display `id` instead of `private_id`
+            // developers don't have any knowledge of private ids
+            const displayErr = err === 'private_id' ? 'id' : err;
+            this.logError([
+                '  -',
+                `${displayErr}:`.toLowerCase().replace(/^error:/, ''),
+                errors[err].message,
+            ]
+                .filter(Boolean)
+                .join(' '));
+        }
+    }
+    async syncAppConfigs() {
+        const configsToPush = [];
+        const installed = [];
+        const removed = [];
+        for (const { configFile, configType } of allConfigFilesPaths(this.appPath)) {
+            // skip logo icon as it is dealt with at the app level
+            if (isAppLogoIcon(configFile)) {
+                continue;
+            }
+            const appConfig = appConfigFromFile(configFile, configType);
+            configsToPush.push(appConfig);
+        }
+        const batches = batchAppConfigsByType(configsToPush);
+        for (const batch of batches) {
+            this.log(style.appConfigName(batch.label));
+            // eslint-disable-next-line no-await-in-loop
+            for (const appConfig of batch.configs) {
+                const installedConfig = await this.pushConfigFile(appConfig);
+                if (installedConfig)
+                    installed.push(installedConfig.id);
+            }
+            this.log();
+        }
+        // pull the app again after the latest push
+        // this allows us to get the latest configs updates that the remote app
+        // might have done
+        this.app = await this.getAppWithConfig(this.app.id);
+        this.debugJson('syncAppConfigs: app', this.app);
+        // if the remote app has configs that are not in the local app, we want to
+        // remove them
+        for (const config of this.app?.configs || []) {
+            const appConfig = config;
+            if (!appConfig.localPath) {
+                // eslint-disable-next-line no-await-in-loop
+                await this.removeConfig(appConfig);
+                removed.push(appConfig.id);
+            }
+        }
+        return { installed, removed };
+    }
+    /**
+     * Reads the .swellrc file and sets up the remote app configuration.
+     *
+     * @returns App
+     */
+    initApp() {
+        let remoteApp = {};
+        try {
+            this.debug('initApp: swellRcPath', this.swellRcPath());
+            remoteApp = readRcFile(this.swellRcPath());
+            this.debug('initApp: remoteApp', remoteApp);
+        }
+        catch (error) {
+            // if the file doesn't exist, we don't want to throw an error as we might
+            // want to create it later.
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        if (this.appConfig.get('id')) {
+            // use the same formula as the backend api
+            // eslint-disable-next-line camelcase
+            remoteApp.private_id = toAppId(this.appConfig.get('id'));
+        }
+        return remoteApp;
+    }
+    showOrientation(orientation, flags) {
+        const orientationOutput = [];
+        const currentStore = swellConfig.getDefaultStore();
+        const { env, store } = flags;
+        if (store) {
+            orientationOutput.push(`[store] ${style.storeId(store)}`);
+        }
+        else if (currentStore) {
+            orientationOutput.push(`[store] ${style.storeId(currentStore)}`);
+        }
+        const outputEnv = env || orientation.env;
+        if (outputEnv) {
+            const outputStyle = outputEnv === 'live' ? style.appEnvLive : style.appEnv;
+            orientationOutput.push(`[env] ${outputStyle(outputEnv)}`);
+        }
+        this.log(orientationOutput.join(' '));
+        this.log();
+    }
+    async getVersions(version) {
+        const versionsResponse = await this.api.get({ adminPath: `/apps/${this.app.id}/versions` }, {
+            query: {
+                limit: 1000,
+                sort: 'version desc',
+                ...(version ? { version } : undefined),
+            },
+        });
+        this.debugJson('getApp: versionsResponse', versionsResponse);
+        return versionsResponse.results || [];
+    }
+    swellRcPath() {
+        return path.join(this.appPath, '.swellrc');
+    }
+}

package/dist/swell-command.d.ts

@@ -0,0 +1,21 @@
+import { Command, Config } from '@oclif/core';
+import Api from './lib/api.js';
+/**
+ * A base class for Swell CLI commands.
+ *
+ * This class extends the oclif Command class and adds:
+ *
+ * - an Api instance
+ * - logging methods
+ * - a catch method to handle errors
+ */
+export declare abstract class SwellCommand extends Command {
+    static examples: Command.Example[];
+    api: Api;
+    requiresAuth: boolean;
+    constructor(argv: string[], config: Config);
+    catch(error: any): Promise<void>;
+    debugJson(...args: any[]): void;
+    logError(message: string): void;
+    logSuccess(message: string): void;
+}

package/dist/swell-command.js

@@ -0,0 +1,43 @@
+import git from '@npmcli/git';
+import { Command } from '@oclif/core';
+import { FetchError } from 'node-fetch';
+import Api from './lib/api.js';
+import style from './lib/style.js';
+const { GitUnknownError } = git.errors;
+/**
+ * A base class for Swell CLI commands.
+ *
+ * This class extends the oclif Command class and adds:
+ *
+ * - an Api instance
+ * - logging methods
+ * - a catch method to handle errors
+ */
+export class SwellCommand extends Command {
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    api;
+    requiresAuth = true;
+    constructor(argv, config) {
+        super(argv, config);
+        this.api = new Api();
+    }
+    async catch(error) {
+        if (error instanceof GitUnknownError) {
+            this.error(style.error(`git: ${error.stderr || error.stdout || error.message}`));
+        }
+        else if (error instanceof FetchError) {
+            this.error(`Could not connect to Swell API. Please try again later: ${error.message}`);
+        }
+        throw error;
+    }
+    debugJson(...args) {
+        const stringified = args.map((arg) => typeof arg === 'string' ? arg : JSON.stringify(arg, null, 4));
+        this.debug(...stringified);
+    }
+    logError(message) {
+        this.log(`${style.error(message)}`);
+    }
+    logSuccess(message) {
+        this.log(`${style.success(message)}`);
+    }
+}