@swell/cli 1.0.2 → 2.0.1-alpha.2

package/dist/commands/create/app.js

@@ -0,0 +1,210 @@
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { confirm, input, select } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import ora from 'ora';
+import { appConfigFileExists, newConfig } from '../../lib/app-config.js';
+import style from '../../lib/style.js';
+import { SwellCommand } from '../../swell-command.js';
+import { toAppName, toAppId } from '../../lib/create/index.js';
+import { getAllConfigPaths, writeJsonFile } from '../../lib/apps/index.js';
+const execAsync = promisify(exec);
+export default class CreateApp extends SwellCommand {
+    static args = {
+        id: Args.string({
+            default: '',
+            description: `id of the app to create`,
+        }),
+    };
+    static flags = {
+        pkg: Flags.string({
+            char: 'p',
+            default: 'npm',
+            description: `use npm or yarn to install default dependencies, or none to disable`,
+            options: ['npm', 'yarn', 'none'],
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: `accept all default values`,
+        }),
+    };
+    static description = 'Initialize an app with config file and folder structure.';
+    static examples = [
+        {
+            command: 'swell create app',
+            description: 'Create app following command prompts.',
+        },
+        {
+            command: 'swell create app my_app -y',
+            description: 'Create app and accept all default values.',
+        },
+        {
+            command: 'swell create app -p yarn',
+            description: 'Create app with yarn package manager instead of npm by default.',
+        },
+        {
+            command: 'swell create app -p none',
+            description: 'Create app without installing TypeScript bindings, etc.',
+        },
+    ];
+    async run() {
+        const { args, flags } = await this.parse(CreateApp);
+        const { id } = args;
+        const { pkg, yes } = flags;
+        let confirmYes = yes && id;
+        const name = confirmYes
+            ? toAppName(id)
+            : await input({
+                message: 'App name',
+                default: id ? toAppName(id) : '',
+                validate: (answer) => answer.length > 2,
+            });
+        let appId = toAppId(id || '');
+        if (!appId) {
+            appId = await input({
+                message: 'App ID',
+                default: toAppId(name),
+                validate: (answer) => answer.length > 2,
+            });
+            appId = toAppId(appId);
+            confirmYes = yes && appId;
+        }
+        const description = confirmYes
+            ? ''
+            : await input({
+                message: 'Describe what the app does',
+                default: 'Something special',
+            });
+        const type = confirmYes
+            ? 'admin'
+            : await select({
+                message: 'What is the primary purpose of the app?',
+                choices: [
+                    { name: 'Admin', value: 'admin' },
+                    { name: 'Integration', value: 'integration' },
+                    { name: 'Storefront', value: 'storefront' },
+                ],
+            });
+        const appConfigJson = {
+            id: appId,
+            version: '1.0.0',
+            name,
+            description,
+            type,
+            permissions: [],
+        };
+        const config = newConfig(appId);
+        if (!confirmYes && appConfigFileExists(config.path)) {
+            const continueCreateApp = await confirm({
+                message: `An app already exists in the target folder ${appId}. Overwrite?`,
+            });
+            if (!continueCreateApp) {
+                return;
+            }
+        }
+        this.log(`\nCreating app ${style.appConfigValue(name)} in ${config.path}`);
+        this.log(`\n${JSON.stringify(appConfigJson, null, 4)}\n`);
+        const confirmCreateApp = confirmYes
+            ? true
+            : await confirm({
+                message: 'Ok to continue?',
+            });
+        if (!confirmCreateApp) {
+            return;
+        }
+        !confirmYes && this.log();
+        const spinner = ora();
+        spinner.start('Creating app...');
+        config.clear();
+        config.set(appConfigJson);
+        if (pkg !== 'none') {
+            await this.tryPackageSetup(appId, config, pkg);
+        }
+        await this.createAppConfigFolders(config);
+        spinner.succeed(`${style.appConfigValue(name)} app created.`);
+        this.log('\nNext steps:');
+        this.log(`Run ${style.command('swell app push')} to push configurations to your test store.`);
+        this.log(`Run ${style.command('swell app install')} to install the app in another store or environment.`);
+    }
+    async tryPackageSetup(name, config, pkg) {
+        try {
+            await this.setupPackage(name, config, pkg);
+        }
+        catch (err) {
+            this.log(`There was an error setting up the package manager: ${err.message}`);
+        }
+    }
+    async setupPackage(name, config, pkg) {
+        const execAsync = promisify(exec);
+        const packageJson = {
+            name,
+            version: config.get('version'),
+            description: config.get('description'),
+            scripts: {},
+            devDependencies: {
+                '@swell/app-types': '^1.0.5',
+            },
+        };
+        const tsConfig = {
+            compilerOptions: {
+                target: 'esnext',
+                module: 'esnext',
+                lib: ['esnext', 'webworker'],
+                types: ['@swell/app-types'],
+            },
+            include: ['**/*.ts'],
+            exclude: ['node_modules'],
+        };
+        await writeJsonFile(path.join(path.dirname(config.path), 'package.json'), packageJson);
+        await writeJsonFile(path.join(path.dirname(config.path), 'tsconfig.json'), tsConfig);
+        try {
+            const packageManager = await this.findPackageManager(pkg);
+            await execAsync(`${packageManager} install`, {
+                cwd: path.dirname(config.path),
+            });
+        }
+        catch (err) {
+            this.error(err.message);
+        }
+    }
+    async findPackageManager(pkg) {
+        let packageManager = pkg ? pkg : '';
+        // Determine if system has yarn or npm install
+        if (packageManager) {
+            if (await this.doesPackageManagerExist(packageManager)) {
+                return packageManager;
+            }
+        }
+        else {
+            if (await this.doesPackageManagerExist('npm')) {
+                return 'npm';
+            }
+            else if (await this.doesPackageManagerExist('yarn')) {
+                return 'yarn';
+            }
+        }
+    }
+    async doesPackageManagerExist(packageManager) {
+        try {
+            await execAsync(`${packageManager} --version`);
+            return true;
+        }
+        catch (err) {
+            this.debug(`Could not find ${packageManager} on your system. Please install ${packageManager} and try again.`);
+            return false;
+        }
+    }
+    async createAppConfigFolders(config) {
+        for (const type of getAllConfigPaths()) {
+            // Create a config folder
+            await execAsync(`mkdir -p ${type}`, {
+                cwd: path.dirname(config.path),
+            });
+            // Create gitkeep file
+            await execAsync(`touch ${path.join(type, '.gitkeep')}`, {
+                cwd: path.dirname(config.path),
+            });
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { CreateCollectionCommand } from '../../create-collection-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+export default class CreateContent extends CreateCollectionCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        views: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    createType: ConfigType;
+    run(): Promise<void>;
+}

package/dist/commands/create/content.js

@@ -0,0 +1,87 @@
+import { checkbox } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { CreateCollectionCommand } from '../../create-collection-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+import { parseFields, parseViews, } from '../../lib/create/content.js';
+import { toFileName } from '../../lib/create/index.js';
+export default class CreateContent extends CreateCollectionCommand {
+    static description = `This command assists in generating UI model configuration files. CLI will prompt for values when flags are not present.`;
+    static examples = [
+        {
+            command: 'swell create content',
+            description: 'Create content model interactively.',
+        },
+        {
+            command: 'swell create content visitors -v list,edit,new',
+            description: 'Specify views delimited by semicolons.',
+        },
+        {
+            command: 'swell create content visitors -f name:short_text,description:long_text,verified:boolean,visitor_count:integer,photo:image,orders:collection',
+            description: 'Specify fields with types delimited by semicolons',
+        },
+        {
+            command: 'swell create content visitors -o -f verified:short_text -v list,edit,new -d "Visitor Views"',
+            description: 'Specify fields, views, and description.',
+        },
+    ];
+    static flags = {
+        label: Flags.string({
+            char: 'l',
+            default: '',
+            description: 'content model label',
+        }),
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'content model description',
+        }),
+        fields: Flags.string({
+            char: 'f',
+            default: '',
+            description: 'list of content model fields delimited by commas',
+        }),
+        views: Flags.string({
+            char: 'v',
+            default: '',
+            description: 'list of content model views delimited by commas, i.e. list,edit,new',
+        }),
+        overwrite: Flags.boolean({
+            default: false,
+            description: 'overwrite existing content model configuration file',
+        }),
+    };
+    static summary = 'Initialize a content UI model config file with properties in the content folder.';
+    createType = ConfigType.CONTENT;
+    async run() {
+        const { flags } = await this.parse(CreateContent);
+        const { label, description, collection } = await this.promptCollection();
+        const fileName = toFileName(collection);
+        const fileBody = {
+            collection,
+        };
+        const { fields, overwrite, views } = flags;
+        if (label) {
+            fileBody.label = label;
+        }
+        fileBody.description = description;
+        fileBody.fields = fields ? parseFields(fields.split(',')) : [];
+        if (views) {
+            fileBody.views = views ? parseViews(views.split(',')) : [];
+        }
+        else {
+            const viewsInput = await checkbox({
+                message: 'Which views does your content have?',
+                choices: [
+                    { name: 'List view', value: 'list' },
+                    { name: 'Edit view', value: 'edit' },
+                    { name: 'New view', value: 'new' },
+                ],
+            });
+            fileBody.views = parseViews(viewsInput);
+        }
+        await this.createFile({
+            fileBody,
+            fileName,
+        }, overwrite);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { CreateCommand } from '../../create-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+export default class CreateFunction extends CreateCommand {
+    static args: {
+        functionName: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        trigger: 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>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        route: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        schedule: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    createType: ConfigType;
+    run(): Promise<void>;
+    private gatherInput;
+    private writeFunctionFile;
+}

package/dist/commands/create/function.js

@@ -0,0 +1,191 @@
+import { input, select } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { CreateCommand } from '../../create-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+import { getFunctionTemplate, } from '../../lib/create/function.js';
+import { toFunctionFileName } from '../../lib/create/index.js';
+const PERMITTED_TRIGGERS = ['cron', 'model', 'route'];
+export default class CreateFunction extends CreateCommand {
+    static args = {
+        functionName: Args.string({
+            description: 'function name, used in an http route if applicable',
+        }),
+        trigger: Args.string({
+            description: `function trigger type`,
+            options: PERMITTED_TRIGGERS,
+        }),
+    };
+    static description = `This command assists in generating functions scripts. CLI will prompt for values when flags are not present.`;
+    static examples = [
+        {
+            command: 'swell create function',
+            description: 'Create function script interactively.',
+        },
+        {
+            command: 'swell create function orders-subscriptions-created.ts model --events order.created,subscription.created',
+            description: 'Specify model event trigger of the function.',
+        },
+        {
+            command: 'swell create function get-frontend-data.ts route --route public',
+            description: 'Specify public API access.',
+        },
+        {
+            command: 'swell create function process-metrics.ts cron --schedule "0 0 * * *"',
+            description: 'Specify schedule of the cron function.',
+        },
+    ];
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'function description',
+        }),
+        events: Flags.string({
+            char: 'e',
+            default: '',
+            description: 'list of data model events used with model trigger, delimited by commas',
+        }),
+        route: Flags.string({
+            char: 'r',
+            default: 'public',
+            description: 'access type used with route trigger',
+            options: ['public', 'private'],
+        }),
+        schedule: Flags.string({
+            char: 's',
+            default: '',
+            description: 'crontab value used with cron trigger',
+        }),
+        overwrite: Flags.boolean({
+            default: false,
+            description: 'overwrite existing function file',
+        }),
+    };
+    static summary = 'Initialize a functions script in JavaScript or TypeScript.';
+    createType = ConfigType.FUNCTION;
+    async run() {
+        const { args, flags } = await this.parse(CreateFunction);
+        const { functionName, trigger } = args;
+        const { description, events, route, schedule, overwrite } = flags;
+        let writeFunctionFileParams = {
+            description,
+            events,
+            route,
+            functionName: functionName || '',
+            language: (functionName?.includes('.ts')
+                ? 'ts'
+                : 'js'),
+            schedule,
+            trigger: trigger,
+        };
+        writeFunctionFileParams = {
+            ...writeFunctionFileParams,
+            ...(await this.gatherInput(writeFunctionFileParams)),
+        };
+        await this.writeFunctionFile(writeFunctionFileParams, overwrite);
+    }
+    async gatherInput(params) {
+        let language = params.language;
+        if (!language) {
+            language = await select({
+                choices: [
+                    {
+                        name: 'TypeScript',
+                        value: 'ts',
+                    },
+                    {
+                        name: 'JavaScript',
+                        value: 'js',
+                    },
+                ],
+                message: 'What language are you using?',
+            });
+        }
+        let trigger = params.trigger;
+        if (!trigger) {
+            trigger = await select({
+                choices: [
+                    {
+                        name: 'Event',
+                        value: 'model',
+                    },
+                    {
+                        name: 'Schedule',
+                        value: 'cron',
+                    },
+                    {
+                        name: 'HTTP',
+                        value: 'route',
+                    },
+                ],
+                message: 'How will your function be triggered?',
+            });
+        }
+        let events = params.events;
+        if (trigger === 'model' && !events) {
+            events = await input({
+                message: 'Enter event types separated by a comma',
+                default: 'product.created, etc...',
+            });
+            if (events === 'product.created, etc...') {
+                events = '';
+            }
+        }
+        let schedule = params.schedule;
+        if (trigger === 'cron' && !schedule) {
+            schedule = await input({
+                message: 'Enter the crontab value',
+                default: '0 0 * * *',
+            });
+        }
+        let route = params.route;
+        if (trigger === 'route' && !route) {
+            route = await select({
+                message: 'Should tbe route be public (public_key) or private (secret_key)?',
+                choices: [
+                    { name: 'Public', value: 'public' },
+                    { name: 'Private', value: 'private' },
+                ],
+            });
+        }
+        let functionName = params.functionName;
+        if (!functionName) {
+            functionName = await input({
+                message: 'What will the endpoint be?',
+                default: functionName,
+            });
+        }
+        let description = params.description;
+        if (!description) {
+            await input({
+                default: 'Does a thing when another other thing happens',
+                message: 'Describe what the function does',
+            });
+        }
+        return {
+            description,
+            events: events || '',
+            route: route || '',
+            functionName,
+            language,
+            schedule: schedule || '',
+            trigger,
+        };
+    }
+    async writeFunctionFile({ description, events, route, functionName, language, schedule, trigger, }, overwrite) {
+        const fileName = toFunctionFileName(functionName);
+        await this.createFile({
+            extension: language,
+            fileBody: getFunctionTemplate({
+                description,
+                events,
+                route,
+                functionName,
+                language,
+                schedule,
+                trigger,
+            }),
+            fileName,
+        }, overwrite);
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Create extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/create/index.js

@@ -0,0 +1,34 @@
+import { select } from '@inquirer/prompts';
+import { Command } from '@oclif/core';
+export default class Create extends Command {
+    static description = 'Scaffold apps, models, functions, and notifications.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const createTarget = await select({
+            choices: [
+                {
+                    name: 'App',
+                    value: 'app',
+                },
+                {
+                    name: 'Model',
+                    value: 'model',
+                },
+                {
+                    name: 'Content',
+                    value: 'content',
+                },
+                {
+                    name: 'Function',
+                    value: 'function',
+                },
+                {
+                    name: 'Notification',
+                    value: 'notification',
+                },
+            ],
+            message: 'What do you want to create?',
+        });
+        this.log(JSON.stringify(createTarget));
+    }
+}

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

