@swell/cli 1.0.2 → 2.0.1-alpha.0

package/dist/lib/sessions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get the session id for the passed in store. If the session is not found,
+ * open the browser to login and return the session id.
+ *
+ * @param storeId - The store to get the session id for
+ * @returns A promise that resolves to the session id
+ */
+declare function getSessionIdOrLoginInBrowser(storeId?: string | undefined): Promise<string[]>;
+export { getSessionIdOrLoginInBrowser };

package/dist/lib/sessions.js

@@ -0,0 +1,110 @@
+import { ux } from '@oclif/core';
+import * as http from 'node:http';
+import open from 'open';
+import { getLoginHost } from './constants.js';
+import style from './style.js';
+/**
+ * Get the session id for the passed in store. If the session is not found,
+ * open the browser to login and return the session id.
+ *
+ * @param storeId - The store to get the session id for
+ * @returns A promise that resolves to the session id
+ */
+function getSessionIdOrLoginInBrowser(storeId) {
+    return new Promise((resolve, _reject) => {
+        const onSessionId = (sessionId, storeId) => resolve([sessionId, storeId]);
+        createServer(onSessionId, storeId);
+    });
+}
+function createServer(onSessionId, storeId) {
+    // the spinner is used to show progress while waiting for the browser
+    const spinner = ux.action;
+    serverForLogin({
+        storeId,
+        onPost(req) {
+            // we received the session id from the browser so we can move on
+            const sessionId = req.headers['x-session'];
+            const storeId = req.headers['x-store'];
+            if (sessionId) {
+                spinner.stop('Browser authentication successful');
+                onSessionId(sessionId, storeId);
+            }
+        },
+        async onStart(loginUrl) {
+            spinner.start([
+                "Open this link if your browser doesn't launch it automatically:",
+                `${style.link(loginUrl)}`,
+            ].join(' '));
+            await open(loginUrl);
+        },
+    });
+}
+/**
+ * Start a local HTTP server to handle the POST and GET requests from the
+ * browser login flow.
+ *
+ * The POST request will contain the session id in the `x-session` header.
+ *
+ * The GET request will be used to close the connection after the login flow
+ * is complete.
+ *
+ * @param onSessionId - A callback to run when the session id is received
+ * from the browser
+ * @returns void
+ */
+function serverForLogin({ storeId, onPost, onStart, }) {
+    // flag to track if the POST and GET requests have been handled
+    // we only want to handle them once
+    let postHandled = false;
+    let getHandled = false;
+    // Create the HTTP server
+    const server = http.createServer(async (req, res) => {
+        // Set CORS headers
+        res.setHeader('Access-Control-Allow-Origin', getLoginHost(storeId));
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Origin, Content-Type, x-session, x-store');
+        if (req.method === 'POST' && !postHandled) {
+            onPost(req);
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('POST request handled');
+            postHandled = true;
+        }
+        else if (req.method === 'GET' && !getHandled) {
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            // Close the HTTP connection to prevent `server.close()` from hanging
+            res.setHeader('connection', 'close');
+            // The browser will show this message in the window
+            res.end('Authentication successful, you can close this window and return to the terminal.');
+            getHandled = true;
+        }
+        else if (req.method === 'OPTIONS') {
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('ok');
+        }
+        else {
+            // Return 404 for subsequent requests or other request types
+            res.statusCode = 404;
+            res.end('Not Found');
+        }
+    });
+    server.listen(0, '127.0.0.1', async () => {
+        const serverAddr = server.address();
+        // the port will be dynamically assigned, one of the available ports
+        const localServerUrl = Buffer.from(`http://${serverAddr.address}:${serverAddr.port}/`).toString('base64');
+        const loginUrl = `${getLoginHost(storeId)}/admin?cli=${localServerUrl}`;
+        onStart(loginUrl);
+    });
+    const closeInterval = setInterval(() => {
+        if (postHandled) {
+            server.close(() => {
+                clearInterval(closeInterval);
+            });
+            server.emit('close');
+            server.removeAllListeners('close');
+        }
+    }, 100);
+}
+export { getSessionIdOrLoginInBrowser };

