@swell/cli 2.1.0 → 2.2.1

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 (/^[\da-f]{24}$/.test(identifier)) {
+            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;
+}

package/dist/commands/schema.js

@@ -0,0 +1,231 @@
+import { Args, Flags } from '@oclif/core';
+// eslint-disable-next-line import/no-named-as-default
+import Ajv2020 from 'ajv/dist/2020.js';
+import ajvErrors from 'ajv-errors';
+import addFormats from 'ajv-formats';
+import * as fs from 'node:fs';
+import parseJson from 'parse-json';
+import { SCHEMAS_BASE_URL } from '../lib/constants.js';
+import { SwellCommand } from '../swell-command.js';
+const SCHEMA_DEFINITIONS = Object.freeze({
+    model: {
+        description: 'Data model definitions (/models/*.json)',
+    },
+    notification: {
+        description: 'Notification definitions (/notifications/*.json)',
+    },
+    content: {
+        description: 'Content views definitions (/content/*.json)',
+    },
+    setting: {
+        description: 'App settings definitions (/settings/*.json)',
+    },
+    webhook: {
+        description: 'Webhook definitions (/webhooks/*.json)',
+    },
+});
+export default class Schema extends SwellCommand {
+    static summary = 'View or validate Swell config JSON Schemas.';
+    static examples = [
+        {
+            description: 'List available schema types',
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'Output JSON Schema',
+            command: '<%= config.bin %> <%= command.id %> content --format=json-schema',
+        },
+        {
+            description: 'Output bundled JSON Schema (all $refs resolved)',
+            command: '<%= config.bin %> <%= command.id %> content --format=json-schema-bundle',
+        },
+        {
+            description: 'Output TypeScript declarations',
+            command: '<%= config.bin %> <%= command.id %> content --format=dts',
+        },
+        {
+            description: 'Validate a file',
+            command: '<%= config.bin %> <%= command.id %> content myfile.json',
+        },
+        {
+            description: 'Validate from stdin',
+            command: 'cat myfile.json | <%= config.bin %> <%= command.id %> content -',
+        },
+    ];
+    static args = {
+        type: Args.string({
+            required: false,
+            description: 'Schema type (e.g. model, content, setting, notification, webhook)',
+        }),
+        file: Args.string({
+            required: false,
+            description: 'Path to JSON file to validate (or use "-" for stdin)',
+        }),
+    };
+    static flags = {
+        format: Flags.string({
+            description: 'Output format: json-schema (with $ref pointers), json-schema-bundle (all $refs resolved), or dts (TypeScript declarations)',
+            options: ['json-schema', 'json-schema-bundle', 'dts'],
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip informational output and print schema directly (equivalent to --format=json-schema).',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Schema);
+        const { type, file } = args;
+        const { format, yes } = flags;
+        // List available schema types
+        if (!type) {
+            this.listTypes();
+            return;
+        }
+        // Validate type
+        if (!(type in SCHEMA_DEFINITIONS)) {
+            throw new Error(`Unknown schema type '${type}'. Use 'swell schema' to list available types`);
+        }
+        // Validate file
+        if (file) {
+            if (format) {
+                throw new Error('--format cannot be used with file validation');
+            }
+            await this.validate(type, file);
+            return;
+        }
+        // Show schema info or output schema
+        if (!format && !yes) {
+            await this.showSchemaInfo(type);
+            return;
+        }
+        // Output schema in requested format
+        const outputFormat = format || 'json-schema';
+        await this.outputSchema(type, outputFormat);
+    }
+    catch(error) {
+        return this.error(error.message, { exit: 1 });
+    }
+    listTypes() {
+        this.log('Available config schemas:\n');
+        const entries = Object.entries(SCHEMA_DEFINITIONS);
+        const maxKeyLength = Math.max(...entries.map(([key]) => key.length));
+        for (const [schemaType, config] of entries) {
+            const padded = schemaType.padEnd(maxKeyLength + 4);
+            this.log(`  ${padded}${config.description}`);
+        }
+    }
+    async showSchemaInfo(_type) {
+        this.log(`Use --format to output the schema, or provide a file to validate.`);
+        this.log(`Run "swell schema --help" for more information.`);
+    }
+    async outputSchema(type, format) {
+        let output;
+        switch (format) {
+            case 'json-schema': {
+                const schemaUrl = this.getSchemaUrl(type);
+                const response = await fetch(schemaUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch schema: ${response.statusText}`);
+                }
+                const schema = await response.json();
+                output = JSON.stringify(schema, null, 2);
+                break;
+            }
+            case 'json-schema-bundle': {
+                const bundledUrl = this.getBundledSchemaUrl(type);
+                const response = await fetch(bundledUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch bundled schema: ${response.statusText}`);
+                }
+                const schema = await response.json();
+                output = JSON.stringify(schema, null, 2);
+                break;
+            }
+            case 'dts': {
+                const dtsUrl = this.getTypeScriptDeclarationsUrl(type);
+                const response = await fetch(dtsUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch TypeScript declarations: ${response.statusText}`);
+                }
+                output = await response.text();
+                break;
+            }
+            default: {
+                throw new Error(`Unknown format: ${format}`);
+            }
+        }
+        this.log(output);
+    }
+    async validate(type, file) {
+        const isStdin = file === '-';
+        const input = isStdin
+            ? await this.readFromStdin()
+            : await this.getFileInput(file);
+        let json;
+        try {
+            json = parseJson(input);
+        }
+        catch (error) {
+            let errorTitle = 'Invalid JSON';
+            if (!isStdin) {
+                errorTitle += ` in '${file}'`;
+            }
+            throw new Error(`${errorTitle}: ${error.message}`);
+        }
+        const bundledUrl = this.getBundledSchemaUrl(type);
+        const response = await fetch(bundledUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch bundled schema: ${response.statusText}`);
+        }
+        const schema = await response.json();
+        const ajv = new Ajv2020({
+            allErrors: true,
+            strict: false,
+        });
+        addFormats(ajv);
+        ajvErrors(ajv);
+        const validate = ajv.compile(schema);
+        const valid = validate(json);
+        if (!valid) {
+            const { errors } = validate;
+            const errorLength = errors?.length;
+            let errorTitle = 'Invalid model definition';
+            if (typeof errorLength === 'number' && errorLength > 1) {
+                errorTitle += ` (${errorLength} errors)`;
+            }
+            let errorMessage = '';
+            for (const error of errors || []) {
+                const path = error.instancePath || '/';
+                errorMessage += `\n•  ${path}: ${error.message} (schema: ${error.schemaPath})`;
+            }
+            throw new Error(`${errorTitle}\n${errorMessage}`);
+        }
+        this.log('Valid model definition');
+    }
+    getFileInput(file) {
+        if (!fs.existsSync(file)) {
+            throw new Error(`File not found: ${file}`);
+        }
+        return fs.promises.readFile(file, 'utf8');
+    }
+    readFromStdin() {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on('end', () => resolve(data));
+            process.stdin.on('error', reject);
+        });
+    }
+    getSchemaUrl(type) {
+        return `${SCHEMAS_BASE_URL}/${type}.json`;
+    }
+    getBundledSchemaUrl(type) {
+        return `${SCHEMAS_BASE_URL}/schema-bundle/${type}.bundled.json`;
+    }
+    getTypeScriptDeclarationsUrl(type) {
+        return `${SCHEMAS_BASE_URL}/types/${type}.d.ts`;
+    }
+}

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

@@ -1,6 +1,5 @@
 import { PushAppCommand } from '../../push-app-command.js';
 export default class AppThemeDev extends PushAppCommand {
-    appType: string;
     static examples: string[];
     static flags: {
         bundle: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
@@ -12,6 +11,7 @@ export default class AppThemeDev extends PushAppCommand {
         env: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     static summary: string;
+    appType: string;
     logAppLocalUrl(storeId: string, sessionId: string): void;
     run(): Promise<void>;
     private findAndInstallDependencies;