@swell/cli 2.1.0 → 2.2.1

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

@@ -0,0 +1,126 @@
+export function swellClientTemplate() {
+    return `\
+import { env } from "cloudflare:test";
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+
+type BasicSwellClient = Pick<
+  SwellAPI,
+  "get" | "post" | "put" | "delete" | "settings"
+>;
+
+async function makeRequest(
+  method: HttpMethod,
+  url: string,
+  data?: any
+): Promise<any> {
+  const baseUrl = env.SWELL_API_BASE_URL || "https://api.swell.store";
+  const sessionId = env.SWELL_SESSION_ID;
+
+  if (!sessionId) {
+    throw new Error(
+      "Missing SWELL_SESSION_ID binding. Run \\\`swell login\\\` or set it explicitly for tests.",
+    );
+  }
+
+  let endpointUrl = String(url).startsWith("/") ? url.substring(1) : String(url);
+  if (!endpointUrl.startsWith("data/")) {
+    endpointUrl = \`data/\${endpointUrl}\`;
+  }
+
+  let fullUrl = \`\${baseUrl}/\${endpointUrl}\`;
+  const headers: HeadersInit = {
+    "Content-Type": "application/json;charset=UTF-8",
+    "User-Agent": "swell-app-tests/1.0",
+    "X-Session": sessionId,
+  };
+
+  const options: RequestInit = {
+    method,
+    headers,
+  };
+
+  if (data) {
+    if (method === "GET") {
+      const params = new URLSearchParams();
+
+      function append(prefix: string, value: any) {
+        if (value === null || value === undefined) return;
+        if (typeof value === "object" && !Array.isArray(value)) {
+          for (const [k, v] of Object.entries(value)) {
+            append(\`\${prefix}[\${k}]\`, v);
+          }
+        } else if (Array.isArray(value)) {
+          for (const v of value) {
+            append(\`\${prefix}[]\`, v);
+          }
+        } else {
+          params.append(prefix, String(value));
+        }
+      }
+
+      for (const [key, value] of Object.entries(data)) {
+        append(key, value);
+      }
+
+      const query = params.toString();
+      if (query) {
+        fullUrl += \`?\${query}\`;
+      }
+    } else {
+      options.body = JSON.stringify(data);
+    }
+  }
+
+  const response = await fetch(fullUrl, options);
+  const text = await response.text();
+
+  let result: any;
+  try {
+    result = text ? JSON.parse(text) : null;
+  } catch {
+    result = text;
+  }
+
+  if (!response.ok) {
+    throw new (globalThis as any).SwellError(result || text || "Request failed", {
+      status: response.status,
+    });
+  }
+
+  if (result?.errors) {
+    throw new (globalThis as any).SwellError(result.errors, {
+      status: 400,
+    });
+  }
+
+  return result;
+}
+
+export function createSwellClient(): BasicSwellClient {
+  return {
+    get(url: string, query?: any) {
+      return makeRequest("GET", url, query);
+    },
+    post(url: string, data?: any) {
+      return makeRequest("POST", url, data);
+    },
+    put(url: string, data?: any) {
+      return makeRequest("PUT", url, data);
+    },
+    delete(url: string, data?: any) {
+      return makeRequest("DELETE", url, data);
+    },
+    settings(id?: string) {
+      const appId = id || env.SWELL_APP_ID;
+      if (!appId) {
+        throw new Error(
+          "Missing app id. Pass an id to settings() or set SWELL_APP_ID binding.",
+        );
+      }
+      return makeRequest("GET", \`/settings/\${appId}\`);
+    },
+  } as BasicSwellClient;
+}
+`;
+}

package/dist/lib/create/tests/templates/tsconfig.d.ts

@@ -0,0 +1 @@
+export declare function tsconfigTemplate(): string;

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

@@ -0,0 +1,15 @@
+export function tsconfigTemplate() {
+    const config = {
+        extends: '../tsconfig.json',
+        compilerOptions: {
+            moduleResolution: 'bundler',
+            types: [
+                '@cloudflare/vitest-pool-workers',
+                '@swell/app-types',
+                'vitest/globals',
+            ],
+        },
+        include: ['./**/*.ts', '../functions/**/*.ts'],
+    };
+    return `${JSON.stringify(config, null, 2)}\n`;
+}

package/dist/lib/create/tests/templates/unit-test.d.ts

@@ -0,0 +1 @@
+export declare function unitTestTemplate(): string;