@@ -0,0 +1,19 @@
+import { CreateCollectionCommand } from '../../create-collection-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+export default class CreateModel extends CreateCollectionCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    createType: ConfigType;
+    run(): Promise<void>;
+}

package/dist/commands/create/model.js

@@ -0,0 +1,87 @@
+import { checkbox } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { CreateCollectionCommand } from '../../create-collection-command.js';
+import { ConfigType } from '../../lib/apps/index.js';
+import { toFileName } from '../../lib/create/index.js';
+import { parseEvents, parseFields, } from '../../lib/create/model.js';
+export default class CreateModel extends CreateCollectionCommand {
+    static description = `This command assists in generating data model configuration files. CLI will prompt for values when flags are not present.`;
+    static examples = [
+        {
+            command: 'swell create model',
+            description: 'Create data model configuration interactively.',
+        },
+        {
+            command: 'swell create model visitors -e created,updated,deleted.',
+            description: 'Specify events of the data model.',
+        },
+        {
+            command: 'swell create model visitors -f first_name:string,last_name:string,photo:file,visit_count:int,visits:link',
+            description: 'Specify fields of the data model.',
+        },
+        {
+            command: 'swell create model visitors -f first_name:string,last_name:string,photo:file,visit_count:int,visits:link -d "Visitors Tracking" -o -e created,updated,deleted',
+            description: 'Scaffold a data model configuration with args and flags.',
+        },
+    ];
+    static flags = {
+        label: Flags.string({
+            char: 'l',
+            default: '',
+            description: 'data model label, i.e. Products',
+        }),
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'data model description',
+        }),
+        fields: Flags.string({
+            char: 'f',
+            default: '',
+            description: 'list of data model fields delimited by commas',
+        }),
+        events: Flags.string({
+            char: 'e',
+            default: 'created,updated,deleted',
+            description: 'list of data model events delimited by commas',
+        }),
+        overwrite: Flags.boolean({
+            default: false,
+            description: 'Overwrite existing data model configuration file.',
+        }),
+    };
+    static summary = 'Initialize a data model config file with properties in the models folder.';
+    createType = ConfigType.MODEL;
+    async run() {
+        const { flags } = await this.parse(CreateModel);
+        const { label, description, collection } = await this.promptCollection();
+        const fileName = toFileName(collection);
+        const fileBody = {
+            collection,
+        };
+        const { events, fields, overwrite } = flags;
+        if (label) {
+            fileBody.label = label;
+        }
+        fileBody.description = description;
+        fileBody.fields = fields ? parseFields(fields.split(',')) : {};
+        if (fileBody.events) {
+            fileBody.events = events ? parseEvents(events.split(',')) : {};
+        }
+        else {
+            const eventsInput = await checkbox({
+                message: 'Which events should be captured by default?',
+                choices: [
+                    { name: 'created', value: 'created' },
+                    { name: 'updated', value: 'updated' },
+                    { name: 'deleted', value: 'deleted' },
+                ],
+            });
+            fileBody.events = parseEvents(eventsInput);
+        }
+        await this.createFile({
+            fileBody,
+            fileName,
+        }, overwrite);
+    }
+}