package/dist/lib/stores.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Builds a list of stores while also highlighting the current store.
+ *
+ * @example <caption>Example output:</caption>
+ *
+ * >   Stores you are logged in to:
+ * >
+ * >       - Test Store, test
+ * >       - Another Test, another-test (current)
+ *
+ * @param stores - The stores to build the display for
+ * @param currentStoreId - The ID of the default store
+ * @returns A list of stores ready to display.
+ */
+declare function showStores(stores: Store[], currentStoreId: string): string;
+/**
+ * Select the store to login to from a CLI prompt.
+ *
+ * By default it will only show stores for which we don't already have a
+ * session id. If `force` is true, show all stores to pull the session id
+ * again.
+ *
+ * @param currentStoreId - The ID of the default store
+ * @param authorizations - The authorizations for the current user
+ * @param force - Whether to show all stores or not
+ *
+ * @returns The store ID to login to
+ */
+declare function selectStoreId({ authorizations, currentStoreId, force, }: {
+    authorizations: UserAuthorization[];
+    currentStoreId: string;
+    force: boolean;
+}): Promise<any>;
+/**
+ * Select the store to switch to from a CLI prompt from the list of
+ * already logged in stores.
+ *
+ * @returns The store ID to switch to
+ * @throws CLIError - If there are no stores to switch to
+ */
+declare function selectLoggedInStoreId(message?: string): Promise<string>;
+/**
+ * Select an environment.
+ *
+ * @throws CLIError - If there are no stores to switch to
+ */
+declare function selectEnvironmentId(message?: string): Promise<string>;
+/**
+ * Ask the user if they want to make the given store id the default store.
+ *
+ * If there is no current store id, it will always be set as the default
+ * without asking.
+ *
+ * @param currentStoreId - The ID of the default store
+ * @param storeId - The ID of the store to set as the default
+ *
+ * @returns void
+ */
+declare function modifyDefaultStore({ currentStoreId, storeId, }: {
+    currentStoreId: string;
+    storeId: string;
+}): Promise<void>;
+export { modifyDefaultStore, selectLoggedInStoreId, selectStoreId, selectEnvironmentId, showStores, };

package/dist/lib/stores.js

