@swell/cli 2.9.31 → 2.9.33

package/dist/commands/app/action.d.ts

@@ -0,0 +1,25 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppAction extends RemoteAppCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        collection: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        ids: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        record: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        settings: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        source: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        values: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        view: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private findAction;
+    private findFunctionId;
+    private getActionParams;
+    private parseValues;
+}

package/dist/commands/app/action.js

@@ -0,0 +1,233 @@
+import { Args, Flags } from '@oclif/core';
+import ora from 'ora';
+import { functionSlug, getContentActions, getModalFieldIds, getSettingsActions, } from '../../lib/apps/actions.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+const UNAVAILABLE_CODES = new Set([
+    'notfound',
+    'connrefused',
+    'proxy_notfound',
+]);
+export default class AppAction extends RemoteAppCommand {
+    static args = {
+        id: Args.string({
+            description: 'id of the action, as declared in content or settings',
+            required: true,
+        }),
+    };
+    static description = `Runs a function action of the app as the logged-in dashboard user, the way a click in the dashboard does. The action is looked up in the app's content and settings as pushed.
+
+A record action or action field needs ${style.command('--record')}, and a bulk action ${style.command('--ids')} or ${style.command('--all')}. Pass the values of the action's modal with ${style.command('--values')}. When the same id is declared in more than one place, pick one with ${style.command('--collection')}, ${style.command('--view')}, ${style.command('--settings')} or ${style.command('--source')}.`;
+    static examples = [
+        'swell app action sync_now',
+        'swell app action ship --record 64e8dfb633c44a0039477251',
+        `swell app action ship --record 64e8dfb633c44a0039477251 --values '{"carrier":"ups"}'`,
+        'swell app action ship-selected --ids 64e8dfb633c44a0039477251,64e8dfb633c44a0039477252',
+        'swell app action ship --collection shipments --view edit --record 64e8dfb633c44a0039477251',
+        'swell app action export --source bulk --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            description: 'run a bulk action on all records its view lists with no filters set, as selecting all in the dashboard does',
+            exclusive: ['ids'],
+        }),
+        collection: Flags.string({
+            description: "collection of the content that declares the action, or the model's name for a collection of the app",
+        }),
+        ids: Flags.string({
+            description: 'comma-separated ids of the records a bulk action runs on',
+            exclusive: ['all'],
+        }),
+        live: Flags.boolean({
+            default: false,
+            description: 'run in the live environment instead of test',
+        }),
+        record: Flags.string({
+            description: 'id of the record a record action or action field runs on',
+        }),
+        settings: Flags.string({
+            description: 'name of the settings that declare the action',
+        }),
+        source: Flags.string({
+            description: "where the action is declared: list or record (a view's actions), bulk (a view's bulk actions), field (an action field) or settings (a settings action)",
+            options: ['list', 'record', 'bulk', 'field', 'settings'],
+        }),
+        values: Flags.string({
+            description: "values of the action's modal fields, as JSON",
+        }),
+        view: Flags.string({
+            description: 'id of the content view that declares the action',
+        }),
+    };
+    static summary = 'Run an app action from the command line.';
+    async run() {
+        const { args, flags } = await this.parse(AppAction);
+        const values = flags.values === undefined ? undefined : this.parseValues(flags.values);
+        if (!flags.live) {
+            await this.api.setEnv('test');
+        }
+        this.app = await this.getAppWithConfig();
+        const action = await this.findAction(args.id, flags);
+        const $action = this.getActionParams(action, { ...flags, values });
+        const functionId = await this.findFunctionId(action.function);
+        const name = style.appConfigValue(action.id);
+        const spinner = ora();
+        spinner.start(`Running action ${name}...`);
+        const result = await this.handleRequestErrors(async () => this.api.put({ adminPath: `/data/:functions/${functionId}` }, { body: { $action } }), () => spinner.fail(`Action ${action.id} failed`));
+        if (!(result?.status >= 200 && result.status < 300)) {
+            spinner.fail(`Action ${name} failed`);
+            this.error(getErrorMessage(result, name));
+        }
+        // A workflow runs in the background, so the platform answers with the run
+        // it started
+        const run = result.response?.run;
+        if (result.status === 202 && run?.id && run.workflow_name) {
+            spinner.succeed(`Started run ${style.appConfigValue(run.id)} of workflow ${style.appConfigValue(run.workflow_name)}`);
+            return;
+        }
+        spinner.succeed(`Ran action ${name}`);
+        if (result.response !== undefined) {
+            this.log(JSON.stringify(result.response, null, 2));
+        }
+    }
+    async findAction(id, flags) {
+        const [contents, settings] = await Promise.all([
+            this.api.get({ adminPath: '/data/:content' }, { query: { app_id: this.app.id, limit: 1000 } }),
+            this.api.get({ adminPath: `/data/:settings/${this.app.id}` }),
+        ]);
+        const actions = [
+            ...(contents?.results || []).flatMap((content) => getContentActions(content).map((action) => ({
+                ...action,
+                collection: content.collection,
+                content_id: content.id,
+            }))),
+            ...Object.entries(settings?.content || {}).flatMap(([name, values]) => getSettingsActions(values, name)),
+        ];
+        // Content of the app's own model has the collection apps/<app id>/<model>
+        const appCollection = `apps/${this.app.id}/`;
+        const matches = actions.filter((action) => action.id === id &&
+            (!flags.collection ||
+                action.collection === flags.collection ||
+                action.collection === `${appCollection}${flags.collection}`) &&
+            (!flags.view || action.view === flags.view) &&
+            (!flags.settings || action.settings === flags.settings) &&
+            (!flags.source || action.source === flags.source));
+        if (matches.length === 0) {
+            this.error(`Action ${style.appConfigValue(id)} not found in the app's content or settings. Push the app first if it is new.`);
+        }
+        if (matches.length > 1) {
+            this.error(`Action ${style.appConfigValue(id)} is declared in more than one place:\n${matches
+                .map((action) => `  ${describePlace(action, appCollection)}`)
+                .join('\n')}\nPick one with --collection, --view, --settings or --source.`);
+        }
+        return matches[0];
+    }
+    async findFunctionId(name) {
+        const functions = await this.api.get({ adminPath: '/data/:functions' }, { query: { app_id: this.app.id, fields: 'id, name', limit: 1000 } });
+        const record = (functions?.results || []).find((record) => functionSlug(record.name) === functionSlug(name));
+        if (!record) {
+            this.error(`Function ${style.appConfigValue(name)} of the action is not installed. Push the app first.`);
+        }
+        return record.id;
+    }
+    getActionParams(action, flags) {
+        const name = style.appConfigValue(action.id);
+        const isBulk = action.source === 'bulk';
+        const needsRecord = action.source === 'record' ||
+            (action.source === 'field' && !action.settings);
+        if (needsRecord && !flags.record) {
+            this.error(`Action ${name} runs on a record: pass --record.`);
+        }
+        if (!needsRecord && flags.record) {
+            this.error(isBulk
+                ? `Action ${name} is a bulk action, which runs on --ids or --all: leave out --record.`
+                : `Action ${name} does not run on a record: leave out --record.`);
+        }
+        if (isBulk && !flags.ids && !flags.all) {
+            this.error(`Action ${name} is a bulk action: pass --ids or --all.`);
+        }
+        if (!isBulk && (flags.ids || flags.all)) {
+            this.error(`Action ${name} is not a bulk action: leave out ${flags.ids ? '--ids' : '--all'}.`);
+        }
+        // The platform passes on only the values of the modal's fields
+        if (flags.values) {
+            if (!action.modal) {
+                this.error(`Action ${name} has no modal: leave out --values.`);
+            }
+            const fieldIds = getModalFieldIds(action.modal);
+            const unknownKeys = Object.keys(flags.values).filter((key) => !fieldIds.includes(key));
+            if (unknownKeys.length > 0) {
+                this.error(`--values names fields that the modal of action ${name} does not have: ${unknownKeys.join(', ')}.`);
+            }
+        }
+        return {
+            id: action.id,
+            source: action.source,
+            ...(action.settings
+                ? { settings: action.settings }
+                : { content_id: action.content_id }),
+            ...(action.view ? { view: action.view } : undefined),
+            ...(needsRecord ? { record_id: flags.record } : undefined),
+            ...(isBulk
+                ? { selection: getSelection(flags.ids, action.query) }
+                : undefined),
+            ...(flags.values ? { values: flags.values } : undefined),
+        };
+    }
+    parseValues(values) {
+        let parsed;
+        try {
+            parsed = JSON.parse(values);
+        }
+        catch {
+            // ignore
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            this.error('--values must be a JSON object of the modal field values, like \'{"carrier":"ups"}\'');
+        }
+        return parsed;
+    }
+}
+// The function answers as it likes, so only a string is a message
+function resultMessage(message) {
+    return typeof message === 'string' ? message : '';
+}
+// As the dashboard reads a result that did not succeed
+function getErrorMessage(result, name) {
+    const { code, response } = result || {};
+    if (code === 'timeout') {
+        return `Action ${name} did not finish within the time limit. It may still be running; check before running it again.`;
+    }
+    if (UNAVAILABLE_CODES.has(code)) {
+        return 'The app function is unavailable.';
+    }
+    return (resultMessage(response?.$reject?.message) ||
+        resultMessage(response?.error?.message) ||
+        resultMessage(response?.error) ||
+        `Action ${name} failed`);
+}
+function describePlace(action, appCollection) {
+    const collection = action.collection?.startsWith(appCollection)
+        ? action.collection.slice(appCollection.length)
+        : action.collection;
+    return action.settings
+        ? `settings ${action.settings} (${action.source})`
+        : `content ${collection}${action.view ? `, view ${action.view}` : ''} (${action.source})`;
+}
+// As the dashboard selects records: by their ids, or all of them that the
+// view lists with no filters set
+function getSelection(ids, viewQuery = {}) {
+    if (!ids) {
+        return { all: true, count: null, query: viewQuery };
+    }
+    const list = ids
+        .split(',')
+        .map((id) => id.trim())
+        .filter(Boolean);
+    return {
+        all: false,
+        count: list.length,
+        ids: list,
+        query: { $and: [{ id: { $in: list } }] },
+    };
+}