package/dist/lib/create/tests/templates/unit-test.js

@@ -0,0 +1,42 @@
+export function unitTestTemplate() {
+    return `\
+import { describe, it, expect, vi } from "vitest";
+import { createMockRequest } from "../helpers/mock-request";
+
+// Import your functions to test:
+// import handler from "../../functions/my-handler";
+
+describe("Unit test examples", () => {
+  it("creates a mock request with data and session", () => {
+    const req = createMockRequest({
+      data: { product_id: "prod_123" },
+      session: { account_id: "acc_456" },
+    });
+
+    expect(req.data.product_id).toBe("prod_123");
+    expect(req.session.account_id).toBe("acc_456");
+  });
+
+  it("mocks swell.get", async () => {
+    const mockGet = vi.fn().mockResolvedValue({ id: "123", name: "Test" });
+    const req = createMockRequest({ swell: { get: mockGet } });
+
+    const result = await req.swell.get("/products/{id}", { id: "123" });
+
+    expect(result.name).toBe("Test");
+    expect(mockGet).toHaveBeenCalledWith("/products/{id}", { id: "123" });
+  });
+
+  it("mocks swell.settings", async () => {
+    const mockSettings = vi.fn().mockResolvedValue({
+      feature: { enabled: true },
+    });
+    const req = createMockRequest({ swell: { settings: mockSettings } });
+
+    const settings = await req.swell.settings();
+
+    expect(settings.feature.enabled).toBe(true);
+  });
+});
+`;
+}

package/dist/lib/create/tests/templates/vitest-config.d.ts

@@ -0,0 +1,2 @@
+import type { TestTemplateOptions } from '../types.js';
+export declare function vitestConfigTemplate(options: TestTemplateOptions): string;

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

@@ -0,0 +1,121 @@
+export function vitestConfigTemplate(options) {
+    return `\
+import { defineWorkersConfig } from "@cloudflare/vitest-pool-workers/config";
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+type SdkAuth = {
+  storeId: string;
+  sessionId: string;
+  apiBaseUrl: string;
+};
+
+const isCI = Boolean(process.env.CI || process.env.CONTINUOUS_INTEGRATION);
+
+function loadSwellAuth(): SdkAuth {
+  const envStoreId = process.env.SWELL_STORE_ID;
+  const envSessionId = process.env.SWELL_SESSION_ID;
+  const envApiBaseUrl = process.env.SWELL_API_BASE_URL;
+
+  if (envStoreId && envSessionId) {
+    return {
+      storeId: envStoreId,
+      sessionId: envSessionId,
+      apiBaseUrl: envApiBaseUrl || \`https://\${envStoreId}.swell.store/admin/api\`,
+    };
+  }
+
+  if (isCI) {
+    throw new Error(
+      "CI environment detected but SWELL_STORE_ID and SWELL_SESSION_ID are not set. " +
+        "Add these as CI secrets/variables to run integration tests.",
+    );
+  }
+
+  const home = homedir();
+  const configPath = path.resolve(home, ".swell", "config.json");
+  if (!existsSync(configPath)) {
+    throw new Error(
+      \`Swell CLI config not found at \${configPath}. Run \\\`swell login\\\` or set SWELL_STORE_ID and SWELL_SESSION_ID.\`
+    );
+  }
+
+  const rawConfig = readFileSync(configPath, "utf-8");
+
+  interface CliConfig {
+    defaultStore?: string;
+    stores?: { storeId: string; sessionId?: string }[];
+  }
+
+  let configJson: CliConfig;
+
+  try {
+    configJson = JSON.parse(rawConfig) as CliConfig;
+  } catch (error) {
+    throw new Error(
+      \`Unable to parse Swell CLI config at \${configPath}: \${String(error)}\`
+    );
+  }
+
+  const defaultStore = configJson.defaultStore;
+  const stores = configJson.stores || [];
+
+  const store = defaultStore
+    ? stores.find((item) => item.storeId === defaultStore)
+    : undefined;
+
+  if (!defaultStore || !store?.sessionId) {
+    throw new Error(
+      "No active Swell CLI session found. Run \\\`swell login\\\` or set SWELL_STORE_ID and SWELL_SESSION_ID.",
+    );
+  }
+
+  const envPath = path.join(home, ".swell", "env.json");
+  let apiBaseUrl = \`https://\${defaultStore}.swell.store/admin/api\`;
+
+  if (existsSync(envPath)) {
+    try {
+      const rawEnv = readFileSync(envPath, "utf-8");
+      const envJson = JSON.parse(rawEnv) as { ADMIN_API_BASE_URL?: string };
+      if (envJson.ADMIN_API_BASE_URL) {
+        apiBaseUrl = envJson.ADMIN_API_BASE_URL.replace("\${STORE_ID}", defaultStore);
+      }
+    } catch {
+      // Ignore env parsing errors and fall back to default
+    }
+  }
+
+  return {
+    storeId: defaultStore,
+    sessionId: store.sessionId!,
+    apiBaseUrl,
+  };
+}
+
+const sdkAuth = loadSwellAuth();
+
+export default defineWorkersConfig({
+  test: {
+    globals: true,
+    include: ["test/**/*.test.ts"],
+    exclude: ["node_modules", "docs"],
+    setupFiles: ["./test/setup-globals.ts"],
+    poolOptions: {
+      workers: {
+        singleWorker: true,
+        isolatedStorage: true,
+        miniflare: {
+          bindings: {
+            SWELL_STORE_ID: sdkAuth.storeId,
+            SWELL_SESSION_ID: sdkAuth.sessionId,
+            SWELL_API_BASE_URL: sdkAuth.apiBaseUrl,
+            SWELL_APP_ID: "${options.appId}",
+          },
+        },
+      },
+    },
+  },
+});
+`;
+}

