@swell/cli 1.0.2 → 2.0.1-alpha.2

package/dist/lib/constants.js

@@ -0,0 +1,17 @@
+import { env } from './config.js';
+// note: env values stored in ~/.swell/env.json
+// url for backend api calls
+export const API_BASE_URL = env.get('API_BASE_URL') || 'https://api.swell.store';
+// url for admin api calls
+export const ADMIN_API_BASE_URL = 
+// eslint-disable-next-line no-template-curly-in-string
+env.get('ADMIN_API_BASE_URL') || 'https://${STORE_ID}.swell.store/admin/api';
+// url host for admin login
+export const LOGIN_HOST = env.get('LOGIN_HOST') || 'https://${STORE_ID}.swell.store';
+// helpers to get constants with replacements
+export function getAdminApiBaseUrl(storeId) {
+    return ADMIN_API_BASE_URL.replace('${STORE_ID}', storeId);
+}
+export function getLoginHost(storeId) {
+    return LOGIN_HOST.replace('${STORE_ID}', storeId || 'app');
+}

package/dist/lib/create/content.d.ts

@@ -0,0 +1,23 @@
+interface CreateContentFileBody {
+    collection: string;
+    label?: string;
+    description?: string;
+    fields?: ContentFieldProps[];
+    views?: ContentViewProps[];
+}
+interface ContentViewProps {
+    fields: [];
+    id: ContentView;
+    nav?: Record<string, any>;
+    tabs: [];
+}
+type ContentView = 'edit' | 'list' | 'new';
+type ContentType = 'asset' | 'basic_html' | 'blocks' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'currency' | 'customer_lookup' | 'date' | 'datetime' | 'document' | 'dropdown' | 'email' | 'field_group' | 'generic_lookup' | 'icon' | 'image' | 'long_text' | 'lookup' | 'markdown' | 'number' | 'percent' | 'phone' | 'product_lookup' | 'radio' | 'rich_html' | 'select' | 'short_text' | 'slider' | 'slug' | 'tags' | 'text' | 'textarea' | 'time' | 'toggle' | 'url' | 'variant_lookup' | 'video';
+interface ContentFieldProps {
+    id: string;
+    label: string;
+    type?: ContentType;
+}
+declare const parseViews: (views: string[]) => ContentViewProps[];
+declare const parseFields: (fields: string[]) => ContentFieldProps[];
+export { CreateContentFileBody, parseFields, parseViews };

package/dist/lib/create/content.js

@@ -0,0 +1,40 @@
+import { titleize } from 'inflection';
+const parseViews = (views) => {
+    if (views.length === 0) {
+        return [];
+    }
+    const viewResponse = [];
+    for (const viewId of views) {
+        viewResponse.push({
+            id: viewId,
+            ...(viewId === 'list' ? { nav: {} } : {}),
+            tabs: [],
+            fields: [],
+        });
+    }
+    return viewResponse;
+};
+const parseFields = (fields) => {
+    if (fields.length === 0) {
+        return [];
+    }
+    const fieldResponse = [];
+    for (const fieldPair of fields) {
+        if (fieldPair.includes(':')) {
+            const [id, type] = fieldPair.split(':');
+            fieldResponse.push({
+                id,
+                label: titleize(id),
+                type,
+            });
+        }
+        else {
+            fieldResponse.push({
+                id: fieldPair,
+                label: titleize(fieldPair),
+            });
+        }
+    }
+    return fieldResponse;
+};
+export { parseFields, parseViews };

package/dist/lib/create/function.d.ts

@@ -0,0 +1,17 @@
+type FunctionType = 'cron' | 'model' | 'route';
+type FunctionLanguage = 'js' | 'ts';
+interface CreateFunctionArgs {
+    functionName: string;
+    trigger: FunctionType;
+}
+interface WriteFunctionFileParams {
+    description: string;
+    events: string;
+    route: string;
+    functionName: string;
+    language: FunctionLanguage;
+    schedule: string;
+    trigger: FunctionType;
+}
+declare const getFunctionTemplate: ({ description, events, route, schedule, language, trigger, }: WriteFunctionFileParams) => string;
+export { CreateFunctionArgs, FunctionLanguage, FunctionType, WriteFunctionFileParams, getFunctionTemplate, };

package/dist/lib/create/function.js

