@swell/cli 1.0.2 → 2.0.1-alpha.2

package/dist/commands/create/notification.d.ts

@@ -0,0 +1,25 @@
+import { CreateCommand } from '../../create-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+export default class CreateNotification extends CreateCommand {
+    static args: {
+        model: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        subject: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        event: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        admin: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        once: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    createType: ConfigType;
+    run(): Promise<void>;
+    private writeNotificationFile;
+}

package/dist/commands/create/notification.js

@@ -0,0 +1,170 @@
+import { input, select } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { singularize, capitalize } from 'inflection';
+import { CreateCommand } from '../../create-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+import { toFileName, toNotificationLabel } from '../../lib/create/index.js';
+export default class CreateNotification extends CreateCommand {
+    static args = {
+        model: Args.string({
+            description: 'data model to trigger the notification by',
+        }),
+        name: Args.string({
+            description: 'internal name for the notification',
+        }),
+    };
+    static description = `This command assists in generating notifications configuration files. This CLI command will prompt for values when flags are not present.`;
+    static examples = [
+        {
+            command: 'swell create notification',
+            description: 'Create notification configuration interactively.',
+        },
+        {
+            command: 'swell create notification subscriptions confirmed --event subscription.created --once --s "Your subscription has been confirmed" -d "Send a confirmation email when subscription is created"',
+            description: 'Specify the model, name, event, subject, and description.',
+        },
+        {
+            command: 'swell create notification orders paid --event paid"',
+            description: 'Specify the event to trigger the notification.',
+        },
+    ];
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'notification description',
+        }),
+        subject: Flags.string({
+            char: 's',
+            default: '',
+            description: 'notification email subject',
+        }),
+        event: Flags.string({
+            char: 'e',
+            default: '',
+            description: 'data model event to trigger the notification event, i.e. created',
+        }),
+        admin: Flags.boolean({
+            char: 'a',
+            description: 'indicate when the notification is sent to store admins only',
+        }),
+        once: Flags.boolean({
+            char: 'o',
+            description: 'indicate the notification should be sent only once when conditions are met, instead of repeating',
+        }),
+        overwrite: Flags.boolean({
+            description: 'overwrite existing notification configuration file',
+        }),
+    };
+    static summary = 'Initialize notification files and configuration with properties in the notifications folder.';
+    createType = ConfigType.NOTIFICATION;
+    async run() {
+        const { args, flags } = await this.parse(CreateNotification);
+        if (args.model && args.name) {
+            await this.writeNotificationFile({
+                admin: flags.admin,
+                description: flags.description,
+                event: flags.event,
+                model: args.model,
+                name: `${singularize(args.model)}-${args.name.replace(singularize(args.model), '')}`,
+                subject: flags.subject,
+                once: flags.once,
+            }, false);
+        }
+        else {
+            let admin = flags.admin;
+            if (admin === undefined) {
+                const choice = await await select({
+                    message: 'Who will be notified?',
+                    choices: [
+                        { name: 'Admins', value: 'admin' },
+                        { name: 'Customers', value: 'customer' },
+                    ],
+                });
+                if (choice === 'admin') {
+                    admin = true;
+                }
+            }
+            const collections = await this.getCollectionOptions();
+            const model = await select({
+                message: 'Which model will trigger the notification?',
+                choices: [
+                    ...collections.map((collectionName) => ({
+                        name: collectionName,
+                        value: collectionName,
+                    })),
+                ],
+                pageSize: 25,
+                loop: false,
+            });
+            const event = await input({
+                message: 'Event to trigger the notification',
+                default: 'created',
+            });
+            const answers = {
+                name: await input({
+                    message: 'Name of the notification',
+                    default: `${singularize(model)}-${event}`,
+                }),
+                subject: await input({
+                    message: 'Subject of the notification email',
+                    default: `Something happened with ${model}`,
+                }),
+                description: await input({
+                    message: 'Describe what the notification does',
+                    default: `Notify ${admin ? 'admin' : 'customer'} when ${singularize(model)}...`,
+                }),
+                once: await select({
+                    message: 'When should we send this notification?',
+                    choices: [
+                        {
+                            name: 'Every time conditions are met',
+                            value: false,
+                        },
+                        {
+                            name: 'Only the first time conditions are met',
+                            value: true,
+                        },
+                    ],
+                }),
+            };
+            const { description, name, subject, once } = answers;
+            await this.writeNotificationFile({ admin, description, event, model, name, subject, once }, false);
+        }
+    }
+    async writeNotificationFile({ admin, description, event, model, name, subject, once, }, overwrite) {
+        const label = [name].map((val) => capitalize(val).trim()).join(' ');
+        const fileName = toFileName(label);
+        const noteLabel = toNotificationLabel(name);
+        const fileBody = {
+            collection: model,
+            label: noteLabel,
+            subject: subject || `${noteLabel}...`,
+            event: event || 'created',
+            conditions: {},
+            method: 'email',
+        };
+        fileBody.description = description;
+        if (admin) {
+            fileBody.admin = true;
+        }
+        else {
+            fileBody.contact = 'account.email';
+        }
+        // Note since we are using events, we don't need 'new' option
+        if (!once) {
+            fileBody.repeat = true;
+        }
+        fileBody.query = {
+            expand: [],
+        };
+        fileBody.sample = {};
+        const jsonCreated = await this.createFile({
+            fileBody,
+            fileName,
+        }, overwrite);
+        if (jsonCreated) {
+            await this.createFile({ extension: 'tpl', fileBody: '\n', fileName }, overwrite, false);
+        }
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '@oclif/core';
+import { SwellCommand } from '../swell-command.js';
+export default class Login extends SwellCommand {
+    static description: string;
+    static flags: {
+        store: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    constructor(argv: string[], config: Config);
+    run(): Promise<void>;
+    /**
+     * Use the /user/switch API request to either get the session id for the
+     * current store or create a session id for the given store id.
+     *
+     * @param sessionId - The session id for the current store
+     * @param storeId - The store id to get the session id for
+     *
+     * @returns void
+     */
+    private getAndSetStoreConfig;
+}

package/dist/commands/login.js

@@ -0,0 +1,77 @@
+import { Flags } from '@oclif/core';
+import config from '../lib/config.js';
+import { getSessionIdOrLoginInBrowser } from '../lib/sessions.js';
+import { modifyDefaultStore } from '../lib/stores.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Login extends SwellCommand {
+    static description = `
+If you are not already logged in, this command will open your browser to the
+Swell Admin login page, otherwise it will show you the stores you still
+have available for logging in to.
+`;
+    static flags = {
+        store: Flags.string({
+            char: 's',
+            description: 'store to login to',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'show all available stores and switch the current session if needed',
+        }),
+    };
+    static summary = 'Login to your Swell user account.';
+    constructor(argv, config) {
+        super(argv, config);
+        this.requiresAuth = false;
+    }
+    async run() {
+        const { flags } = await this.parse(Login);
+        const { force, store } = flags;
+        let currentStoreId = config.getDefaultStore();
+        let user;
+        if (currentStoreId && !force) {
+            try {
+                user = await this.api.get({ adminPath: 'user' });
+                config.setUser(user);
+            }
+            catch (err) {
+                // noop
+            }
+        }
+        if (!user) {
+            const [sessionId, storeId] = await getSessionIdOrLoginInBrowser(store);
+            this.api.setStoreEnv(storeId);
+            user = await this.api.get({ adminPath: 'user' }, { sessionId });
+            await this.getAndSetStoreConfig({ sessionId, storeId });
+            await modifyDefaultStore({ currentStoreId, storeId });
+            config.setUser(user);
+            this.log(`You are now logged in to ${style.storeId(storeId)} as ${style.currentUser(user.username)}.`);
+            process.exit(0);
+        }
+        this.log(`You are already logged in as ${style.currentUser(user.username)}.`);
+        this.log([
+            `Use ${style.command('swell switch')}`,
+            'to login to another account.',
+        ].join(' '));
+    }
+    /**
+     * Use the /user/switch API request to either get the session id for the
+     * current store or create a session id for the given store id.
+     *
+     * @param sessionId - The session id for the current store
+     * @param storeId - The store id to get the session id for
+     *
+     * @returns void
+     */
+    async getAndSetStoreConfig({ sessionId, storeId, }) {
+        const switchResponse = await this.api.post({ adminPath: '/user/switch' }, 
+        // eslint-disable-next-line camelcase
+        { body: { client_id: storeId }, sessionId });
+        // ensure we have the attribute names as we expect before saving
+        switchResponse.sessionId = switchResponse.session_id;
+        switchResponse.storeId = switchResponse.client_id;
+        switchResponse.name = switchResponse.client_name;
+        config.setStore(switchResponse);
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,8 @@
+import { SwellCommand } from '../swell-command.js';
+export default class Logout extends SwellCommand {
+    static description: string;
+    static flags: {
+        local: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,45 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { inflect } from 'inflection';
+import config from '../lib/config.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Logout extends SwellCommand {
+    static description = 'Log out of all stores available in your current session.';
+    static flags = {
+        local: Flags.boolean({
+            description: 'clear local authentication data',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Logout);
+        const user = config.getUser();
+        const storesCount = (config.get('stores') || []).length;
+        if (!config.getDefaultStore()) {
+            config.clear();
+            this.log('You are not logged in.');
+            return;
+        }
+        const continueLogout = await confirm({
+            message: `You are logged in as ${style.currentUser(user.email)} ${style.dim(`(${storesCount} ${inflect('stores', storesCount)})`)}. Are you sure you want to log out?`,
+        });
+        if (!continueLogout) {
+            return;
+        }
+        if (flags.local) {
+            config.clear();
+            this.log('Cleared local authentication data.');
+            return;
+        }
+        // logout from remote
+        const response = await this.api.post({ adminPath: 'user/logout' }, {});
+        if (response === null || response.success) {
+            // clear locally stored config
+            config.clear();
+            this.log(`Logged out from ${style.currentUser(user.email)}.`);
+        }
+        else {
+            this.logError('Logout failed.');
+        }
+    }
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,23 @@
+import { SwellCommand } from '../swell-command.js';
+export default class Logs extends SwellCommand {
+    static examples: string[];
+    static flags: {
+        after: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        before: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        columns: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        env: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        follow: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        number: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        pretty: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        search: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    private output;
+    run(): Promise<void>;
+    private getLogs;
+    private getLogsAndWriteToStream;
+}

package/dist/commands/logs.js

@@ -0,0 +1,207 @@
+import { Flags } from '@oclif/core';
+import { LineOutput, LoggedItem, TableOutput } from '../lib/logs/index.js';
+import { SwellCommand } from '../swell-command.js';
+// the columns available to display in the table
+const OUTPUT_COLUMNS = [
+    'app',
+    'data',
+    'date',
+    'env',
+    'ip',
+    'request',
+    'req',
+    'status',
+    'time',
+    'type',
+];
+// the default columns to display in the table
+const OUTPUT_COLUMNS_DEFAULTS = ['date', 'request', 'data', 'status', 'time'];
+// the interval to poll the API when following logs
+const FOLLOW_POLLING_INTERVAL = 1000 * 2; // 2 seconds
+/**
+ * Builds the request options to send to the API based on the flags passed
+ * to the command.
+ *
+ * @param flags the flags passed to the command
+ * @returns the request options to send to the API
+ */
+function buildLogRequestBody(flags) {
+    const reqOptions = { where: {} };
+    const andConditions = [];
+    reqOptions.limit = flags.number;
+    if (flags.search) {
+        reqOptions.search = flags.search;
+    }
+    // some filters are simple and can be mapped directly to the API
+    const logFilters = [
+        { filter: 'app_id', flag: 'app', operator: '$in' },
+        { filter: 'message.status', flag: 'status', operator: '$in' },
+        { filter: 'message.type', flag: 'type', operator: '$in' },
+    ];
+    // map the flags to the API query
+    for (const filter of logFilters) {
+        if (flags[filter.flag]) {
+            andConditions.push({
+                [filter.filter]: filter.operator
+                    ? { [filter.operator]: flags[filter.flag] }
+                    : flags[filter.flag],
+            });
+        }
+    }
+    const { after, before, env, startPolling } = flags;
+    if (env) {
+        andConditions.push({ environment_id: env });
+    }
+    else {
+        // Default to test env
+        andConditions.push({ environment_id: 'test' });
+    }
+    // if we are polling, we want to get logs after the last date we received
+    if (startPolling) {
+        andConditions.push({ date: { $gt: startPolling } });
+    }
+    else {
+        if (after) {
+            if (typeof after === 'object' && after !== null) {
+                andConditions.push({ date: after });
+            }
+            else {
+                andConditions.push({ date: { $gte: after } });
+            }
+        }
+        if (before) {
+            andConditions.push({ date: { $lte: before } });
+        }
+    }
+    // if there are any conditions, add them to the request options
+    // otherwise, the server will complain for an empty $and array
+    if (andConditions.length > 0) {
+        reqOptions.where.$and = andConditions;
+    }
+    return reqOptions;
+}
+export default class Logs extends SwellCommand {
+    static examples = [
+        'swell logs',
+        'swell logs -f -p -n 10 -c date,req,data',
+        'swell logs -s accounts',
+        'swell logs --after 2023-08-25T16:01:02.697Z -c date',
+        'swell logs --after 2023-08-27',
+    ];
+    static flags = {
+        after: Flags.string({
+            description: 'expected is Javascript Date Time String Format: YYYY-MM-DDTHH:mm:ss.sssZ',
+            parse: async (value) => new Date(value).toISOString(),
+            summary: 'show logs created on or after this date/time (utc)',
+        }),
+        // filters
+        app: Flags.string({
+            description: 'filter logs by app id',
+        }),
+        before: Flags.string({
+            description: 'expected is Javascript Date Time String Format: YYYY-MM-DDTHH:mm:ss.sssZ',
+            parse: async (value) => new Date(value).toISOString(),
+            summary: 'show logs created on or before this date/time (utc)',
+        }),
+        columns: Flags.string({
+            char: 'c',
+            default: OUTPUT_COLUMNS_DEFAULTS.join(','),
+            description: `available columns: ${OUTPUT_COLUMNS.join(', ')}`,
+            // validate the columns requested for display
+            async parse(value) {
+                const flagColumns = value.split(/\s*,\s*/g);
+                for (const column of flagColumns) {
+                    if (!OUTPUT_COLUMNS.includes(column)) {
+                        throw new Error(`Invalid column: ${column}`);
+                    }
+                }
+                return flagColumns.join(',');
+            },
+            summary: 'comma separated list of columns to display',
+        }),
+        env: Flags.string({
+            description: 'filter logs by environment id',
+        }),
+        // control / output
+        follow: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'stream logs in real time',
+            exclusive: ['before'],
+        }),
+        number: Flags.integer({
+            char: 'n',
+            default: 100,
+            description: 'number of log lines to return',
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'line',
+            description: 'how to display the logs',
+            options: ['table', 'line'],
+        }),
+        pretty: Flags.boolean({
+            char: 'p',
+            default: false,
+            description: 'note that this flag will take more space in the terminal and require more time to load',
+            summary: 'pretty print json data',
+        }),
+        search: Flags.string({
+            char: 's',
+            description: 'search logs by keyword',
+        }),
+        status: Flags.string({
+            description: 'filter logs by request status',
+        }),
+        type: Flags.string({
+            description: 'filter logs by type',
+            multiple: true,
+            options: ['api', 'function', 'webhook'],
+        }),
+    };
+    static summary = 'Output or stream store logs to the terminal.';
+    output;
+    async run() {
+        const { flags } = await this.parse(Logs);
+        // indentify the columns to display
+        const columns = flags.columns.split(',');
+        // create the output stream
+        this.output =
+            flags.output === 'table'
+                ? new TableOutput(columns, flags.pretty)
+                : new LineOutput(columns, flags.pretty);
+        // first run for getting the logs
+        // we keep track of the last date we received so we can get logs after that
+        flags.startPolling = await this.getLogsAndWriteToStream(flags);
+        // if following, poll the API every FOLLOW_POLLING_INTERVAL seconds and
+        // write new logs to the stream
+        if (flags.follow) {
+            setInterval(async () => {
+                // when polling, we want to get logs after the last date we received
+                flags.startPolling = await this.getLogsAndWriteToStream(flags);
+            }, FOLLOW_POLLING_INTERVAL);
+        }
+    }
+    async getLogs(flags) {
+        const body = buildLogRequestBody(flags);
+        this.debug('getLogs body', body);
+        const response = await this.api.post({ adminPath: `/data/$get/:logs` }, { body });
+        return response?.results?.reverse() || [];
+    }
+    async getLogsAndWriteToStream(flags) {
+        const logs = await this.getLogs(flags);
+        let lastDate = '';
+        if (!this.output) {
+            this.error('Output stream not available');
+        }
+        if (logs.length > 0) {
+            lastDate = logs.at(-1).date;
+            for (const log of logs) {
+                this.output.write(this.output.prepareData(new LoggedItem(log)));
+            }
+        }
+        // if the user is following logs, we want to return the last date we
+        // received
+        return lastDate || flags.startPolling;
+    }
+}

package/dist/commands/switch.d.ts

@@ -0,0 +1,10 @@
+import { SwellCommand } from '../swell-command.js';
+export default class Switch extends SwellCommand {
+    static args: {
+        'store-id': import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: import("@oclif/core").Command.Example[];
+    static summary: string;
+    run(): Promise<void>;
+}

package/dist/commands/switch.js

@@ -0,0 +1,41 @@
+import { Args } from '@oclif/core';
+import { CLIError } from '@oclif/errors';
+import config from '../lib/config.js';
+import { selectLoggedInStoreId } from '../lib/stores.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Switch extends SwellCommand {
+    static args = {
+        'store-id': Args.string({
+            description: 'store id you want to switch to',
+        }),
+    };
+    static description = `
+If you have access to more than one store, this command will
+define the store that all other commands will apply to by default.
+`;
+    static examples = [
+        ...SwellCommand.examples,
+        '<%= config.bin %> <%= command.id %> <store-id>',
+    ];
+    static summary = 'Switch your default current store.';
+    async run() {
+        const { args } = await this.parse(Switch);
+        let storeId = args['store-id'];
+        if (!storeId) {
+            storeId = await selectLoggedInStoreId();
+            // Login to a different account
+            if (storeId === '') {
+                await this.config.runCommand('login', ['--force']);
+                return;
+            }
+        }
+        if (storeId) {
+            config.setDefaultStore(storeId);
+            this.log(`Current store is now ${style.storeId(config.getDefaultStore())}.`);
+        }
+        else {
+            throw new CLIError('Could not switch stores.');
+        }
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,7 @@
+import { Config } from '@oclif/core';
+import { SwellCommand } from '../swell-command.js';
+export default class Whoami extends SwellCommand {
+    static description: string;
+    constructor(argv: string[], config: Config);
+    run(): Promise<void>;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,24 @@
+import config from '../lib/config.js';
+import { showStores } from '../lib/stores.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Whoami extends SwellCommand {
+    static description = `Display the current logged-in user and available stores.`;
+    constructor(argv, config) {
+        super(argv, config);
+        this.requiresAuth = false;
+    }
+    async run() {
+        const currentStoreId = config.getDefaultStore();
+        const loggedInStores = config.get('stores') || [];
+        const currentUser = config.get('user');
+        if (loggedInStores.length > 0 && currentUser?.name) {
+            this.log(`Logged in as: ${style.currentUser(currentUser.email)}\n`);
+            const storesOutput = showStores(loggedInStores, currentStoreId);
+            this.log(`Your stores:\n${storesOutput}`);
+        }
+        else {
+            this.log(`Please login to list current stores.`);
+        }
+    }
+}