@swell/cli 2.0.20 → 2.2.0

package/dist/commands/create/model.js

@@ -1,27 +1,36 @@
 import { checkbox } from '@inquirer/prompts';
-import { Flags } from '@oclif/core';
+import { Args, 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 { toCollectionLabel, toCollectionName, toFileName, } from '../../lib/create/index.js';
 import { parseEvents, parseFields, } from '../../lib/create/model.js';
+import { SCHEMAS } from '../../lib/create/schemas.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 args = {
+        collection: Args.string({
+            default: '',
+            description: 'collection ID to create or apply to, e.g., products (required with -y)',
+        }),
+    };
+    static description = `Interactive mode: choose to create a new collection or extend an existing standard collection. The CLI will propose a list of standard collections you can extend.
+
+Non-interactive (-y): provide COLLECTION explicitly. To discover standard collections first, run: swell inspect models.`;
     static examples = [
         {
             command: 'swell create model',
-            description: 'Create data model configuration interactively.',
+            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 products -y',
+            description: 'Apply configuration to a standard collection (non-interactive)',
         },
         {
-            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 -e created,updated -f title:string,photo:image -l "Visitors" -d "" -y',
+            description: 'Create custom collection with explicit fields (non-interactive)',
         },
         {
-            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.',
+            command: 'swell inspect models',
+            description: 'List standard collections available for extending',
         },
     ];
     static flags = {
@@ -33,40 +42,129 @@ export default class CreateModel extends CreateCollectionCommand {
         events: Flags.string({
             char: 'e',
             default: 'created,updated,deleted',
-            description: 'list of data model events delimited by commas',
+            description: 'comma-separated events - valid: created, updated, deleted',
         }),
         fields: Flags.string({
             char: 'f',
             default: '',
-            description: 'list of data model fields delimited by commas',
+            description: 'comma-separated id:type pairs (e.g., title:string, price:currency). Types: collection, currency, image, int, link, string',
         }),
         label: Flags.string({
             char: 'l',
             default: '',
-            description: 'data model label, i.e. Products',
+            description: 'display label for the model (defaults to capitalized collection name)',
         }),
         overwrite: Flags.boolean({
             default: false,
-            description: 'Overwrite existing data model configuration file.',
+            description: 'overwrite existing data model configuration file (use with -y to force overwrite)',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'accept all default values; non-interactive, never prompts; errors if required values are missing',
         }),
     };
-    static summary = 'Initialize a data model config file with properties in the models folder.';
+    static summary = 'Create or extend a data model configuration in the models folder.';
     createType = ConfigType.MODEL;
     async run() {
-        const { flags } = await this.parse(CreateModel);
+        const { args, flags } = await this.parse(CreateModel);
+        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) {
+                this.error(`Invalid event(s): ${invalid.join(', ')}\n\nValid events: ${validEventValues.join(', ')}\n\nExample: swell create model visitors -e created,updated -y`, { exit: 1 });
+            }
+        };
+        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 });
+            }
+        };
+        if (confirmYes) {
+            const argCollection = args.collection;
+            if (!argCollection) {
+                this.error('Missing required argument for non-interactive mode: COLLECTION\n\nExample: swell create model products -y\n\nTip: run `swell inspect models` to list standard collections you can extend.', { exit: 1 });
+            }
+            const collection = toCollectionName(argCollection);
+            const label = flags.label || toCollectionLabel(collection);
+            const description = flags.description || '';
+            const eventsRaw = (flags.events || 'created,updated,deleted');
+            const eventsList = eventsRaw
+                .split(',')
+                .map((v) => v.trim())
+                .filter(Boolean);
+            validateEvents(eventsList);
+            const fieldsRaw = (flags.fields || '');
+            const fieldPairs = fieldsRaw
+                ? fieldsRaw
+                    .split(',')
+                    .map((v) => v.trim())
+                    .filter(Boolean)
+                : [];
+            validateFields(fieldPairs);
+            const fileName = toFileName(collection);
+            const fileBody = {
+                $schema: SCHEMAS.MODEL,
+                collection,
+                description,
+                fields: parseFields(fieldPairs),
+                label,
+                events: parseEvents(eventsList),
+            };
+            await this.createFile({ fileBody, fileName }, flags.overwrite, 
+            /* shouldConfirm */ false);
+            return;
+        }
+        // Interactive flow (prompts)
         const { collection, description, label } = await this.promptCollection();
         const fileName = toFileName(collection);
         const fileBody = {
+            $schema: SCHEMAS.MODEL,
             collection,
         };
         const { events, fields, overwrite } = flags;
