@swell/cli 2.2.1 → 2.3.1

package/dist/lib/create/schemas.js

@@ -3,4 +3,5 @@ export const SCHEMAS = {
     MODEL: 'https://json.swell.store/model.json',
     NOTIFICATION: 'https://json.swell.store/notification.json',
     SETTING: 'https://json.swell.store/setting.json',
+    WEBHOOK: 'https://json.swell.store/webhook.json',
 };

package/dist/lib/create/setting.d.ts

@@ -0,0 +1,15 @@
+interface CreateSettingFileBody {
+    $schema: string;
+    description?: string;
+    fields: SettingFieldProps[];
+    label?: string;
+}
+interface SettingFieldProps {
+    id: string;
+    label: string;
+    type?: SettingFieldType;
+}
+type SettingFieldType = 'asset' | 'basic_html' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'color_scheme' | 'color_scheme_group' | 'currency' | 'customer_lookup' | 'date' | 'datetime' | 'document' | 'dropdown' | 'email' | 'field_group' | 'font_family' | 'generic_lookup' | 'html' | 'icon' | 'image' | 'long_text' | 'lookup' | 'markdown' | 'number' | 'percent' | 'phone' | 'product_lookup' | 'radio' | 'rich_html' | 'rich_text' | 'select' | 'short_text' | 'slider' | 'slug' | 'tags' | 'text' | 'textarea' | 'time' | 'toggle' | 'url' | 'variant_lookup' | 'video';
+declare const parseFields: (fields: string[]) => SettingFieldProps[];
+declare const toSettingLabel: (value: string) => string;
+export { CreateSettingFileBody, parseFields, toSettingLabel };

package/dist/lib/create/setting.js

@@ -0,0 +1,27 @@
+import { titleize } from 'inflection';
+const parseFields = (fields) => {
+    if (fields.length === 0) {
+        return [];
+    }
+    const fieldResponse = [];
+    for (const fieldPair of fields) {
+        if (fieldPair.includes(':')) {
+            const [id, type] = fieldPair.split(':');
+            fieldResponse.push({
+                id,
+                label: titleize(id),
+                type,
+            });
+        }
+        else {
+            fieldResponse.push({
+                id: fieldPair,
+                label: titleize(fieldPair),
+            });
+        }
+    }
+    return fieldResponse;
+};
+// Example: 'api-config' => 'Api Config'
+const toSettingLabel = (value) => titleize(value).replaceAll('-', ' ');
+export { parseFields, toSettingLabel };

package/dist/lib/create/tests/templates/env-dts.js

@@ -6,6 +6,7 @@ declare module "cloudflare:test" {
     SWELL_SESSION_ID: string;
     SWELL_API_BASE_URL: string;
     SWELL_APP_ID: string;
+    SWELL_ENVIRONMENT?: string;
   }
 }
 

package/dist/lib/create/tests/templates/swell-client.js