@@ -0,0 +1,36 @@
+const getFunctionTemplate = ({ description, events, route, schedule, language, trigger, }) => {
+    let typeAppend = ``;
+    if (trigger === 'model') {
+        const eventsList = events
+            .split(/\s*,\s*/g)
+            .filter((e) => e)
+            .map((eventName) => `'${eventName}'`)
+            .join(', ');
+        typeAppend = `,
+  model: {
+    events: [${eventsList}],
+    conditions: {},
+  },`;
+    }
+    if (trigger === 'route') {
+        typeAppend = `,
+  route: {
+    public: ${route === 'public' || !route ? 'true' : 'false'}
+  },`;
+    }
+    if (trigger === 'cron') {
+        typeAppend = `,
+  cron: {
+    schedule: '${schedule}',
+  },`;
+    }
+    return `export const config${language === 'ts' ? ': SwellConfig' : ''} = {
+  description: '${description}'${typeAppend}
+};
+
+export default async function (req${language === 'ts' ? ': SwellRequest' : ''}) {
+  const { swell, store, settings, data${trigger === 'route' ? ', session' : ''} } = req;
+}
+`;
+};
+export { getFunctionTemplate, };

package/dist/lib/create/index.d.ts

@@ -0,0 +1,13 @@
+interface CreateFileParams {
+    extension?: string;
+    fileBody: Record<any, any> | string;
+    fileName: string;
+}
+declare const toFileName: (value: string) => string;
+declare const toAppName: (value: string) => string;
+declare const toAppId: (value: string) => string;
+declare const toFunctionFileName: (value: string) => string;
+declare const toCollectionName: (value: string) => string;
+declare const toCollectionLabel: (value: string) => string;
+declare const toNotificationLabel: (value: string) => string;
+export { CreateFileParams, toFileName, toAppName, toAppId, toFunctionFileName, toCollectionName, toCollectionLabel, toNotificationLabel, };

package/dist/lib/create/index.js

@@ -0,0 +1,20 @@
+import { dasherize, pluralize, underscore, titleize } from 'inflection';
+// Example: 'My Thing' => 'my-thing'
+const toFileName = (value) => dasherize(underscore(value.split('.')[0].replace(' ', '_'))).toLowerCase();
+// Example: 'my-things' => 'My Things'
+const toAppName = (value) => pluralize(titleize(value).replace('-', ' '));
+// Example: 'My App' => 'my_app'
+const toAppId = (value) => value
+    .replace(/[^a-z0-9]+/gi, '_')
+    .replace(/^\_|\_$/g, '')
+    .toLowerCase();
+// Example: 'My Thing' => 'my-thing'
+// And: 'myThing' => 'myThing'
+const toFunctionFileName = (value) => value.split('.')[0].replace(' ', '-');
+// Example: 'My Thing' => 'my-things'
+const toCollectionName = (value) => pluralize(value.replaceAll(/[^A-Za-z]/g, '-').replace(' ', '')).toLowerCase();
+// Example: 'my-things' => 'My Things'
+const toCollectionLabel = (value) => pluralize(titleize(value).replace('-', ' '));
+// Example: 'order-receipt' => 'Order Receipt'
+const toNotificationLabel = (value) => titleize(value).replace('-', ' ');
+export { toFileName, toAppName, toAppId, toFunctionFileName, toCollectionName, toCollectionLabel, toNotificationLabel, };

package/dist/lib/create/model.d.ts

@@ -0,0 +1,22 @@
+interface CreateModelFileBody {
+    label?: string;
+    collection?: string;
+    description?: string;
+    fields?: ModelFieldResponse;
+    events?: ModelEventObject;
+}
+interface ModelEventObject {
+    types?: ModelEvent[];
+}
+interface ModelEvent {
+    id: ModelEventID;
+}
+type ModelEventID = 'created' | 'deleted' | 'updated';
+type ModelFieldResponse = Record<string, ModelFieldTypeObject>;
+type FieldType = 'collection' | 'currency' | 'image' | 'int' | 'link' | 'string';
+interface ModelFieldTypeObject {
+    type: FieldType;
+}
+declare const parseFields: (fields: string[]) => ModelFieldResponse;
+declare const parseEvents: (events: string[]) => ModelEventObject;
+export { CreateModelFileBody, parseEvents, parseFields };

package/dist/lib/create/model.js

@@ -0,0 +1,30 @@
+const parseFields = (fields) => {
+    if (fields.length === 0) {
+        return {};
+    }
+    const fieldResponse = {};
+    for (const fieldPair of fields) {
+        if (fieldPair.includes(':')) {
+            const [id, type] = fieldPair.split(':');
+            fieldResponse[id] = {
+                type,
+            };
+        }
+    }
+    return fieldResponse;
+};
+const parseEvents = (events) => {
+    if (events.length === 0) {
+        return {};
+    }
+    const eventTypes = [];
+    for (const event of events) {
+        eventTypes.push({
+            id: event,
+        });
+    }
+    return {
+        types: eventTypes,
+    };
+};
+export { parseEvents, parseFields };

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

