@swell/cli 2.1.0 → 2.2.0

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;

package/dist/commands/theme/dev.js

@@ -5,10 +5,9 @@ import fs from 'node:fs';
 import ora from 'ora';
 import { default as localConfig } from '../../lib/config.js';
 import style from '../../lib/style.js';
-import { PushAppCommand } from '../../push-app-command.js';
 import { ThemeSync } from '../../lib/theme-sync.js';
+import { PushAppCommand } from '../../push-app-command.js';
 export default class AppThemeDev extends PushAppCommand {
-    appType = 'theme';
     static examples = [
         'swell theme dev',
         'swell theme dev --local',
@@ -43,6 +42,7 @@ export default class AppThemeDev extends PushAppCommand {
         }),
     };
     static summary = `Run a theme in dev mode from your local machine.`;
+    appType = 'theme';
     logAppLocalUrl(storeId, sessionId) {
         this.log(`View it at ${style.link(this.localFrontendUrl(storeId, sessionId))}\n`);
     }

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

@@ -1,9 +1,9 @@
 import InitApp from '../app/init.js';
 export default class InitTheme extends InitApp {
-    appType: string;
     static description: string;
     static examples: {
         command: string;
         description: string;
     }[];
+    appType: string;
 }

package/dist/commands/theme/init.js

@@ -1,6 +1,5 @@
 import InitApp from '../app/init.js';
 export default class InitTheme extends InitApp {
-    appType = 'theme';
     static description = 'Initialize theme swell.json in the current directory.';
     static examples = [
         {
@@ -12,4 +11,5 @@ export default class InitTheme extends InitApp {
             description: 'Initialize theme and accept all default values.',
         },
     ];
+    appType = 'theme';
 }

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

@@ -1,10 +1,10 @@
 import AppPull from '../app/pull.js';
 export default class AppThemePull extends AppPull {
-    appType: string;
     static args: {
         appId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
         targetPath: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
+    static delayOrientation: boolean;
     static description: string;
     static examples: string[];
     static flags: {
@@ -15,6 +15,6 @@ export default class AppThemePull extends AppPull {
         'sync-app': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     static summary: string;
-    static delayOrientation: boolean;
+    appType: string;
     run(): Promise<void>;
 }

package/dist/commands/theme/pull.js

@@ -3,7 +3,6 @@ import { ThemeConfigPaths } from '../../lib/apps/index.js';
 import style from '../../lib/style.js';
 import AppPull from '../app/pull.js';
 export default class AppThemePull extends AppPull {
-    appType = 'theme';
     static args = {
         appId: Args.string({
             default: '',
@@ -14,6 +13,7 @@ export default class AppThemePull extends AppPull {
             description: 'path to download theme files into',
         }),
     };
+    static delayOrientation = true;
     static description = `Pull all theme files, a specific file, or a specific configuration
 type from a theme in your store's test environment to your local machine.
 
@@ -53,7 +53,7 @@ ${Object.values(ThemeConfigPaths)
         }),
     };
     static summary = 'Pull theme files from Swell to your local machine.';
-    static delayOrientation = true;
+    appType = 'theme';
     async run() {
         const { args, flags } = await this.parse(AppThemePull);
         const { force } = flags;

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

@@ -1,6 +1,5 @@
 import AppPush from '../app/push.js';
 export default class AppThemePush extends AppPush {
-    appType: string;
     static args: {
         file: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
     };
@@ -14,5 +13,6 @@ export default class AppThemePush extends AppPush {
         'sync-app': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     static summary: string;
+    appType: string;
     run(): Promise<void>;
 }

package/dist/commands/theme/push.js

@@ -4,7 +4,6 @@ import { default as localConfig } from '../../lib/config.js';
 import style from '../../lib/style.js';
 import AppPush from '../app/push.js';
 export default class AppThemePush extends AppPush {
-    appType = 'theme';
     static args = {
         file: Args.string({
             char: 'f',
@@ -56,6 +55,7 @@ ${Object.values(ThemeConfigPaths)
         }),
     };
     static summary = 'Push local files to your Swell theme.';
+    appType = 'theme';
     async run() {
         const { args, flags } = await this.parse(AppThemePush);
         const { file } = args;

package/dist/create-app-command.d.ts

@@ -3,14 +3,15 @@ export declare abstract class CreateAppCommand extends SwellCommand {
     static baseFlags: {
         frontend: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         'storefront-app': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'integration-type': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'integration-id': 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>;
     };
     private devApi;
     constructor(argv: string[], config: any);
-    addAllowedHostsToAstro(configPath: string): Promise<void>;
     addAllowedHostsToAngular(configPath: string): Promise<void>;
+    addAllowedHostsToAstro(configPath: string): Promise<void>;
     addAllowedHostsToNuxt(configPath: string): Promise<void>;
-    private addFrontendAllowedHosts;
     createAppConfigFolders(swellConfig: any): Promise<void>;
     createFrontendApp(swellConfig: any, flags: any, directCreate?: boolean, kind?: string): Promise<boolean>;
     createStorefrontApp(swellConfig: any, flags: any, directCreate?: boolean): Promise<boolean>;
@@ -19,6 +20,15 @@ export declare abstract class CreateAppCommand extends SwellCommand {
     execWithStdio(cwd: string, command: string, onOutput?: (string: string) => any | false): Promise<void>;
     findPackageManager(pkg?: string): Promise<string | undefined>;
     getInstalledStorefrontApps(): Promise<any[] | boolean>;
+    getProjectType(frameworkType: string): {
+        installCommand: string;
+        buildCommand?: string | undefined;
+        devCommand: string;
+        mainPackage: string;
+        name: string;
+        slug: string;
+    };
     setupPackage(name: string, config: any, pkg: string): Promise<void>;
     tryPackageSetup(name: string, config: any, pkg: string): Promise<void>;
+    private addFrontendAllowedHosts;
 }