@@ -16,6 +16,7 @@ async function makeRequest(
 ): Promise<any> {
   const baseUrl = env.SWELL_API_BASE_URL || "https://api.swell.store";
   const sessionId = env.SWELL_SESSION_ID;
+  const environment = env.SWELL_ENVIRONMENT || "test";
 
   if (!sessionId) {
     throw new Error(
@@ -33,6 +34,7 @@ async function makeRequest(
     "Content-Type": "application/json;charset=UTF-8",
     "User-Agent": "swell-app-tests/1.0",
     "X-Session": sessionId,
+    "Swell-Env": environment,
   };
 
   const options: RequestInit = {

package/dist/lib/create/tests/templates/tsconfig.js

@@ -3,6 +3,7 @@ export function tsconfigTemplate() {
         extends: '../tsconfig.json',
         compilerOptions: {
             moduleResolution: 'bundler',
+            skipLibCheck: true,
             types: [
                 '@cloudflare/vitest-pool-workers',
                 '@swell/app-types',
@@ -10,6 +11,7 @@ export function tsconfigTemplate() {
             ],
         },
         include: ['./**/*.ts', '../functions/**/*.ts'],
+        exclude: ['../node_modules'],
     };
     return `${JSON.stringify(config, null, 2)}\n`;
 }

package/dist/lib/create/tests/templates/vitest-config.js

@@ -111,6 +111,7 @@ export default defineWorkersConfig({
             SWELL_SESSION_ID: sdkAuth.sessionId,
             SWELL_API_BASE_URL: sdkAuth.apiBaseUrl,
             SWELL_APP_ID: "${options.appId}",
+            SWELL_ENVIRONMENT: "test",
           },
         },
       },

package/dist/lib/create/webhook.d.ts

@@ -0,0 +1,32 @@
+interface CreateWebhookFileBody {
+    $schema: string;
+    description?: string;
+    enabled?: boolean;
+    events: string[];
+    url: string;
+}
+type ErrorHandler = (msg: string, options: {
+    exit: number;
+}) => never;
+/**
+ * Parse comma-separated events string to array
+ * Input: "payment.succeeded,payment.failed"
+ * Output: ["payment.succeeded", "payment.failed"]
+ */
+declare const parseEvents: (eventsInput: string) => string[];
+/**
+ * Validate event format (model.action pattern)
+ * Valid: "product.created", "payment.succeeded"
+ * Invalid: "product", "created", "", ".created", "product."
+ */
+declare const validateEventFormat: (events: string[], onError: ErrorHandler) => void;
+/**
+ * Validate URL format (basic check for protocol)
+ */
+declare const validateUrl: (url: string, onError: ErrorHandler) => void;
+/**
+ * Convert name to webhook label
+ * "payment-handler" => "Payment Handler"
+ */
+declare const toWebhookLabel: (value: string) => string;
+export { CreateWebhookFileBody, parseEvents, toWebhookLabel, validateEventFormat, validateUrl, };

package/dist/lib/create/webhook.js

@@ -0,0 +1,52 @@
+import { titleize } from 'inflection';
+/**
+ * Parse comma-separated events string to array
+ * Input: "payment.succeeded,payment.failed"
+ * Output: ["payment.succeeded", "payment.failed"]
+ */
+const parseEvents = (eventsInput) => {
+    if (!eventsInput) {
+        return [];
+    }
+    return eventsInput
+        .split(',')
+        .map((e) => e.trim())
+        .filter(Boolean);
+};
+/**
+ * Validate event format (model.action pattern)
+ * Valid: "product.created", "payment.succeeded"
+ * Invalid: "product", "created", "", ".created", "product."
+ */
+const validateEventFormat = (events, onError) => {
+    const invalid = [];
+    for (const event of events) {
+        const parts = event.split('.');
+        if (parts.length !== 2 || !parts[0] || !parts[1]) {
+            invalid.push(event);
+        }
+    }
+    if (invalid.length > 0) {
+        onError(`Invalid event format: ${invalid.join(', ')}\n\nEvents must follow the 'model.action' pattern (e.g., product.created, payment.succeeded).\n\nExample: swell create webhook my-hook -u https://example.com -e order.created,order.updated -y`, { exit: 1 });
+    }
+};
+/**
+ * Validate URL format (basic check for protocol)
+ */
+const validateUrl = (url, onError) => {
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            throw new Error('Invalid protocol');
+        }
+    }
+    catch {
+        onError(`Invalid URL format: ${url}\n\nURL must be a valid HTTP or HTTPS endpoint.\n\nExample: swell create webhook my-hook -u https://example.com/webhook -e order.created -y`, { exit: 1 });
+    }
+};
+/**
+ * Convert name to webhook label
+ * "payment-handler" => "Payment Handler"
+ */
+const toWebhookLabel = (value) => titleize(value).replaceAll('-', ' ');
+export { parseEvents, toWebhookLabel, validateEventFormat, validateUrl, };

package/dist/lib/proxy.js

@@ -1,8 +1,62 @@
+import { bin, install, Tunnel } from 'cloudflared';
 import localtunnel from 'localtunnel';
 import ngrok from 'ngrok';
+import * as fs from 'node:fs';
+import ora from 'ora';
 import { LOCAL_PROXY_PROVIDER } from './constants.js';
+let activeTunnel = null;
+let cleanupRegistered = false;
+async function startCloudflaredTunnel(port) {
+    // Stop existing tunnel if called again
+    if (activeTunnel) {
+        activeTunnel.stop();
+        activeTunnel = null;
+    }
+    // Ensure cloudflared binary is installed
+    if (!fs.existsSync(bin)) {
+        const spinner = ora('Installing cloudflared tunnel (first time only)...').start();
+        await install(bin);
+        spinner.stop();
+    }
+    // Use Tunnel.quick() for quick tunnels without a Cloudflare account
+    const tunnel = Tunnel.quick(`http://localhost:${port}`);
+    activeTunnel = tunnel;
+    // Wait for the URL to be available
+    const url = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            tunnel.stop();
+            activeTunnel = null;
+            reject(new Error('Timeout waiting for cloudflared tunnel URL. Check if cloudflared can connect to Cloudflare.'));
+        }, 60000);
+        tunnel.on('url', (tunnelUrl) => {
+            clearTimeout(timeout);
+            resolve(tunnelUrl);
+        });
+        tunnel.on('error', (error) => {
+            clearTimeout(timeout);
+            activeTunnel = null;
+            reject(error);
+        });
+    });
+    // Register cleanup handlers only once, referencing activeTunnel for current tunnel
+    if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        process.on('exit', () => activeTunnel?.stop());
+        process.on('SIGINT', () => {
+            activeTunnel?.stop();
+            // eslint-disable-next-line no-process-exit
+            process.exit();
+        });
+        process.on('SIGTERM', () => {
+            activeTunnel?.stop();
+            // eslint-disable-next-line no-process-exit
+            process.exit();
+        });
+    }
+    return url;
+}
 export async function getProxyUrl(port) {
-    const provider = LOCAL_PROXY_PROVIDER || 'localtunnel';
+    const provider = LOCAL_PROXY_PROVIDER || 'cloudflared';
     try {
         switch (provider) {
             case 'local': {
@@ -14,16 +68,19 @@ export async function getProxyUrl(port) {
                     region: 'us', // TODO: make it configurable
                 });
             }
-            // eslint-disable-next-line unicorn/no-useless-switch-case
-            case 'localtunnel':
-            default: {
+            case 'localtunnel': {
                 const tunnel = await localtunnel({ port });
                 return tunnel.url;
             }
+            // eslint-disable-next-line unicorn/no-useless-switch-case
+            case 'cloudflared':
+            default: {
+                return await startCloudflaredTunnel(port);
+            }
         }
     }
     catch (error) {
-        console.log(error);
+        console.error(error);
         throw new Error(`Unable to start tunnel on port ${port} (${provider}): ${error.message}`);
     }
 }