@@ -0,0 +1,25 @@
+interface WriteNotificationsFileParams {
+    description: string;
+    event: string;
+    model: string;
+    name: string;
+    subject: string;
+    admin?: boolean;
+    once?: boolean;
+}
+interface CreateNotificationFileBody {
+    admin?: boolean;
+    collection: string;
+    conditions: Record<any, any>;
+    contact?: string;
+    description?: string;
+    event: string;
+    label: string;
+    method: string;
+    new?: boolean;
+    query?: Record<any, any>;
+    repeat?: boolean;
+    sample?: Record<any, any>;
+    subject: string;
+}
+export { CreateNotificationFileBody, WriteNotificationsFileParams };

package/dist/lib/create/notification.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/info.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Helper module for the `info` command. Encapsulates the logic for
+ * displaying the app's information.
+ */
+import { App, AppVersion } from './apps';
+interface FieldDefinition {
+    label: string;
+    transform?: (_arg: any) => Promise<string> | string;
+    value?: any;
+}
+export declare class FieldDefinitions {
+    app: App;
+    versions: AppVersion[];
+    constructor(app: App, versions: AppVersion[]);
+    get client(): FieldDefinition;
+    get dateCreated(): FieldDefinition;
+    get dateUpdated(): FieldDefinition;
+    get description(): FieldDefinition;
+    get installed(): FieldDefinition;
+    get name(): FieldDefinition;
+    get publicId(): FieldDefinition;
+    get published(): FieldDefinition;
+    get version(): FieldDefinition;
+    /**
+     * Returns a FieldDefinition object for the given field.
+     *
+     * The function uses the field name to find its value in the app object. If
+     * the FieldDefinition has a transform function for the required field,
+     * it will be called to transform the value before returning the
+     * FieldDefinition.
+     *
+     * @param field The field to get the definition for
+     *
+     * @returns The FieldDefinition object
+     */
+    getFieldDefinition(field: string): FieldDefinition;
+}
+export {};

package/dist/lib/info.js

@@ -0,0 +1,91 @@
+/**
+ * Helper module for the `info` command. Encapsulates the logic for
+ * displaying the app's information.
+ */
+import { camelize } from 'inflection';
+import style from './style.js';
+function transformDate(date) {
+    return date ? new Date(date).toUTCString() : '';
+}
+function transformBoolean(bool) {
+    return bool ? 'Yes' : 'No';
+}
+export class FieldDefinitions {
+    app;
+    versions;
+    constructor(app, versions) {
+        this.app = app;
+        this.versions = versions;
+    }
+    get client() {
+        return {
+            label: 'Test store',
+            transform: (client) => `${client.name} (${style.storeId(client.id)})`,
+        };
+    }
+    get dateCreated() {
+        return { label: 'Created at', transform: transformDate };
+    }
+    get dateUpdated() {
+        return { label: 'Updated at', transform: transformDate };
+    }
+    get description() {
+        return { label: 'Description' };
+    }
+    get installed() {
+        return { label: 'Installed', transform: transformBoolean };
+    }
+    get name() {
+        return { label: 'Name' };
+    }
+    get publicId() {
+        return {
+            label: 'Public ID',
+            transform: (publicId) => {
+                if (publicId)
+                    return publicId;
+                // replace _ as the first char any number of times in private_id
+                return this.app.private_id?.replace(/^_+/, '') || '';
+            },
+        };
+    }
+    get published() {
+        return { label: 'Published', transform: transformBoolean };
+    }
+    get version() {
+        return {
+            label: 'Version',
+            transform: (_version) => {
+                if (this.versions.length === 0) {
+                    return 'N/A';
+                }
+                return [
+                    style.appConfigValue(this.versions[0].version),
+                    '(latest)',
+                    this.versions.length > 1 ? `| ${this.versions.length} (total)` : '',
+                ].join(' ');
+            },
+        };
+    }
+    /**
+     * Returns a FieldDefinition object for the given field.
+     *
+     * The function uses the field name to find its value in the app object. If
+     * the FieldDefinition has a transform function for the required field,
+     * it will be called to transform the value before returning the
+     * FieldDefinition.
+     *
+     * @param field The field to get the definition for
+     *
+     * @returns The FieldDefinition object
+     */
+    getFieldDefinition(field) {
+        const fieldDef = this[camelize(field, true)];
+        let value = this.app[field];
+        if (fieldDef.transform) {
+            value = fieldDef.transform(value);
+        }
+        fieldDef.value = value || '';
+        return fieldDef;
+    }
+}