-        if (label) {
+        if (label)
             fileBody.label = label;
-        }
         fileBody.description = description;
-        fileBody.fields = fields ? parseFields(fields.split(',')) : {};
-        if (fileBody.events) {
-            fileBody.events = events ? parseEvents(events.split(',')) : {};
+        if (fields) {
+            const pairs = fields
+                .split(',')
+                .map((v) => v.trim())
+                .filter(Boolean);
+            validateFields(pairs);
+            fileBody.fields = parseFields(pairs);
+        }
+        else {
+            fileBody.fields = {};
+        }
+        // If events were provided via flag, use them; otherwise prompt
+        if (events && events !== 'created,updated,deleted') {
+            const eventsList = events
+                .split(',')
+                .map((v) => v.trim())
+                .filter(Boolean);
+            validateEvents(eventsList);
+            fileBody.events = parseEvents(eventsList);
         }
         else {
             const eventsInput = await checkbox({
@@ -79,9 +177,6 @@ export default class CreateModel extends CreateCollectionCommand {
             });
             fileBody.events = parseEvents(eventsInput);
         }
-        await this.createFile({
-            fileBody,
-            fileName,
-        }, overwrite);
+        await this.createFile({ fileBody, fileName }, overwrite);
     }
 }

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

@@ -0,0 +1,25 @@
+import { SwellCommand } from '../../swell-command.js';
+export default class Content extends SwellCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        'content-id': import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    protected catch(error: Error): Promise<any>;
+    private listContent;
+    private showContentViews;
+    private showContentView;
+    private resolveContentId;
+    private showContentDetail;
+    private reverseResolveContentId;
+    private getAppBySlug;
+    private getAppSlugId;
+    private throwContentNotFound;
+    private showContent;
+}

package/dist/commands/inspect/content.js

