@swell/cli 1.0.2 → 2.0.1-alpha.0

package/dist/lib/swell-function-wrapper.js

@@ -0,0 +1,302 @@
+"use strict";
+const origialConsoleLog = console.log;
+addEventListener('fetch', (event) => {
+    event.respondWith(handleRequest(event.request, event.env, event));
+});
+async function handleRequest(originalRequest, _env, context) {
+    const req = new SwellRequest(originalRequest, context);
+    await req.initialize();
+    let response;
+    try {
+        response = await executeModuleHandler(req, context);
+    }
+    catch (err) {
+        // Log the error for Swell
+        console.error(err.stack);
+        response = new SwellResponse({ error: err.message }, { status: err.status || 500 });
+    }
+    // Create a response by default if one is not returned
+    if (!(response instanceof Response)) {
+        response = new SwellResponse(response);
+    }
+    // Send logs back to Swell
+    context.waitUntil(req.ingestLogs(response));
+    return response;
+}
+/**
+ * Invokes one of the function types that are available.
+ *
+ * Type-1: Named export function handlers
+ * ```
+ * export function post (req) {
+ *
+ * }
+ * ```
+ *
+ * Important note:
+ * - `delete` func cannot be implemented in Type-1 since it's a reserved name. So, consider using Type-3.
+ *
+ * Type-2: Default export function handlers
+ * ```
+ * export default function (req) {
+ *
+ * }
+ * ```
+ *
+ * Type-3: Default object with named function handlers
+ * ```
+ * export default {
+ *   delete(req) {
+ *
+ *   },
+ *   post(req) {
+ *
+ *   },
+ * }
+ * ```
+ *
+ * @param {SwellRequest} req
+ * @param {Event} context
+ */
+async function executeModuleHandler(req, context) {
+    const method = req.method.toLowerCase();
+    const defaults = moduleExports.default;
+    if (moduleExports[method]) {
+        return moduleExports[method](req, context);
+    }
+    else if (defaults) {
+        if (typeof defaults === 'function') {
+            return defaults(req, context);
+        }
+        else if (defaults[method]) {
+            return defaults[method](req, context);
+        }
+    }
+    throw new Error(`Function does not export a method to handle ${method.toUpperCase()} requests`);
+}
+class SwellRequest {
+    constructor(req, context) {
+        this.originalRequest = req;
+        this.assignRequestProps(req);
+        // Set environment specific variables
+        this.context = context;
+        this.appId = req.headers.get('Swell-App-Id');
+        this.storeId = req.headers.get('Swell-Store-Id');
+        this.accessToken = req.headers.get('Swell-Access-Token');
+        this.publicKey = req.headers.get('Swell-Public-Key');
+        this.store = this.parseJson(req.headers.get('Swell-Store-Details'));
+        this.session = this.parseJson(req.headers.get('Swell-Session'));
+        this.logParams = this.parseJson(req.headers.get('Swell-Request-Log'));
+        this.apiHost = req.headers.get('Swell-API-Host') || 'https://api.schema.io';
+        this.id = req.headers.get('Swell-Request-ID') || this.logParams?.req_id;
+        // Swell client
+        this.swell = new SwellAPI(this, context);
+        // URL of the original request
+        this.url;
+        // Original body of the request, JSON if applicable
+        this.body = {};
+        // URL query parameters as an object
+        this.query = {};
+        // Combined object of body and query parameters
+        this.data = {};
+        // Internal logs
+        this._logs = [];
+    }
+    assignRequestProps(req) {
+        ['ur', 'method', 'headers', 'referrer', 'credentials'].forEach((prop) => {
+            this[prop] = req[prop];
+        });
+    }
+    async initialize() {
+        this.body = await this.originalRequest.text();
+        try {
+            this.data = JSON.parse(this.body);
+            this.body = { ...this.data };
+        }
+        catch (err) {
+            this.data = {};
+        }
+        this.url = new URL(this.originalRequest.url);
+        // Convert the query parameters to an object
+        this.url.searchParams.forEach((value, key) => {
+            this.query[key] = value;
+            this.data[key] = value;
+        });
+        // Bind the console methods to the request
+        console.log = this.log.bind(this, 'info');
+        console.info = this.log.bind(this, 'info');
+        console.debug = this.log.bind(this, 'debug');
+        console.warn = this.log.bind(this, 'warn');
+        console.error = this.log.bind(this, 'error');
+    }
+    parseJson(input) {
+        try {
+            return JSON.parse(input);
+        }
+        catch (err) {
+            return {};
+        }
+    }
+    log(level, ...line) {
+        origialConsoleLog(...line);
+        this._logs.push({
+            date: Date.now(),
+            line: line.map((l) => JSON.stringify(l)),
+            ...(level !== 'info' ? { level } : {}),
+        });
+    }
+    async ingestLogs(response) {
+        if (!this.logParams) {
+            return;
+        }
+        if (this.logParams.$start) {
+            this.logParams.time = Date.now() - this.logParams.$start;
+            delete this.logParams.$start;
+        }
+        const result = await this.swell.post('/:logs', {
+            $ingest_function_logs: {
+                params: {
+                    ...this.logParams,
+                    message: {
+                        ...this.logParams?.message,
+                        logs: this._logs,
+                        status: response.status,
+                    },
+                },
+            },
+        });
+        if (!result?.success) {
+            console.error('Error ingesting logs', result);
+        }
+    }
+}
+class SwellAPI {
+    constructor(req, context) {
+        this.request = req;
+        this.baseUrl = req.apiHost;
+        this.basicAuth = `${req.storeId}:${req.accessToken}`;
+        this.context = context;
+    }
+    toBase64(inputString) {
+        const utf8Bytes = new TextEncoder().encode(inputString);
+        let base64String = '';
+        for (let i = 0; i < utf8Bytes.length; i += 3) {
+            const chunk = utf8Bytes.slice(i, i + 3);
+            base64String += btoa(String.fromCharCode(...chunk));
+        }
+        return base64String;
+    }
+    stringifyQuery(queryObject, prefix) {
+        const result = [];
+        for (const [key, value] of Object.entries(queryObject)) {
+            const prefixKey = prefix ? `${prefix}[${key}]` : key;
+            const isObject = value !== null && typeof value === 'object';
+            const encodedResult = isObject
+                ? this.stringifyQuery(value, prefixKey)
+                : `${encodeURIComponent(prefixKey)}=${encodeURIComponent(value)}`;
+            result.push(encodedResult);
+        }
+        return result.join('&');
+    }
+    async makeRequest(method, url, data) {
+        const requestOptions = {
+            method,
+            headers: {
+                Authorization: `Basic ${this.toBase64(this.basicAuth)}`,
+                'User-Agent': 'swell-functions/1.0',
+                'Content-Type': 'application/json',
+                ...(this.request.id ? { 'Swell-Request-ID': this.request.id } : {}),
+            },
+        };
+        let query = '';
+        if (data) {
+            try {
+                if (method === 'GET') {
+                    query = `?${this.stringifyQuery(data)}`;
+                }
+                else {
+                    requestOptions.body = JSON.stringify(data);
+                    requestOptions.headers['Content-Length'] = requestOptions.body.length;
+                }
+            }
+            catch {
+                throw new Error(`Error serializing data: ${data}`);
+            }
+        }
+        const endpointUrl = String(url).startsWith('/') ? url.substring(1) : url;
+        const response = await fetch(`${this.baseUrl}/${endpointUrl}${query}`, requestOptions);
+        const responseText = await response.text();
+        let result;
+        try {
+            result = JSON.parse(responseText);
+        }
+        catch {
+            result = String(responseText || '').trim();
+        }
+        if (response.status > 299) {
+            throw new SwellError(result, {
+                status: response.status,
+                method,
+                endpointUrl,
+            });
+        }
+        else if (method !== 'GET' && result?.errors) {
+            throw new SwellError(result.errors, { status: 400, method, endpointUrl });
+        }
+        return result;
+    }
+    async get(url, query) {
+        return this.makeRequest('GET', url, query);
+    }
+    async put(url, data) {
+        return this.makeRequest('PUT', url, data);
+    }
+    async post(url, data) {
+        return this.makeRequest('POST', url, data);
+    }
+    async delete(url, data) {
+        return this.makeRequest('DELETE', url, data);
+    }
+    async settings(id = this.request.appId) {
+        return this.makeRequest('GET', `/settings/${id}`);
+    }
+}
+class SwellError extends Error {
+    constructor(message, options = {}) {
+        let formattedMessage;
+        if (typeof message === 'string') {
+            formattedMessage = message;
+        }
+        else {
+            formattedMessage = JSON.stringify(message, null, 2);
+        }
+        if (options.method && options.endpointUrl) {
+            formattedMessage = `${options.method} /${options.endpointUrl}\n${formattedMessage}`;
+        }
+        super(formattedMessage);
+        this.name = 'SwellError';
+        this.status = options.status || 500;
+    }
+}
+class SwellResponse extends Response {
+    constructor(data, options = {}) {
+        const resultHeaders = {};
+        let result;
+        if (typeof data === 'string') {
+            result = data;
+            resultHeaders['Content-Type'] = 'text/plain;charset=UTF-8';
+        }
+        else if (data !== undefined) {
+            result = JSON.stringify(data, null, 2);
+            resultHeaders['Content-Type'] = 'application/json;charset=UTF-8';
+        }
+        super(result?.toString?.('utf-8'), {
+            status: 200,
+            ...options,
+            headers: {
+                ...resultHeaders,
+                ...(options.headers || {}),
+            },
+        });
+    }
+}

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