@@ -0,0 +1,173 @@
+import { Separator, confirm, select } from '@inquirer/prompts';
+import { CLIError } from '@oclif/errors';
+import config from './config.js';
+import style from './style.js';
+/**
+ * Builds a list of stores while also highlighting the current store.
+ *
+ * @example <caption>Example output:</caption>
+ *
+ * >   Stores you are logged in to:
+ * >
+ * >       - Test Store, test
+ * >       - Another Test, another-test (current)
+ *
+ * @param stores - The stores to build the display for
+ * @param currentStoreId - The ID of the default store
+ * @returns A list of stores ready to display.
+ */
+function showStores(stores, currentStoreId) {
+    if (stores.length === 0) {
+        throw new CLIError('You are not logged in to any store.');
+    }
+    function currentStoreLabel(store) {
+        if (stores.length === 1 || store.storeId !== currentStoreId) {
+            return '';
+        }
+        return `(${style.basicHighlight('current')})`;
+    }
+    let storesOutput = '';
+    for (const [index, store] of stores.entries()) {
+        // builds each line of the output, for every store
+        // e.g. - Another Test, another-test (current)
+        storesOutput += [
+            `- ${store.name},`,
+            `${style.storeId(store.storeId)}`,
+            `${style.storeId(currentStoreLabel(store))}`,
+            // don't add a newline on the last line:
+            index === stores.length - 1 ? null : '\n',
+        ]
+            .filter(Boolean)
+            .join(' ');
+    }
+    return storesOutput;
+}
+/**
+ * Select the store to login to from a CLI prompt.
+ *
+ * By default it will only show stores for which we don't already have a
+ * session id. If `force` is true, show all stores to pull the session id
+ * again.
+ *
+ * @param currentStoreId - The ID of the default store
+ * @param authorizations - The authorizations for the current user
+ * @param force - Whether to show all stores or not
+ *
+ * @returns The store ID to login to
+ */
+async function selectStoreId({ authorizations, currentStoreId, force = false, }) {
+    let selectStoreChoices;
+    let selectedStoreId;
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (force) {
+        // show all stores
+        selectStoreChoices = authorizations.map((auth) => ({
+            name: auth.client_name +
+                (auth.client_id === currentStoreId
+                    ? ` (${style.basicHighlight('current')})`
+                    : ''),
+            value: auth.client_id,
+        }));
+    }
+    else {
+        // only show the stores for which we don't already have a session id
+        // eslint-disable-next-line unicorn/no-array-reduce
+        selectStoreChoices = authorizations.reduce((acc, auth) => {
+            if (!config.getSessionId(auth.client_id)) {
+                acc.push({
+                    name: auth.client_name,
+                    value: auth.client_id,
+                });
+            }
+            return acc;
+        }, []);
+    }
+    // if more than one option, show the select options, otherwise just return
+    // the available one
+    if (selectStoreChoices.length > 1) {
+        selectedStoreId = await select({
+            choices: selectStoreChoices,
+            message: 'Which store do you want to login to on the CLI?',
+        });
+    }
+    else if (selectStoreChoices.length === 1) {
+        selectedStoreId = selectStoreChoices[0].value;
+    }
+    // we can also return `undefined` when we already have sessions for all
+    // stores: no force and no selectStoreChoices
+    return selectedStoreId;
+}
+/**
+ * Select the store to switch to from a CLI prompt from the list of
+ * already logged in stores.
+ *
+ * @returns The store ID to switch to
+ * @throws CLIError - If there are no stores to switch to
+ */
+async function selectLoggedInStoreId(message) {
+    const currentStoreId = config.getDefaultStore();
+    const loggedInStores = config.get('stores') || [];
+    if (loggedInStores.length === 0) {
+        throw new CLIError(`You are not logged in. Run ${style.command('swell login')} to continue.`);
+    }
+    const selectStoreChoices = loggedInStores.map((store) => ({
+        name: `${store.name} (${store.storeId})` +
+            (store.storeId === currentStoreId
+                ? ` [${style.basicHighlight('current')}]`
+                : ''),
+        value: store.storeId,
+    }));
+    return select({
+        choices: [
+            ...selectStoreChoices,
+            new Separator(),
+            { name: 'Login to another account', value: '' },
+        ],
+        message: message || 'Which store do you want to switch to?',
+        pageSize: 25,
+        loop: false,
+    });
+}
+/**
+ * Select an environment.
+ *
+ * @throws CLIError - If there are no stores to switch to
+ */
+async function selectEnvironmentId(message) {
+    return select({
+        choices: [
+            {
+                name: '[live]',
+                value: '',
+            },
+            {
+                name: '[test]',
+                value: 'test',
+            },
+        ],
+        message: message || 'Which envoronment?',
+    });
+}
+/**
+ * Ask the user if they want to make the given store id the default store.
+ *
+ * If there is no current store id, it will always be set as the default
+ * without asking.
+ *
+ * @param currentStoreId - The ID of the default store
+ * @param storeId - The ID of the store to set as the default
+ *
+ * @returns void
+ */
+async function modifyDefaultStore({ currentStoreId, storeId, }) {
+    let modifyDefault = false;
+    if (currentStoreId && currentStoreId !== storeId) {
+        modifyDefault = await confirm({
+            message: `Do you want to make ${style.storeId(storeId)} your default store?`,
+        });
+    }
+    if (!currentStoreId || modifyDefault) {
+        config.setDefaultStore(storeId);
+    }
+}
+export { modifyDefaultStore, selectLoggedInStoreId, selectStoreId, selectEnvironmentId, showStores, };