@@ -0,0 +1,159 @@
+import { Args, Flags } from '@oclif/core';
+import { FetchError } from 'node-fetch';
+import { default as localConfig } from '../../lib/config.js';
+import { SwellCommand } from '../../swell-command.js';
+export default class Content extends SwellCommand {
+    static summary = 'Inspect content view extensions deployed in your store.';
+    static description = `
+View content view extensions available in your Swell store.
+
+Without a content ID, this command lists all available content views.
+With a content ID, it retrieves the configuration for that specific content view in JSON format.
+`;
+    static args = {
+        'content-id': Args.string({
+            description: 'Optional content view ID. Example: custom.admin.products, app.myapp.products',
+            required: false,
+        }),
+    };
+    static flags = {
+        live: Flags.boolean({
+            description: 'Use the live environment instead of test (default: test).',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Accept all prompts automatically (for agent compatibility; no functional effect).',
+            default: false,
+        }),
+    };
+    static examples = [
+        'swell inspect content',
+        'swell inspect content custom.admin.products',
+        'swell inspect content app.honest_reviews.reviews',
+        'swell inspect content app.myapp.products --live',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Content);
+        const { 'content-id': contentId } = args;
+        const { live } = flags;
+        if (!live) {
+            await this.api.setEnv('test');
+        }
+        // Detail mode: show configuration for a specific content view
+        if (contentId) {
+            await this.showContentDetail(contentId);
+            return;
+        }
+        const store = localConfig.getDefaultStore();
+        // List mode: show all content views
+        await this.listContent(store, live);
+    }
+    async catch(error) {
+        if (error instanceof FetchError) {
+            const message = `Could not connect to Swell API. Please try again later: ${error.message}`;
+            return this.error(message, { exit: 2, code: error.code });
+        }
+        return this.error(error.message, { exit: 1 });
+    }
+    async listContent(store, live) {
+        const { results: apps } = await this.api.get({
+            adminPath: '/apps',
+        });
+        const appsById = Object.fromEntries(apps.map((app) => [app.id, app]));
+        const { results: contentViews } = await this.api.getAll({
+            adminPath: '/data/:content',
+        });
+        // Sort by resolved ID in reverse order (custom.* first)
+        const sortedContentViews = [...contentViews].sort((a, b) => {
+            const resolvedA = this.resolveContentId(a, appsById);
+            const resolvedB = this.resolveContentId(b, appsById);
+            return resolvedB.localeCompare(resolvedA);
+        });
+        this.log(`Content views extensions available in '${store}' ${live ? '[live]' : '[test]'}:`);
+        this.log();
+        this.showContentViews(sortedContentViews, appsById);
+        // Show next step hints
+        this.log();
+        this.log('Examples:');
+        this.log('  swell inspect content custom.admin.products');
+        this.log('  swell inspect content app.honest_reviews.accounts');
+    }
+    showContentViews(contentViews, appsById) {
+        const maxNameWidth = Math.max(...contentViews.map((cv) => cv.name.length), 15);
+        for (const cv of contentViews) {
+            this.showContentView(cv, maxNameWidth, appsById);
+        }
+    }
+    showContentView(contentView, nameWidth, appsById) {
+        const resolvedId = this.resolveContentId(contentView, appsById);
+        const paddedName = contentView.name.padEnd(nameWidth + 2);
+        this.log(`${paddedName}${resolvedId}`);
+    }
+    resolveContentId(contentView, appsById) {
+        const { id, name } = contentView;
+        // Parse ID: app.{appId}.{name} or custom.{source}.{name}
+        const match = id.match(/^(app|custom)\.([^.]+)\.(.+)$/);
+        if (!match)
+            return id; // fallback to original
+        const [, type, identifier] = match;
+        if (type === 'custom') {
+            return id; // custom IDs are already resolved
+        }
+        // type === 'app': resolve app ID to slug
+        const appId = identifier;
+        const app = appsById[appId];
+        if (!app) {
+            return id; // fallback if app not found
+        }
+        const appSlug = this.getAppSlugId(app);
+        return `app.${appSlug}.${name}`;
+    }
+    async showContentDetail(resolvedId) {
+        // Reverse resolve to get unresolved ID for API
+        const unresolvedId = await this.reverseResolveContentId(resolvedId);
+        // Fetch content view
+        const content = await this.api.get({
+            adminPath: `/data/:content/${unresolvedId}`,
+        });
+        if (!content) {
+            this.throwContentNotFound(resolvedId);
+        }
+        this.showContent(content);
+    }
+    async reverseResolveContentId(resolvedId) {
+        // Parse ID: app.{slug}.{name} or custom.{source}.{name}
+        const match = resolvedId.match(/^(app|custom)\.([^.]+)\.(.+)$/);
+        if (!match) {
+            throw new Error(`Invalid content ID format: ${resolvedId}`);
+        }
+        const [, type, identifier, name] = match;
+        if (type === 'custom') {
+            return resolvedId; // custom IDs don't need reverse resolution
+        }
+        // Check if identifier is already an app ID (ObjectID format)
+        if (identifier.match(/^[0-9a-f]{24}$/)) {
+            return resolvedId; // already unresolved format
+        }
+        // type === 'app': resolve slug to app ID
+        const appSlug = identifier;
+        const app = await this.getAppBySlug(appSlug);
+        return `app.${app.id}.${name}`;
+    }
+    async getAppBySlug(slug) {
+        const app = await this.api.get({ adminPath: `/apps/${slug}` });
+        if (!app) {
+            throw new Error(`App '${slug}' not found.\nList available content: swell inspect content`);
+        }
+        return app;
+    }
+    getAppSlugId(app) {
+        return app.public_id || app.private_id.replace(/^_/, '');
+    }
+    throwContentNotFound(id) {
+        throw new Error(`No content view found for '${id}'.\nList available content: swell inspect content`);
+    }
+    showContent(content) {
+        this.log(JSON.stringify(content, null, 2));
+    }
+}

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

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

