@swell/cli 2.0.1-alpha.9 → 2.0.2

package/dist/commands/create/function.js

@@ -1,11 +1,11 @@
 import { input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-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 {
+export default class CreateFunction extends CreateConfigCommand {
     static args = {
         functionName: Args.string({
             description: 'function name, used in an http route if applicable',
@@ -45,6 +45,10 @@ export default class CreateFunction extends CreateCommand {
             default: '',
             description: 'list of data model events used with model trigger, delimited by commas',
         }),
+        overwrite: Flags.boolean({
+            default: false,
+            description: 'overwrite existing function file',
+        }),
         route: Flags.string({
             char: 'r',
             default: 'public',
@@ -56,25 +60,21 @@ export default class CreateFunction extends CreateCommand {
             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;
+        const { description, events, overwrite, route, schedule } = flags;
         let writeFunctionFileParams = {
             description,
             events,
-            route,
             functionName: functionName || '',
             language: (functionName?.includes('.ts')
                 ? 'ts'
                 : 'js'),
+            route,
             schedule,
             trigger: trigger,
         };
@@ -85,7 +85,7 @@ export default class CreateFunction extends CreateCommand {
         await this.writeFunctionFile(writeFunctionFileParams, overwrite);
     }
     async gatherInput(params) {
-        let language = params.language;
+        let { language } = params;
         if (!language) {
             language = await select({
                 choices: [
@@ -101,7 +101,7 @@ export default class CreateFunction extends CreateCommand {
                 message: 'What language are you using?',
             });
         }
-        let trigger = params.trigger;
+        let { trigger } = params;
         if (!trigger) {
             trigger = await select({
                 choices: [
@@ -121,41 +121,41 @@ export default class CreateFunction extends CreateCommand {
                 message: 'How will your function be triggered?',
             });
         }
-        let events = params.events;
+        let { events } = params;
         if (trigger === 'model' && !events) {
             events = await input({
-                message: 'Enter event types separated by a comma',
                 default: 'product.created, etc...',
+                message: 'Enter event types separated by a comma',
             });
             if (events === 'product.created, etc...') {
                 events = '';
             }
         }
-        let schedule = params.schedule;
+        let { schedule } = params;
         if (trigger === 'cron' && !schedule) {
             schedule = await input({
-                message: 'Enter the crontab value',
                 default: '0 0 * * *',
+                message: 'Enter the crontab value',
             });
         }
-        let route = params.route;
+        let { route } = params;
         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' },
                 ],
+                message: 'Should tbe route be public (public_key) or private (secret_key)?',
             });
         }
-        let functionName = params.functionName;
+        let { functionName } = params;
         if (!functionName) {
             functionName = await input({
-                message: 'What will the endpoint be?',
                 default: functionName,
+                message: 'What will the endpoint be?',
             });
         }
-        let description = params.description;
+        const { description } = params;
         if (!description) {
             await input({
                 default: 'Does a thing when another other thing happens',
@@ -165,23 +165,23 @@ export default class CreateFunction extends CreateCommand {
         return {
             description,
             events: events || '',
-            route: route || '',
             functionName,
             language,
+            route: route || '',
             schedule: schedule || '',
             trigger,
         };
     }
-    async writeFunctionFile({ description, events, route, functionName, language, schedule, trigger, }, overwrite) {
+    async writeFunctionFile({ description, events, functionName, language, route, schedule, trigger, }, overwrite) {
         const fileName = toFunctionFileName(functionName);
         await this.createFile({
             extension: language,
             fileBody: getFunctionTemplate({
                 description,
                 events,
-                route,
                 functionName,
                 language,
+                route,
                 schedule,
                 trigger,
             }),

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

@@ -7,10 +7,10 @@ export default class CreateModel extends CreateCollectionCommand {
         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>;
+        fields: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        label: 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;

package/dist/commands/create/model.js

@@ -25,25 +25,25 @@ export default class CreateModel extends CreateCollectionCommand {
         },
     ];
     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',
         }),
+        events: Flags.string({
+            char: 'e',
+            default: 'created,updated,deleted',
+            description: 'list of data model events delimited by commas',
+        }),
         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',
+        label: Flags.string({
+            char: 'l',
+            default: '',
+            description: 'data model label, i.e. Products',
         }),
         overwrite: Flags.boolean({
             default: false,
@@ -54,7 +54,7 @@ export default class CreateModel extends CreateCollectionCommand {
     createType = ConfigType.MODEL;
     async run() {
         const { flags } = await this.parse(CreateModel);
-        const { label, description, collection } = await this.promptCollection();
+        const { collection, description, label } = await this.promptCollection();
         const fileName = toFileName(collection);
         const fileBody = {
             collection,
@@ -70,12 +70,12 @@ export default class CreateModel extends CreateCollectionCommand {
         }
         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' },
                 ],
+                message: 'Which events should be captured by default?',
             });
             fileBody.events = parseEvents(eventsInput);
         }

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

@@ -1,6 +1,6 @@
-import { CreateCommand } from '../../create-command.js';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
-export default class CreateNotification extends CreateCommand {
+export default class CreateNotification extends CreateConfigCommand {
     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>>;
@@ -11,12 +11,12 @@ export default class CreateNotification extends CreateCommand {
         description: string;
     }[];
     static flags: {
+        admin: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         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>;
+        subject: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     static summary: string;
     createType: ConfigType;

package/dist/commands/create/notification.js

@@ -1,10 +1,10 @@
 import { input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { singularize, capitalize } from 'inflection';
-import { CreateCommand } from '../../create-command.js';
+import { capitalize, singularize } from 'inflection';
+import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { toFileName, toNotificationLabel } from '../../lib/create/index.js';
-export default class CreateNotification extends CreateCommand {
+export default class CreateNotification extends CreateConfigCommand {
     static args = {
         model: Args.string({
             description: 'data model to trigger the notification by',
@@ -29,25 +29,20 @@ export default class CreateNotification extends CreateCommand {
         },
     ];
     static flags = {
+        admin: Flags.boolean({
+            char: 'a',
+            description: 'indicate when the notification is sent to store admins only',
+        }),
         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',
@@ -55,6 +50,11 @@ export default class CreateNotification extends CreateCommand {
         overwrite: Flags.boolean({
             description: 'overwrite existing notification configuration file',
         }),
+        subject: Flags.string({
+            char: 's',
+            default: '',
+            description: 'notification email subject',
+        }),
     };
     static summary = 'Initialize notification files and configuration with properties in the notifications folder.';
     createType = ConfigType.NOTIFICATION;
@@ -67,19 +67,19 @@ export default class CreateNotification extends CreateCommand {
                 event: flags.event,
                 model: args.model,
                 name: `${singularize(args.model)}-${args.name.replace(singularize(args.model), '')}`,
-                subject: flags.subject,
                 once: flags.once,
+                subject: flags.subject,
             }, false);
         }
         else {
-            let admin = flags.admin;
+            let { admin } = flags;
             if (admin === undefined) {
-                const choice = await await select({
-                    message: 'Who will be notified?',
+                const choice = await select({
                     choices: [
                         { name: 'Admins', value: 'admin' },
                         { name: 'Customers', value: 'customer' },
                     ],
+                    message: 'Who will be notified?',
                 });
                 if (choice === 'admin') {
                     admin = true;
@@ -87,35 +87,28 @@ export default class CreateNotification extends CreateCommand {
             }
             const collections = await this.getCollectionOptions();
             const model = await select({
+                choices: collections.map((collectionName) => ({
+                    name: collectionName,
+                    value: collectionName,
+                })),
+                loop: false,
                 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',
+                message: 'Event to trigger the notification',
             });
             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)}...`,
+                    message: 'Describe what the notification does',
+                }),
+                name: await input({
+                    default: `${singularize(model)}-${event}`,
+                    message: 'Name of the notification',
                 }),
                 once: await select({
-                    message: 'When should we send this notification?',
                     choices: [
                         {
                             name: 'Every time conditions are met',
@@ -126,23 +119,28 @@ export default class CreateNotification extends CreateCommand {
                             value: true,
                         },
                     ],
+                    message: 'When should we send this notification?',
+                }),
+                subject: await input({
+                    default: `Something happened with ${model}`,
+                    message: 'Subject of the notification email',
                 }),
             };
-            const { description, name, subject, once } = answers;
-            await this.writeNotificationFile({ admin, description, event, model, name, subject, once }, false);
+            const { description, name, once, subject } = answers;
+            await this.writeNotificationFile({ admin, description, event, model, name, once, subject }, false);
         }
     }
-    async writeNotificationFile({ admin, description, event, model, name, subject, once, }, overwrite) {
+    async writeNotificationFile({ admin, description, event, model, name, once, subject, }, 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: {},
+            event: event || 'created',
+            label: noteLabel,
             method: 'email',
+            subject: subject || `${noteLabel}...`,
         };
         fileBody.description = description;
         if (admin) {

package/dist/commands/env.d.ts

@@ -0,0 +1,12 @@
+import { Config } from '@oclif/core';
+import { SwellCommand } from '../swell-command.js';
+export default class Env extends SwellCommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        reviewBranch: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static hidden: boolean;
+    constructor(argv: string[], config: Config);
+    run(): Promise<void>;
+}

package/dist/commands/env.js

@@ -0,0 +1,31 @@
+import { Args } from '@oclif/core';
+import { env, setEnv } from '../lib/config.js';
+import style from '../lib/style.js';
+import { SwellCommand } from '../swell-command.js';
+export default class Env extends SwellCommand {
+    static args = {
+        name: Args.string({
+            description: 'name of the environment (production, staging, local, review)',
+        }),
+        reviewBranch: Args.string({
+            description: 'name of a review branch',
+        }),
+    };
+    static description = `Internal: Display the current environment configuration.`;
+    static hidden = true;
+    constructor(argv, config) {
+        super(argv, config);
+        this.requiresAuth = false;
+    }
+    async run() {
+        const { args } = await this.parse(Env);
+        const { name, reviewBranch } = args;
+        if (name) {
+            const newEnv = setEnv(name, reviewBranch);
+            this.log(`Environment set to ${style.appEnv(name)}:`, JSON.stringify(newEnv, null, 2));
+        }
+        else {
+            this.log('Current environment:', JSON.stringify(env.store, null, 2));
+        }
+    }
+}

package/dist/commands/login.d.ts

@@ -3,8 +3,8 @@ 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>;
+        store: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     static summary: string;
     constructor(argv: string[], config: Config);

package/dist/commands/login.js

@@ -11,14 +11,14 @@ 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',
         }),
+        store: Flags.string({
+            char: 's',
+            description: 'store to login to',
+        }),
     };
     static summary = 'Login to your Swell user account.';
     constructor(argv, config) {
@@ -28,32 +28,28 @@ have available for logging in to.
     async run() {
         const { flags } = await this.parse(Login);
         const { force, store } = flags;
-        let currentStoreId = config.getDefaultStore();
+        const currentStoreId = config.getDefaultStore();
         let user;
         if (currentStoreId && !force) {
             try {
                 user = await this.api.get({ adminPath: 'user' });
                 config.setUser(user);
+                this.log(`You are already logged in to ${style.storeId(currentStoreId)} as ${style.currentUser(user.username)}. Use --force to login again, or \`swell switch\` to switch stores.`);
+                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+                process.env.NODE_ENV !== 'test' && process.exit(0);
+                return;
             }
-            catch (err) {
+            catch {
                 // 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(' '));
+        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 }, force);
+        config.setUser(user);
+        this.log(`\nYou are now logged in to ${style.storeId(storeId)} as ${style.currentUser(user.username)}.`);
     }
     /**
      * Use the /user/switch API request to either get the session id for the
@@ -65,9 +61,7 @@ have available for logging in to.
      * @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 });
+        const switchResponse = await this.api.post({ adminPath: '/user/switch' }, { 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;

package/dist/commands/logs.js

@@ -189,7 +189,6 @@ export default class Logs extends SwellCommand {
     }
     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() || [];
     }

package/dist/commands/theme/dev.d.ts

@@ -0,0 +1,21 @@
+import { PushAppCommand } from '../../push-app-command.js';
+export default class AppThemeDev extends PushAppCommand {
+    static examples: string[];
+    static flags: {
+        bundle: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        local: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-push': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'storefront-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'storefront-select': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static orientation: {
+        env: string;
+    };
+    static summary: string;
+    appType: string;
+    logAppLocalUrl(storeId: string, sessionId: string): void;
+    run(): Promise<void>;
+    private findAndInstallDependencies;
+    private findAndTryScriptCommands;
+    private startThemeDevServer;
+}