package/dist/lib/logs/index.d.ts

@@ -0,0 +1,23 @@
+export { LineOutput } from './line-output.js';
+export { TableOutput } from './table-output.js';
+/**
+ * A log item.
+ *
+ * A common class for all log types that handles the mapping of log data to the
+ * columns. This mapping is to then be used by all output options consistently.
+ */
+export declare class LoggedItem implements LogItem {
+    app: string;
+    data: string;
+    date: string;
+    env: string;
+    ip: string;
+    req: string;
+    request: string;
+    status: string;
+    time: string;
+    type: string;
+    constructor(log: any);
+    private prepareRequest;
+    private prepareRequestFunction;
+}

package/dist/lib/logs/index.js

@@ -0,0 +1,88 @@
+import style from '../style.js';
+export { LineOutput } from './line-output.js';
+export { TableOutput } from './table-output.js';
+/**
+ * A log item.
+ *
+ * A common class for all log types that handles the mapping of log data to the
+ * columns. This mapping is to then be used by all output options consistently.
+ */
+export class LoggedItem {
+    app;
+    data;
+    date;
+    env;
+    ip;
+    req;
+    request;
+    status;
+    time;
+    type;
+    constructor(log) {
+        const logMessage = log.message;
+        this.app = style.logApp(log.$app_id || log.app_id);
+        this.data = logMessage?.data || null;
+        this.date = style.logDate(log.date.replaceAll(/T|Z/g, ' ').trim());
+        this.env = log.environment_id;
+        this.ip = log.ip;
+        this.request = this.prepareRequest(logMessage);
+        this.req = log.req_id;
+        this.status = style.logStatus(logMessage?.status);
+        this.time = `${log.time}ms`;
+        this.type = logMessage?.type;
+    }
+    prepareRequest(logMessage) {
+        let request = '';
+        if (!logMessage) {
+            return request;
+        }
+        const { url } = logMessage;
+        switch (logMessage.type) {
+            case 'function': {
+                request = this.prepareRequestFunction(logMessage);
+                break;
+            }
+            case 'webhook': {
+                const { event } = logMessage;
+                request = `Webhook ${event.type} > ${style.logMethod('POST')} ${url}`;
+                break;
+            }
+            case 'api': {
+                request = [
+                    style.logMethod(logMessage.method.toUpperCase()),
+                    logMessage.url,
+                ].join(' ');
+                break;
+            }
+            default: {
+                request = logMessage.type;
+                break;
+            }
+        }
+        return request;
+    }
+    prepareRequestFunction(logMessage) {
+        const { event } = logMessage;
+        const { logs, method, name } = logMessage;
+        const logLines = logs
+            ?.map((l) => {
+            const line = l.line?.join('\n');
+            switch (l.level) {
+                case 'debug': {
+                    return style.funcDebug(line);
+                }
+                case 'warn': {
+                    return style.funcWarn(line);
+                }
+                case 'error': {
+                    return style.funcError(line);
+                }
+                default: {
+                    return style.funcInfo(line);
+                }
+            }
+        })
+            .join('\n');
+        return `Function ${event ? `${event.type} >` : ''} ${style.logMethod(method.toUpperCase())} /${name} ${logLines ? `\n${logLines}` : ''}`;
+    }
+}

package/dist/lib/logs/line-output.d.ts

@@ -0,0 +1,5 @@
+import { Output } from './output.js';
+export declare class LineOutput extends Output {
+    prepareData(log: LogItem): string[];
+    write(row: string[]): void;
+}

package/dist/lib/logs/line-output.js

@@ -0,0 +1,13 @@
+import { Output } from './output.js';
+const COLUMN_NAMES_TO_HIDE = new Set(['date', 'request']);
+export class LineOutput extends Output {
+    prepareData(log) {
+        return this.columns.map((c) => {
+            const logValue = log[c];
+            return COLUMN_NAMES_TO_HIDE.has(c) ? logValue : `${c}: ${logValue}`;
+        });
+    }
+    write(row) {
+        console.log(row.join(' - '));
+    }
+}

package/dist/lib/logs/output.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class Output {
+    protected columns: string[];
+    protected pretty: boolean;
+    constructor(columns: string[], pretty: boolean);
+    abstract prepareData(log: LogItem): string[];
+    abstract write(row: string[]): void;
+}

package/dist/lib/logs/output.js

@@ -0,0 +1,8 @@
+export class Output {
+    columns;
+    pretty = false;
+    constructor(columns, pretty) {
+        this.columns = columns;
+        this.pretty = pretty;
+    }
+}

