@swell/cli 1.0.2 → 2.0.1-alpha.10

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;
+}