package/dist/commands/inspect/index.js

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class Inspect extends Command {
+    static summary = 'Inspect deployed artifacts in your store.';
+    static description = `View configuration and data for deployed resources.
+
+Inspect models, content views, and other deployed artifacts in your Swell store.`;
+    static examples = [
+        'swell inspect models',
+        'swell inspect models /products',
+        'swell inspect models /apps/myapp/orders',
+    ];
+    async run() {
+        this.log('Use "swell inspect models" to inspect deployed artifacts.');
+        this.log('Run "swell inspect --help" for more information.');
+    }
+}

package/dist/commands/inspect/models.d.ts

@@ -0,0 +1,27 @@
+import { SwellCommand } from '../../swell-command.js';
+export default class Models extends SwellCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        'collection-path': import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        live: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    protected catch(error: Error): Promise<any>;
+    private listModels;
+    private showStandardModels;
+    private showAppModels;
+    private showModels;
+    private showCollectionPath;
+    private getCurrentAppSlugId;
+    private getAppSlugId;
+    private showModelDetail;
+    private resolveModelPath;
+    private resolveAppModelPath;
+    private throwModelNotFound;
+    private showModel;
+}

package/dist/commands/inspect/models.js

@@ -0,0 +1,197 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import { FetchError } from 'node-fetch';
+import { default as localConfig } from '../../lib/config.js';
+import { SwellCommand } from '../../swell-command.js';
+export default class Models extends SwellCommand {
+    static summary = 'Inspect models for collections deployed in your store.';
+    static description = `
+View models for collections available in your Swell store.
+
+Without a collection path, this command lists all available collections grouped by type.
+With a collection path, it retrieves the model for that specific collection in JSON format.
+`;
+    static args = {
+        'collection-path': Args.string({
+            description: "Optional collection path (must start with '/'). Example: /products, /apps/myapp/orders",
+            required: false,
+        }),
+    };
+    static flags = {
+        live: Flags.boolean({
+            description: 'Use the live environment instead of test (default: test).',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Accept all prompts automatically (for agent compatibility; no functional effect).',
+            default: false,
+        }),
+    };
+    static examples = [
+        'swell inspect models',
+        'swell inspect models /products',
+        'swell inspect models /apps/myapp/orders',
+        'swell inspect models /orders --live',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Models);
+        const { 'collection-path': path } = args;
+        const { live } = flags;
+        if (!live) {
+            await this.api.setEnv('test');
+        }
+        // Detail mode: show schema for a specific model
+        if (path) {
+            if (!path.startsWith('/')) {
+                throw new Error(`Collection path must start with '/'. Did you mean '/${path}'?`);
+            }
+            await this.showModelDetail(path);
+            return;
+        }
+        const store = localConfig.getDefaultStore();
+        // List mode: show all models
+        await this.listModels(store, live);
+    }
+    async catch(error) {
+        if (error instanceof FetchError) {
+            const message = `Could not connect to Swell API. Please try again later: ${error.message}`;
+            return this.error(message, { exit: 2, code: error.code });
+        }
+        return this.error(error.message, { exit: 1 });
+    }
+    async listModels(store, live) {
+        const { results: apps } = await this.api.get({
+            adminPath: '/apps',
+        });
+        const appsById = Object.fromEntries(apps.map((app) => [app.id, app]));
+        const { results: models } = await this.api.getAll({
+            adminPath: '/data/:models',
+        }, {
+            query: {
+                content_id: { $exists: false },
+                deprecated: { $ne: true },
+                development: { $ne: true },
+                abstract: { $ne: true },
+                reserved: { $ne: true },
+                $or: [
+                    { app_id: { $exists: false } },
+                    { app_id: { $in: Object.keys(appsById) } },
+                ],
+            },
+        });
+        const standardModels = [];
+        const modelsByAppId = {};
+        for (const model of models) {
+            if (model.app_id) {
+                modelsByAppId[model.app_id] ||= [];
+                modelsByAppId[model.app_id].push(model);
+            }
+            else {
+                standardModels.push(model);
+            }
+        }
+        this.log(`Collections available in '${store}' ${live ? '[live]' : '[test]'}:`);
+        this.log();
+        this.showStandardModels(standardModels);
+        await this.showAppModels(appsById, modelsByAppId);
+        // Show next step hint
+        this.log();
+        this.log('View collection model');
+        this.log('  swell inspect models <collection-path>');
+        this.log();
+        this.log('Examples:');
+        this.log('  swell inspect models /products');
+        this.log('  swell inspect models /apps/myapp/orders');
+    }
+    showStandardModels(models) {
+        this.showModels(models, 'Standard');
+    }
+    async showAppModels(appsById, modelsByAppId) {
+        const currentAppSlugId = await this.getCurrentAppSlugId();
+        for (const [appId, app] of Object.entries(appsById)) {
+            const models = modelsByAppId[appId];
+            if (models) {
+                const appSlugId = this.getAppSlugId(app);
+                const pathPrefix = `/apps/${appSlugId}`;
+                const label = `${app.name} App ${currentAppSlugId === appSlugId ? '(current app)' : ''}`;
+                this.log();
+                this.showModels(models, label, { pathPrefix });
+            }
+        }
+    }
+    showModels(models, label, options) {
+        this.log(label);
+        this.log();
+        const sortedModels = [...models].sort((a, b) => a.name.localeCompare(b.name));
+        for (const model of sortedModels) {
+            this.showCollectionPath(model.name, 2, options);
+            const sortedSubModels = Object.values(model.fields)
+                .filter((field) => field.type === 'collection')
+                .map((field) => field.name)
+                .sort((a, b) => a.localeCompare(b));
+            for (const sub of sortedSubModels) {
+                this.showCollectionPath(sub, 4, options);
+            }
+        }
+    }
+    showCollectionPath(collection, indent = 0, options) {
+        this.log(`${' '.repeat(indent)}${options?.pathPrefix || ''}/${collection}`);
+    }
+    async getCurrentAppSlugId() {
+        const hasAppContext = fs.existsSync('swell.json');
+        if (!hasAppContext) {
+            return;
+        }
+        try {
+            const appConfig = JSON.parse(await fs.promises.readFile('swell.json', 'utf8'));
+            return appConfig.id;
+        }
+        catch {
+            // noop
+        }
+    }
+    getAppSlugId(app) {
+        return app.public_id || app.private_id.replace(/^_/, '');
+    }
+    async showModelDetail(path) {
+        const [modelPath, subModelKey] = await this.resolveModelPath(path);
+        const model = await this.api.get({
+            adminPath: `/data/:models${modelPath}`,
+        }, { query: { $app: true } });
+        if (!model) {
+            this.throwModelNotFound(path);
+        }
+        if (!subModelKey) {
+            return this.showModel(model);
+        }
+        const subModel = model.fields[subModelKey];
+        if (!subModel) {
+            this.throwModelNotFound(path);
+        }
+        this.showModel(subModel);
+    }
+    async resolveModelPath(path) {
+        if (path.startsWith('/apps/')) {
+            return this.resolveAppModelPath(path);
+        }
+        const [modelPath, subModelKey] = path.split(':');
+        return [modelPath, subModelKey];
+    }
+    async resolveAppModelPath(path) {
+        const parts = path.split('/');
+        const appSlugId = parts[2];
+        const model = parts[3];
+        const app = await this.api.get({ adminPath: `/apps/${appSlugId}` });
+        if (!app) {
+            this.throwModelNotFound(path);
+        }
+        return this.resolveModelPath(`/app_${app.id}.${model}`);
+    }
+    throwModelNotFound(path) {
+        throw new Error(`No model found for collection '${path}'.\nList available collections: swell inspect models`);
+    }
+    showModel(model) {
+        this.log(JSON.stringify(model, null, 2));
+    }
+}

package/dist/commands/schema.d.ts

@@ -0,0 +1,27 @@
+import { SwellCommand } from '../swell-command.js';
+export default class Schema extends SwellCommand {
+    static summary: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        type: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        file: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    protected catch(error: Error): Promise<any>;
+    private listTypes;
+    private showSchemaInfo;
+    private outputSchema;
+    private validate;
+    private getFileInput;
+    private readFromStdin;
+    private getSchemaUrl;
+    private getBundledSchemaUrl;
+    private getTypeScriptDeclarationsUrl;
+}