@@ -0,0 +1,36 @@
+import { AppCommand } from './app-command.js';
+import { App, AppConfig, AppVersion } from './lib/apps/index.js';
+/**
+ * Extends the AppCommand with methods that ease managing remote apps and
+ * configurations.
+ */
+export declare abstract class RemoteAppCommand extends AppCommand {
+    static orientation: AppCommandOrientation;
+    app: App;
+    dashboardUrl(flags?: {
+        [flag: string]: any;
+    }, storeId?: string): string;
+    protected deleteConfig(configId: string): Promise<any>;
+    protected getApp(id?: string): Promise<App>;
+    protected getAppWithConfig(id?: string, errorNotFound?: boolean): Promise<App>;
+    protected getCreateUpdateApp(updateApp?: App): Promise<App>;
+    protected handleRequestErrors(request: () => any, spinnerError?: () => void): Promise<any>;
+    init(): Promise<void>;
+    protected postConfig(configJson: any): Promise<any>;
+    protected pushConfigFile(appConfig: AppConfig): Promise<any>;
+    protected removeConfig(config: AppConfig): Promise<any>;
+    protected showErrors(errors: any, spinnerError?: () => void): void;
+    protected syncAppConfigs(): Promise<{
+        installed: string[];
+        removed: string[];
+    }>;
+    /**
+     * Reads the .swellrc file and sets up the remote app configuration.
+     *
+     * @returns App
+     */
+    private initApp;
+    private showOrientation;
+    protected getVersions(version?: string | undefined | null): Promise<AppVersion[]>;
+    protected swellRcPath(): string;
+}

package/dist/remote-app-command.js

@@ -0,0 +1,367 @@
+import { inflect } from 'inflection';
+import snakeCase from 'lodash/snakeCase.js';
+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 { 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 defined 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) {
+                app = await this.getAppWithConfig(swellId);
+            }
+        }
+        return app;
+    }
+    async getCreateUpdateApp(updateApp) {
+        const spinner = ora();
+        const remoteApp = await readRcFile(this.swellRcPath());
+        /* 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,
+            private_id: this.app?.private_id,
+            ...(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
+            const existingDevApp = await this.api.get({
+                adminPath: `/apps/${this.app?.private_id}`,
+            });
+            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();
+        }
+        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')) {
+            // eslint-disable-next-line camelcase
+            remoteApp.private_id = snakeCase(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');
+    }
+}