package/dist/commands/app/dev.js

@@ -105,7 +105,8 @@ export default class AppDev extends PushAppCommand {
         this.jsonEvents = flags['json-events'];
         this.setStoreUser(flags['store-user']);
         this.functionFilter = flags.function ?? null;
-        if (!(await this.ensureAppExists(undefined, false))) {
+        // A pushing dev run updates the app from swell.json first, as a push does
+        if (!(await this.ensureAppExists(undefined, !noPush))) {
             return;
         }
         if (!noPush) {

package/dist/commands/app/frontend/deploy.d.ts

@@ -12,5 +12,6 @@ export default class AppFrontendDeploy extends PushAppCommand {
         env: string;
     };
     static summary: string;
+    protected pushesSwellJson(): boolean;
     run(): Promise<void>;
 }

package/dist/commands/app/frontend/deploy.js

@@ -31,6 +31,10 @@ If deployment fails, correct any reported errors and run this command again.`;
         env: 'test',
     };
     static summary = `Push frontend files to your Swell app.`;
+    // A deploy pushes no app files, so it applies nothing of the listing
+    pushesSwellJson() {
+        return false;
+    }
     async run() {
         const { flags } = await this.parse(AppFrontendDeploy);
         const { force } = flags;

package/dist/commands/app/frontend/dev.js

@@ -42,10 +42,12 @@ export default class AppFrontendDev extends PushAppCommand {
         const { port, 'proxy-port': proxyPort, 'app-dev': isAppDev } = flags;
         const noPush = flags['no-push'];
         this.setStoreUser(flags['store-user']);
-        if (!(await this.ensureAppExists(undefined, false))) {
+        const isPushing = !noPush && !isAppDev;
+        // A pushing dev run updates the app from swell.json first, as a push does
+        if (!(await this.ensureAppExists(undefined, isPushing))) {
             return;
         }
-        if (!noPush && !isAppDev) {
+        if (isPushing) {
             await this.pushAppConfigs();
         }
         if (this.app.type === 'storefront') {

package/dist/commands/app/push.d.ts

@@ -28,5 +28,8 @@ export default class AppPush extends PushAppCommand {
      */
     confirmPushConflicts(conflictsFlag?: string, file?: string): Promise<boolean>;
     run(): Promise<void>;
+    protected pushesSwellJson(file?: string): boolean;
+    private checkActionFunctions;
+    private enableAutoDisabledFunctions;
     private exitIfFilesFailed;
 }

package/dist/commands/app/push.js

@@ -1,6 +1,9 @@
 import { Args, Flags } from '@oclif/core';
 import * as path from 'node:path';
-import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, isPathDirectory, sameIntegrations, } from '../../lib/apps/index.js';
+import ora from 'ora';
+import { functionSlug, getContentActions, getSettingsActions, } from '../../lib/apps/actions.js';
+import { affectsFrontendDeployment, AllConfigPaths, filePathExistsAsync, getNameFromFilePath, isPathDirectory, sameIntegrations, toPosixPath, } from '../../lib/apps/index.js';
+import { isCredentialFile } from '../../lib/apps/paths.js';
 import { default as localConfig } from '../../lib/config.js';
 import style from '../../lib/style.js';
 import { PushAppCommand } from '../../push-app-command.js';
@@ -19,7 +22,7 @@ If the app does not exist, it will be created and its global ID saved to a .swel
 
 - If no file is specified, all configuration files will be pushed to the store.
   This includes the app icon (assets/icon.png), screenshots (assets/screenshots/),
-  README.md, and swell.json.
+  DESCRIPTION.md, and swell.json.
 - If a file is specified, only that file will be pushed to the store.
 - If a directory is specified, only files in that directory will be pushed.
 
@@ -147,10 +150,17 @@ ${Object.values(AllConfigPaths)
                     ? this.pushFilePath(relativePath, force)
                     : this.pushFile(relativePath));
                 // Uploading frontend sources doesn't change what the Worker serves,
-                // so scoped pushes need the same pipeline as an unscoped one
-                if (!noDeploy && affectsFrontendDeployment(relativePath)) {
+                // so scoped pushes need the same pipeline as an unscoped one. A
+                // credential file named on its own is refused and deploys nothing
+                if (!noDeploy &&
+                    affectsFrontendDeployment(relativePath) &&
+                    !isCredentialFile(relativePath)) {
                     await this.deployAppFrontend(force);
                 }
+                await this.checkActionFunctions(toPosixPath(relativePath));
+                if (toPosixPath(relativePath).split('/')[0] === 'functions') {
+                    await this.enableAutoDisabledFunctions();
+                }
                 this.log();
                 this.logDashboardUrl(flags);
                 this.exitIfFilesFailed();
@@ -158,6 +168,8 @@ ${Object.values(AllConfigPaths)
             }
         }
         await this.pushAppConfigs(force);
+        await this.checkActionFunctions();
+        await this.enableAutoDisabledFunctions();
         if (!noDeploy) {
             await this.deployAppFrontend(force);
             this.log();
@@ -165,6 +177,90 @@ ${Object.values(AllConfigPaths)
         this.logDashboardUrl(flags);
         this.exitIfFilesFailed();
     }
+    // The app path is the working directory unless --app-path names it, so a
+    // scoped push's file resolves here as in resolvePushPaths
+    pushesSwellJson(file) {
+        if (!file) {
+            return true;
+        }
+        const relativePath = path.relative(this.appPath, path.resolve(this.appPath, file));
+        return relativePath === '' || relativePath === 'swell.json';
+    }
+    // Content and settings are installed before functions, so their actions
+    // are checked against the app's functions once the push is done. A scoped
+    // push fails only for the files it pushed, and for the files whose action
+    // function it pushed or removed.
+    async checkActionFunctions(scope) {
+        const configs = await this.api
+            .getAll({ adminPath: `/apps/${this.app.id}/configs` }, { query: { type: { $in: ['function', 'content', 'setting'] } } })
+            .catch((error) => {
+            ora().warn(`Skipped checking the actions against the app functions: ${error.message}`);
+            return null;
+        });
+        if (!configs) {
+            return;
+        }
+        const { results } = configs;
+        const actionFunctions = new Set(results
+            .filter((config) => config.type === 'function' && config.values?.action)
+            .map((config) => functionSlug(config.name)));
+        const inScope = (filePath) => !scope || filePath === scope || filePath?.startsWith(`${scope}/`);
+        // The app's configs from before the push still name the functions it
+        // removed
+        const pushedFunctions = new Set([...results, ...(this.app.configs || [])]
+            .filter((config) => config.type === 'function' && inScope(config.file_path))
+            .map((config) => functionSlug(config.name)));
+        for (const config of results) {
+            const actions = config.type === 'content'
+                ? getContentActions(config.values)
+                : config.type === 'setting'
+                    ? getSettingsActions(config.values, config.name)
+                    : [];
+            const missing = actions.filter((action) => !actionFunctions.has(functionSlug(action.function)));
+            let failed = false;
+            for (const action of missing) {
+                const message = `${config.file_path}: action "${action.id}" runs function "${action.function}", which the app does not have as an action function`;
+                if (inScope(config.file_path) ||
+                    pushedFunctions.has(functionSlug(action.function))) {
+                    ora().fail(message);
+                    failed = true;
+                }
+                else {
+                    ora().warn(message);
+                }
+            }
+            if (failed && !this.failedFiles.includes(config.file_path)) {
+                this.failedFiles.push(config.file_path);
+            }
+        }
+    }
+    // The platform switches off a function that keeps failing, and only an
+    // install of its config switches it on again, which a push skips for an
+    // unchanged file. Switching it on also resends the events it missed.
+    async enableAutoDisabledFunctions() {
+        try {
+            const { results } = await this.api.getAll({ adminPath: '/data/:functions' }, {
+                query: {
+                    app_id: this.app.id,
+                    auto_disabled: true,
+                    fields: 'id, name',
+                },
+            });
+            // A function whose push just failed stays off, as it would fail again
+            const failedNames = new Set(this.failedFiles
+                .filter((filePath) => path.posix.dirname(filePath) === AllConfigPaths.FUNCTION)
+                .map((filePath) => getNameFromFilePath(filePath)));
+            const disabled = (results || []).filter((fn) => !failedNames.has(fn.name));
+            if (disabled.length === 0) {
+                return;
+            }
+            await Promise.all(disabled.map((fn) => this.api.put({ adminPath: `/data/:functions/${fn.id}` }, { body: { enabled: true } })));
+            ora().succeed(`Re-enabled ${disabled.length} auto-disabled function${disabled.length === 1 ? '' : 's'}: ${disabled.map((fn) => fn.name).join(', ')}`);
+        }
+        catch (error) {
+            ora().warn(`Skipped re-enabling auto-disabled functions: ${error.message}`);
+        }
+    }
     // A skipped file is a failed push, for scripts and CI too
     exitIfFilesFailed() {
         if (this.failedFiles.length > 0) {

package/dist/commands/app/version.js

@@ -121,6 +121,9 @@ behavior by using the --no-git-tag option.`;
             return;
         }
         nextVersion = await this.validateAndComputeVersion(nextVersion, localVersion);
+        // The app takes its details from swell.json before any upload, as a push
+        // does, so that details the app refuses fail first
+        this.app = await this.getCreateUpdateApp(this.app);
         await this.pushAppConfigs();
         await this.deployAppFrontend(false, false);
         if (!message) {

package/dist/commands/create/function.js

@@ -4,7 +4,7 @@ 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'];
+const PERMITTED_TRIGGERS = ['cron', 'model', 'route', 'action'];
 const PERMITTED_MODES = [...PERMITTED_TRIGGERS, 'workflow'];
 export default class CreateFunction extends CreateConfigCommand {
     static args = {
@@ -14,7 +14,7 @@ export default class CreateFunction extends CreateConfigCommand {
         }),
         trigger: Args.string({
             default: '',
-            description: 'cron | model | route | workflow',
+            description: 'cron | model | route | action | workflow',
             options: PERMITTED_MODES,
         }),
     };
@@ -23,6 +23,7 @@ export default class CreateFunction extends CreateConfigCommand {
         '$ swell create function order-handler.ts model -e order.created,order.updated -y',
         '$ swell create function cleanup.ts cron -s "0 0 * * *" -y',
         '$ swell create function api-endpoint.ts route -r public -y',
+        '$ swell create function mark-shipped.ts action -y',
         '$ swell create function run-import.ts --type workflow -y',
         '$ swell create function run-import.ts workflow -y',
     ];
@@ -46,6 +47,11 @@ export default class CreateFunction extends CreateConfigCommand {
                     flag: '-r, --route=<option>',
                     description: 'Access: public (default) | private',
                 },
+                {
+                    name: 'action',
+                    flag: '',
+                    description: 'Runs from a dashboard action',
+                },
                 {
                     name: 'workflow',
                     flag: '--type=workflow',
@@ -104,7 +110,7 @@ export default class CreateFunction extends CreateConfigCommand {
             }
             // Validate trigger argument
             if (!trigger) {
-                this.error('Missing required argument for non-interactive mode: TRIGGER or --type workflow\n\nValid modes: cron, model, route, workflow\n\nExample: swell create function my-func.ts model -e order.created -y\nExample: swell create function run-import.ts --type workflow -y', { exit: 1 });
+                this.error('Missing required argument for non-interactive mode: TRIGGER or --type workflow\n\nValid modes: cron, model, route, action, workflow\n\nExample: swell create function my-func.ts model -e order.created -y\nExample: swell create function run-import.ts --type workflow -y', { exit: 1 });
             }
             // Validate filename has extension
             const language = args.name.endsWith('.ts')
@@ -212,6 +218,10 @@ export default class CreateFunction extends CreateConfigCommand {
                         name: 'HTTP (route)',
                         value: 'route',
                     },
+                    {
+                        name: 'Dashboard action (action)',
+                        value: 'action',
+                    },
                 ],
                 message: 'How will your function be triggered?',
             });