package/dist/lib/logs/table-output.d.ts

@@ -0,0 +1,11 @@
+import { Output } from './output.js';
+export declare class TableOutput extends Output {
+    private stream;
+    constructor(columns: string[], pretty: boolean);
+    prepareData(log: LogItem): string[];
+    write(row: string[]): void;
+    private computeExtraWidths;
+    private displayOptions;
+    private prepareColumnDisplay;
+    private writeHeader;
+}

package/dist/lib/logs/table-output.js

@@ -0,0 +1,128 @@
+import { titleize } from 'inflection';
+import { createStream, getBorderCharacters, } from 'table';
+import { Output } from './output.js';
+// the terminal width used in column display
+// leave 5% for padding
+const MAX_WIDTH = Math.floor((process.stdout.columns || 80) * 0.95);
+// the default column width
+const DEFAULT_COL_WIDTH = 10;
+export class TableOutput extends Output {
+    stream;
+    constructor(columns, pretty) {
+        super(columns, pretty);
+        const extraWidths = this.computeExtraWidths();
+        const config = {
+            border: getBorderCharacters('void'),
+            columnCount: columns.length,
+            columnDefault: { width: DEFAULT_COL_WIDTH },
+            columns: columns.map((c) => this.prepareColumnDisplay(c, extraWidths[c])),
+            drawVerticalLine: () => false,
+        };
+        // create the output stream and write the header
+        this.stream = createStream(config);
+        this.writeHeader();
+    }
+    prepareData(log) {
+        return this.columns.map((c) => {
+            // for each column, get the value from the log item and prepare it for
+            // display in the table, i.e. go through TableLoggedItem before returning
+            const tableLog = new TableLoggedItem(log, this.pretty);
+            const preparedLog = tableLog.prepareData();
+            return preparedLog[c];
+        });
+    }
+    write(row) {
+        this.stream.write(row);
+    }
+    computeExtraWidths() {
+        const extraWidths = {};
+        // compute the initial width of the table
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const initialWidth = this.columns.reduce((acc, col) => {
+            const display = this.displayOptions(col);
+            return acc + (display.width || display.minWidth || DEFAULT_COL_WIDTH);
+        }, 0);
+        const availableWidth = MAX_WIDTH - initialWidth;
+        const minWidthCols = this.columns.filter((col) => this.displayOptions(col).minWidth);
+        // if there is extra width available, split it across all columns that have
+        // minWidth
+        if (availableWidth > 0 && minWidthCols.length > 0) {
+            const extraWidthPerCol = Math.floor(availableWidth / minWidthCols.length);
+            for (const col of minWidthCols) {
+                extraWidths[col] = extraWidthPerCol;
+            }
+        }
+        return extraWidths;
+    }
+    displayOptions(column) {
+        // an extension of the column def in https://www.npmjs.com/package/table
+        // for config.columns
+        const columns = {
+            data: {
+                minWidth: 40,
+                wrapWord: !this.pretty,
+            },
+            date: {
+                title: 'Date UTC',
+                width: 24,
+            },
+            req: {
+                width: 24,
+            },
+            request: {
+                minWidth: 40,
+            },
+            status: {
+                width: 6,
+            },
+            time: {
+                width: 6,
+            },
+        };
+        return columns[column];
+    }
+    prepareColumnDisplay(column, extraWidth) {
+        const display = this.displayOptions(column);
+        const { minWidth, wrapWord } = display;
+        let { width } = display;
+        if (minWidth) {
+            width = minWidth;
+        }
+        if (width && extraWidth) {
+            width += extraWidth;
+        }
+        return { width, wrapWord };
+    }
+    writeHeader() {
+        this.stream.write(this.columns.map((c) => this.displayOptions(c)?.title || titleize(c)));
+    }
+}
+/**
+ * A layer between the log item and the table output that handles the mapping of
+ * log data to the columns specifically for the table output.
+ */
+class TableLoggedItem {
+    logItem;
+    pretty = false;
+    constructor(logItem, pretty) {
+        this.logItem = logItem;
+        this.pretty = pretty;
+    }
+    prepareData() {
+        this.logItem.data = this.prepareLogItemData();
+        return this.logItem;
+    }
+    prepareLogItemData() {
+        let logData = this.logItem.data;
+        try {
+            if (this.pretty && typeof logData === 'string') {
+                logData = JSON.parse(logData);
+                logData = JSON.stringify(logData, null, 2);
+            }
+        }
+        catch {
+            // do nothing, JSON parsing errors
+        }
+        return logData;
+    }
+}