package/dist/lib/create/tests/types.d.ts

@@ -0,0 +1,21 @@
+interface TestTemplateOptions {
+    /** App id from swell.json, used for SWELL_APP_ID and settings() */
+    appId: string;
+}
+interface WriteTestsOptions extends TestTemplateOptions {
+    /** Absolute path to the app root */
+    appPath: string;
+    /** Overwrite existing files if present */
+    overwrite: boolean;
+}
+interface ScaffoldResult {
+    /** Files that were created or overwritten */
+    createdFiles: string[];
+    /** Files that were skipped because they already exist */
+    skippedFiles: string[];
+    /** Whether package.json was updated */
+    packageJsonUpdated: boolean;
+    /** Warning messages to display to user */
+    warnings: string[];
+}
+export type { ScaffoldResult, TestTemplateOptions, WriteTestsOptions };

package/dist/lib/create/tests/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { ScaffoldResult, WriteTestsOptions } from './tests/types.js';
+declare function createTestsScaffold(options: WriteTestsOptions): Promise<ScaffoldResult>;
+export { createTestsScaffold };
+export type { ScaffoldResult } from './tests/types.js';

package/dist/lib/create/tests.js

@@ -0,0 +1,113 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { filePathExists, writeFile } from '../apps/index.js';
+import { envDtsTemplate, integrationTestTemplate, mockRequestTemplate, setupGlobalsTemplate, swellClientTemplate, tsconfigTemplate, unitTestTemplate, vitestConfigTemplate, } from './tests/templates/index.js';
+const TEST_DEV_DEPENDENCIES = {
+    '@cloudflare/vitest-pool-workers': 'latest',
+    vitest: 'latest',
+    '@swell/app-types': 'latest',
+};
+async function writeTextFile(filePath, contents, overwrite) {
+    if (!overwrite && filePathExists(filePath)) {
+        return { created: false, skipped: true };
+    }
+    await writeFile(filePath, contents);
+    return { created: true, skipped: false };
+}
+function updatePackageJson(appPath) {
+    const pkgPath = path.join(appPath, 'package.json');
+    if (!filePathExists(pkgPath)) {
+        return {
+            updated: false,
+            warning: 'package.json not found. Run `npm init` first.',
+        };
+    }
+    let pkgRaw;
+    try {
+        pkgRaw = fs.readFileSync(pkgPath, 'utf8');
+    }
+    catch (error) {
+        return {
+            updated: false,
+            warning: `Could not read package.json: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(pkgRaw);
+    }
+    catch (error) {
+        return {
+            updated: false,
+            warning: `Could not parse package.json: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    const devDeps = (pkg.devDependencies || {});
+    const deps = (pkg.dependencies || {});
+    devDeps['@cloudflare/vitest-pool-workers'] =
+        devDeps['@cloudflare/vitest-pool-workers'] ||
+            TEST_DEV_DEPENDENCIES['@cloudflare/vitest-pool-workers'];
+    devDeps.vitest = devDeps.vitest || TEST_DEV_DEPENDENCIES.vitest;
+    if (!devDeps['@swell/app-types'] && !deps['@swell/app-types']) {
+        devDeps['@swell/app-types'] = TEST_DEV_DEPENDENCIES['@swell/app-types'];
+    }
+    pkg.devDependencies = devDeps;
+    const scripts = (pkg.scripts || {});
+    scripts.test = scripts.test || 'vitest run';
+    pkg.scripts = scripts;
+    try {
+        const next = `${JSON.stringify(pkg, null, 2)}\n`;
+        fs.writeFileSync(pkgPath, next, 'utf8');
+        return { updated: true };
+    }
+    catch (error) {
+        return {
+            updated: false,
+            warning: `Could not write package.json: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function validatePrerequisites(appPath) {
+    const warnings = [];
+    const tsconfigPath = path.join(appPath, 'tsconfig.json');
+    if (!filePathExists(tsconfigPath)) {
+        warnings.push('tsconfig.json not found. test/tsconfig.json extends it; create one or tests may not compile.');
+    }
+    return warnings;
+}
+async function createTestsScaffold(options) {
+    const { appPath, appId, overwrite } = options;
+    const result = {
+        createdFiles: [],
+        skippedFiles: [],
+        packageJsonUpdated: false,
+        warnings: [],
+    };
+    const prereqWarnings = validatePrerequisites(appPath);
+    result.warnings.push(...prereqWarnings);
+    const trackFile = async (relativePath, contents) => {
+        const fullPath = path.join(appPath, relativePath);
+        const writeResult = await writeTextFile(fullPath, contents, overwrite);
+        if (writeResult.created) {
+            result.createdFiles.push(relativePath);
+        }
+        else if (writeResult.skipped) {
+            result.skippedFiles.push(relativePath);
+        }
+    };
+    await trackFile('vitest.config.ts', vitestConfigTemplate({ appId }));
+    await trackFile('test/tsconfig.json', tsconfigTemplate());
+    await trackFile('test/env.d.ts', envDtsTemplate());
+    await trackFile('test/setup-globals.ts', setupGlobalsTemplate());
+    await trackFile('test/helpers/swell-client.ts', swellClientTemplate());
+    await trackFile('test/helpers/mock-request.ts', mockRequestTemplate({ appId }));
+    await trackFile('test/unit/example.test.ts', unitTestTemplate());
+    await trackFile('test/integration/example.test.ts', integrationTestTemplate());
+    const pkgResult = updatePackageJson(appPath);
+    result.packageJsonUpdated = pkgResult.updated;
+    if (pkgResult.warning) {
+        result.warnings.push(pkgResult.warning);
+    }
+    return result;
+}
+export { createTestsScaffold };

package/dist/lib/sessions.js

@@ -2,6 +2,7 @@ import { ux } from '@oclif/core';
 import * as http from 'node:http';
 import open from 'open';
 import { getLoginHost } from './constants.js';
+import { getProxyUrl } from './proxy.js';
 import style from './style.js';
 /**
  * Get the session id for the passed in store. If the session is not found,
@@ -90,10 +91,10 @@ function serverForLogin({ onPost, onStart, storeId, }) {
             res.end('Not Found');
         }
     });
-    server.listen(0, '127.0.0.1', async () => {
+    server.listen(0, async () => {
         const serverAddr = server.address();
-        // the port will be dynamically assigned, one of the available ports
-        const localServerUrl = Buffer.from(`http://${serverAddr.address}:${serverAddr.port}/`).toString('base64');
+        const proxyUrl = await getProxyUrl(serverAddr.port);
+        const localServerUrl = Buffer.from(proxyUrl).toString('base64');
         const loginUrl = `${getLoginHost(storeId)}/admin?cli=${localServerUrl}`;
         onStart(loginUrl);
     });

package/dist/lib/style.js

@@ -1,4 +1,3 @@
-/* eslint-disable perfectionist/sort-objects */
 import chalk from 'chalk';
 export default {
     basicHighlight: chalk.bold,

package/dist/lib/theme-sync.d.ts

@@ -3,17 +3,17 @@ interface ThemeSyncOptions {
     targetUrl: string;
 }
 export declare class ThemeSync {
-    private readonly server;
+    private readonly options;
     private readonly proxy;
+    private readonly server;
     private readonly wss;
-    private readonly options;
-    private selectPort;
     constructor(options: ThemeSyncOptions);
-    start(): Promise<number>;
     reload(): void;
-    private parseRequestBody;
+    start(): Promise<number>;
     private decodeRequestBody;
-    private shouldInjectScript;
     private injectScript;
+    private parseRequestBody;
+    private selectPort;
+    private shouldInjectScript;
 }
 export {};

package/dist/lib/theme-sync.js

@@ -1,29 +1,37 @@
-import http from 'http';
 import getPort, { portNumbers } from 'get-port';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - http-proxy has incomplete TypeScript definitions
+import httpProxy from 'http-proxy';
+import http from 'node:http';
 import util from 'node:util';
 import zlib from 'node:zlib';
-// @ts-ignore
-import httpProxy from 'http-proxy';
-// @ts-ignore
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - ws library uses named exports differently
+// eslint-disable-next-line import/no-named-as-default
 import WebSocket, { WebSocketServer } from 'ws';
 const gunzipAsync = util.promisify(zlib.gunzip);
 const inflateAsync = util.promisify(zlib.inflate);
 const brotliDecompressAsync = util.promisify(zlib.brotliDecompress);
 const FALLBACK_PORT = 3000;
 export class ThemeSync {
-    server;
+    options;
     proxy;
+    server;
     wss;
-    options;
-    async selectPort() {
-        return (await getPort({ port: portNumbers(3000, 3100) })) || FALLBACK_PORT;
-    }
     constructor(options) {
         this.options = options;
         this.server = http.createServer();
         this.proxy = httpProxy.createProxyServer({});
         this.wss = new WebSocketServer({ server: this.server });
     }
+    reload() {
+        // Get all connected WebSocket clients
+        const clients = [...this.wss.clients].filter((client) => client.readyState === WebSocket.OPEN);
+        // Notify clients to reload
+        for (const client of clients) {
+            client.send('reload');
+        }
+    }
     async start() {
         // Select port if not specified
         if (!this.options.port) {
@@ -85,38 +93,52 @@ export class ThemeSync {
             });
         });
     }
-    reload() {
-        // Get all connected WebSocket clients
-        const clients = Array.from(this.wss.clients).filter((client) => client.readyState === WebSocket.OPEN);
-        // Notify clients to reload
-        clients.forEach((client) => {
-            client.send('reload');
-        });
+    decodeRequestBody(body, encoding) {
+        switch (encoding) {
+            case 'gzip': {
+                return gunzipAsync(body);
+            }
+            case 'deflate': {
+                return inflateAsync(body);
+            }
+            case 'br': {
+                return brotliDecompressAsync(body);
+            }
+            default: {
+                return Promise.reject(new Error(`Unsupported content encoding: ${encoding}`));
+            }
+        }
+    }
+    // Inject WebSocket client script into proxied HTML
+    injectScript(html, host) {
+        const script = `
+      <script>
+        const ws = new WebSocket('ws://${host}/ws');
+        ws.onmessage = () => {
+          window.location.reload();
+        };
+      </script>
+    `;
+        return html.replace('</body>', `${script}</body>`);
     }
     async parseRequestBody(proxyRes, body) {
         // May contain multiple encodings
         const contentEncoding = String(proxyRes.headers['content-encoding'] ?? '')
             .split(',')
             .reverse();
+        // Sequential decoding of content-encoding layers is required
+        /* eslint-disable no-await-in-loop */
         for (const value of contentEncoding) {
             const encoding = value.trim().toLowerCase();
             if (encoding) {
                 body = await this.decodeRequestBody(body, encoding);
             }
         }
+        /* eslint-enable no-await-in-loop */
         return body.toString('utf8');
     }
-    decodeRequestBody(body, encoding) {
-        switch (encoding) {
-            case 'gzip':
-                return gunzipAsync(body);
-            case 'deflate':
-                return inflateAsync(body);
-            case 'br':
-                return brotliDecompressAsync(body);
-            default:
-                return Promise.reject(new Error(`Unsupported content encoding: ${encoding}`));
-        }
+    async selectPort() {
+        return (await getPort({ port: portNumbers(3000, 3100) })) || FALLBACK_PORT;
     }
     shouldInjectScript(proxyRes, html) {
         // Check if this is an HTML response
@@ -129,16 +151,4 @@ export class ThemeSync {
         }
         return true;
     }
-    // Inject WebSocket client script into proxied HTML
-    injectScript(html, host) {
-        const script = `
-      <script>
-        const ws = new WebSocket('ws://${host}/ws');
-        ws.onmessage = () => {
-          window.location.reload();
-        };
-      </script>
-    `;
-        return html.replace('</body>', `${script}</body>`);
-    }
 }