package/dist/lib/style.d.ts

@@ -0,0 +1,24 @@
+declare const _default: {
+    basicHighlight: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    link: import("chalk").ChalkInstance;
+    path: import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance;
+    command: import("chalk").ChalkInstance;
+    storeId: import("chalk").ChalkInstance;
+    currentUser: import("chalk").ChalkInstance;
+    appEnvLive: import("chalk").ChalkInstance;
+    appEnv: import("chalk").ChalkInstance;
+    appConfigName: import("chalk").ChalkInstance;
+    appConfigValue: import("chalk").ChalkInstance;
+    logDate: import("chalk").ChalkInstance;
+    logStatus: import("chalk").ChalkInstance;
+    logMethod: import("chalk").ChalkInstance;
+    logApp: import("chalk").ChalkInstance;
+    funcInfo: import("chalk").ChalkInstance;
+    funcDebug: import("chalk").ChalkInstance;
+    funcWarn: import("chalk").ChalkInstance;
+    funcError: import("chalk").ChalkInstance;
+};
+export default _default;

package/dist/lib/style.js

@@ -0,0 +1,29 @@
+/* eslint-disable perfectionist/sort-objects */
+import chalk from 'chalk';
+export default {
+    basicHighlight: chalk.bold,
+    error: chalk.red,
+    success: chalk.green,
+    link: chalk.blueBright.underline,
+    path: chalk.underline,
+    dim: chalk.dim,
+    // styles for consistent output of some elements
+    command: chalk.magenta.bold,
+    storeId: chalk.yellow,
+    currentUser: chalk.blueBright.underline,
+    // apps
+    appEnvLive: chalk.magenta,
+    appEnv: chalk.yellow,
+    appConfigName: chalk.yellow,
+    appConfigValue: chalk.green,
+    // logs
+    logDate: chalk.cyan,
+    logStatus: chalk.yellow,
+    logMethod: chalk.green,
+    logApp: chalk.magenta,
+    // function logs
+    funcInfo: chalk.white,
+    funcDebug: chalk.cyan,
+    funcWarn: chalk.yellow,
+    funcError: chalk.red,
+};

package/dist/lib/swell-function-wrapper.d.ts

@@ -0,0 +1,88 @@
+declare function handleRequest(originalRequest: any, _env: any, context: any): Promise<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
+ */
+declare function executeModuleHandler(req: SwellRequest, context: Event): Promise<any>;
+declare const origialConsoleLog: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+declare class SwellRequest {
+    constructor(req: any, context: any);
+    originalRequest: any;
+    context: any;
+    appId: any;
+    storeId: any;
+    accessToken: any;
+    publicKey: any;
+    store: any;
+    session: any;
+    logParams: any;
+    apiHost: any;
+    id: any;
+    swell: SwellAPI;
+    body: {};
+    query: {};
+    data: {};
+    _logs: any[];
+    assignRequestProps(req: any): void;
+    initialize(): Promise<void>;
+    url: URL | undefined;
+    parseJson(input: any): any;
+    log(level: any, ...line: any[]): void;
+    ingestLogs(response: any): Promise<void>;
+}
+declare class SwellAPI {
+    constructor(req: any, context: any);
+    request: any;
+    baseUrl: any;
+    basicAuth: string;
+    context: any;
+    toBase64(inputString: any): string;
+    stringifyQuery(queryObject: any, prefix: any): any;
+    makeRequest(method: any, url: any, data: any): Promise<any>;
+    get(url: any, query: any): Promise<any>;
+    put(url: any, data: any): Promise<any>;
+    post(url: any, data: any): Promise<any>;
+    delete(url: any, data: any): Promise<any>;
+    settings(id?: any): Promise<any>;
+}
+declare class SwellError extends Error {
+    constructor(message: any, options?: {});
+    status: any;
+}
+declare class SwellResponse extends Response {
+    constructor(data: any, options?: {});
+}