@@ -290,7 +300,7 @@ export default class CreateFunction extends CreateConfigCommand {
         if (typeFlag === 'workflow') {
             if (positionalTrigger &&
                 PERMITTED_TRIGGERS.includes(positionalTrigger)) {
-                this.error('--type workflow cannot be combined with a positional cron, model, or route trigger.', { exit: 1 });
+                this.error('--type workflow cannot be combined with a positional cron, model, route, or action trigger.', { exit: 1 });
             }
             return 'workflow';
         }

package/dist/commands/create/model.js

@@ -3,7 +3,7 @@ import { Args, Flags } from '@oclif/core';
 import { CreateCollectionCommand } from '../../create-collection-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { toCollectionLabel, toCollectionName, toFileName, } from '../../lib/create/index.js';
-import { parseEvents, parseFields, } from '../../lib/create/model.js';
+import { FIELD_TYPES, fieldPairProblem, parseEvents, parseFields, } from '../../lib/create/model.js';
 import { SCHEMAS } from '../../lib/create/schemas.js';
 export default class CreateModel extends CreateCollectionCommand {
     static args = {
@@ -16,7 +16,8 @@ export default class CreateModel extends CreateCollectionCommand {
     static examples = [
         '$ swell create model',
         '$ swell create model products -y',
-        '$ swell create model visitors -f title:string,photo:string -l "Visitors" -y',
+        '$ swell create model visitors -f title:string,photo:file -l "Visitors" -y',
+        '$ swell create model reviews -f owner:link:accounts,tags:array:string -y',
     ];
     static helpMeta = {
         usageDirect: '<collection> [...] -y',
@@ -35,7 +36,7 @@ export default class CreateModel extends CreateCollectionCommand {
         fields: Flags.string({
             char: 'f',
             default: '',
-            description: 'Fields as id:type pairs (e.g., title:string,price:currency)',
+            description: 'Fields as id:type pairs, id:link:<model> or id:array:<type> (e.g., title:string,owner:link:accounts)',
         }),
         events: Flags.string({
             char: 'e',
@@ -58,14 +59,6 @@ export default class CreateModel extends CreateCollectionCommand {
         const confirmYes = Boolean(flags.yes);
         // Helper validators
         const validEventValues = ['created', 'updated', 'deleted'];
-        const validFieldTypes = [
-            'collection',
-            'currency',
-            'image',
-            'int',
-            'link',
-            'string',
-        ];
         const validateEvents = (values) => {
             const invalid = values.filter((v) => !validEventValues.includes(v));
             if (invalid.length > 0) {
@@ -73,19 +66,11 @@ export default class CreateModel extends CreateCollectionCommand {
             }
         };
         const validateFields = (pairs) => {
-            const invalid = [];
-            for (const pair of pairs) {
-                if (!pair.includes(':')) {
-                    invalid.push(pair);
-                    continue;
-                }
-                const type = pair.split(':')[1]?.trim();
-                if (!validFieldTypes.includes(type)) {
-                    invalid.push(pair);
-                }
-            }
-            if (invalid.length > 0) {
-                this.error(`Invalid field(s): ${invalid.join(', ')}\n\nValid types: ${validFieldTypes.join(', ')}\n\nExample: swell create model visitors -f title:string,price:currency -y`, { exit: 1 });
+            const problems = pairs
+                .map((pair) => fieldPairProblem(pair))
+                .filter(Boolean);
+            if (problems.length > 0) {
+                this.error(`Invalid field(s):\n  ${problems.join('\n  ')}\n\nValid types: ${FIELD_TYPES.filter((type) => type !== 'collection').join(', ')}\n\nExample: swell create model visitors -f title:string,owner:link:accounts,tags:array:string -y`, { exit: 1 });
             }
         };
         if (confirmYes) {

package/dist/commands/create/webhook.js

@@ -1,4 +1,4 @@
-import { confirm, input } from '@inquirer/prompts';
+import { input } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
 import { CreateConfigCommand } from '../../create-config-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
@@ -16,7 +16,7 @@ export default class CreateWebhook extends CreateConfigCommand {
     static examples = [
         '$ swell create webhook',
         '$ swell create webhook order-sync -u https://example.com/hook -e order.created -y',
-        '$ swell create webhook payment-handler -u https://api.example.com/payments -e payment.succeeded,payment.failed --enabled -y',
+        '$ swell create webhook payment-handler -u https://api.example.com/payments -e payment.succeeded,payment.failed --no-enabled -y',
     ];
     static helpMeta = {
         usageDirect: '<name> -u <url> -e <events> [...] -y',
@@ -38,8 +38,9 @@ export default class CreateWebhook extends CreateConfigCommand {
             description: 'Description',
         }),
         enabled: Flags.boolean({
-            default: false,
-            description: 'Enable webhook (default: false)',
+            allowNo: true,
+            default: true,
+            description: 'Enable webhook (default: true)',
         }),
         overwrite: Flags.boolean({
             default: false,
@@ -148,21 +149,14 @@ export default class CreateWebhook extends CreateConfigCommand {
             events = parseEvents(eventsInput);
         }
         // Description prompt (optional)
-        let { description, enabled } = flags;
-        const { overwrite } = flags;
+        let { description } = flags;
+        const { enabled, overwrite } = flags;
         if (!description) {
             description = await input({
                 default: '',
                 message: 'Describe what this webhook does',
             });
         }
-        // Enabled prompt (optional)
-        if (!enabled) {
-            enabled = await confirm({
-                default: false,
-                message: 'Enable webhook now?',
-            });
-        }
         const fileName = toFileName(name);
         const fileBody = {
             $schema: SCHEMAS.WEBHOOK,