package/dist/swell-api-command.d.ts

@@ -5,6 +5,20 @@ export declare abstract class SwellApiCommand extends SwellCommand {
     protected request(command: typeof SwellApiCommand, requestOptions?: Api.RequestOptions): Promise<void>;
     protected catch(error: Error): Promise<any>;
     private parseCommand;
+    /**
+     * Resolve app ObjectId from a friendly slug or return as-is if already an ObjectId.
+     */
+    private resolveAppId;
+    /**
+     * Resolve function ID from app ID and function name.
+     */
+    private resolveFunctionId;
+    private isPlainObject;
+    /**
+     * Build a function invocation request via the admin /:functions endpoint.
+     */
+    private buildFunctionCallRequest;
+    private parseQueryString;
     private processBody;
     private isFilePath;
     private handleResponse;

package/dist/swell-api-command.js

@@ -1,11 +1,17 @@
 import * as fs from 'node:fs';
 import path from 'node:path';
 import { FetchError } from 'node-fetch';
+import { HttpMethod } from './lib/api.js';
 import { SwellCommand } from './swell-command.js';
+// Pattern to match /functions/{appId}/{functionName} with optional query string
+const FUNCTION_PATH_REGEX = /^\/functions\/([^/]+)\/([^/?]+)(\?.*)?$/;
+// Pattern to match /functions/{functionId} with optional query string
+const FUNCTION_DIRECT_REGEX = /^\/functions\/([^/?]+)(\?.*)?$/;
 export class SwellApiCommand extends SwellCommand {
     async request(command, requestOptions = {}) {
-        const { paths, options } = await this.parseCommand(command);
-        const response = await this.api[this.method](paths, {
+        const { paths, options, methodOverride } = await this.parseCommand(command);
+        const method = methodOverride || this.method;
+        const response = await this.api[method](paths, {
             rawResponse: true,
             ...options,
             ...requestOptions,
@@ -22,22 +28,112 @@ export class SwellApiCommand extends SwellCommand {
     async parseCommand(options, argv) {
         const parsedInput = await super.parse(options, argv);
         const { args, flags } = parsedInput;
-        const { path } = args;
+        const { path: requestPath } = args;
         const { live, body } = flags;
         if (!live) {
             await this.api.setEnv('test');
         }
-        if (!path.startsWith('/')) {
+        if (!requestPath.startsWith('/')) {
             throw new Error('Path must start with a forward slash (/)');
         }
+        const processedBody = await this.processBody(body);
+        // Check if this is a function call by name: /functions/{appId}/{functionName}
+        // Must check this first (more specific pattern)
+        const functionMatch = requestPath.match(FUNCTION_PATH_REGEX);
+        if (functionMatch) {
+            const [, appId, functionName, queryString] = functionMatch;
+            const functionId = await this.resolveFunctionId(appId, functionName);
+            const queryParams = this.parseQueryString(queryString);
+            return this.buildFunctionCallRequest(parsedInput, functionId, processedBody, queryParams);
+        }
+        // Check if this is a direct function call: /functions/{functionId}
+        const directMatch = requestPath.match(FUNCTION_DIRECT_REGEX);
+        if (directMatch) {
+            const [, functionId, queryString] = directMatch;
+            const queryParams = this.parseQueryString(queryString);
+            return this.buildFunctionCallRequest(parsedInput, functionId, processedBody, queryParams);
+        }
+        const paths = { adminPath: `/data${requestPath}` };
         return {
             ...parsedInput,
-            paths: { adminPath: `/data${path}` },
+            paths,
             options: {
-                body: await this.processBody(body),
+                body: processedBody,
             },
         };
     }
+    /**
+     * Resolve app ObjectId from a friendly slug or return as-is if already an ObjectId.
+     */
+    async resolveAppId(appIdOrSlug) {
+        // If it looks like an ObjectId (24 hex chars), return as-is
+        if (/^[\da-f]{24}$/i.test(appIdOrSlug)) {
+            return appIdOrSlug;
+        }
+        // Fetch all installed apps and filter by public_id or private_id client-side
+        const installedApps = await this.api.get({ adminPath: `/client/apps` });
+        const app = installedApps?.results?.find((a) => a.app_public_id === appIdOrSlug ||
+            a.app_private_id === `_${appIdOrSlug}`);
+        if (!app) {
+            throw new Error(`App '${appIdOrSlug}' not found`);
+        }
+        return app.app_id;
+    }
+    /**
+     * Resolve function ID from app ID and function name.
+     */
+    async resolveFunctionId(appIdOrSlug, functionName) {
+        const appId = await this.resolveAppId(appIdOrSlug);
+        const functionRecord = await this.api.get({ adminPath: `/data/:functions` }, {
+            query: {
+                app_id: appId,
+                name: functionName,
+                limit: 1,
+            },
+        });
+        if (!functionRecord?.results?.length) {
+            throw new Error(`Function '${functionName}' not found for app '${appIdOrSlug}'`);
+        }
+        return functionRecord.results[0].id;
+    }
+    isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    /**
+     * Build a function invocation request via the admin /:functions endpoint.
+     */
+    buildFunctionCallRequest(parsedInput, functionId, bodyData, queryParams) {
+        // Merge query params with body data (body takes precedence)
+        // Only merge if bodyData is a plain object; otherwise use bodyData or query params alone
+        const mergedData = this.isPlainObject(bodyData)
+            ? { ...queryParams, ...bodyData }
+            : bodyData ?? queryParams;
+        const callBody = {
+            $call: {
+                data: mergedData,
+                method: this.method,
+            },
+        };
+        return {
+            ...parsedInput,
+            paths: { adminPath: `/data/:functions/${functionId}` },
+            options: {
+                body: callBody,
+            },
+            methodOverride: HttpMethod.PUT,
+        };
+    }
+    parseQueryString(queryString) {
+        if (!queryString) {
+            return {};
+        }
+        const params = new URLSearchParams(queryString.slice(1)); // Remove leading '?'
+        const result = {};
+        for (const [key, value] of params.entries()) {
+            result[key] = value;
+        }
+        return result;
+    }
     async processBody(body) {
         if (!body) {
             return;
@@ -54,10 +150,20 @@ export class SwellApiCommand extends SwellCommand {
     }
     async handleResponse(response) {
         const responseText = await response.text();
-        if (responseText.length <= 2) {
+        // Handle truly empty responses (no body) - success for 2xx status codes
+        // This handles DELETE 204 No Content and similar cases
+        if (!responseText) {
+            if (response.ok) {
+                this.onSuccess({ success: true });
+                return;
+            }
             throw new Error('Not found');
         }
         const result = JSON.parse(responseText);
+        // API returned empty/null content in body - this is "not found" semantics
+        if (result === null || result === undefined || result === '') {
+            throw new Error('Not found');
+        }
         if (result.error || result.errors || !response.ok) {
             throw new Error(responseText);
         }