@swell/cli 2.2.0 → 2.2.1

package/dist/commands/app/dev.js

@@ -189,9 +189,11 @@ ENVIRONMENT = "development"
             }
             else if (config?.route) {
                 this.log(`    Trigger: Route`);
-                this.log(`    Methods: ${style.dim(config.route.methods
-                    .map((m) => String(m).toUpperCase())
-                    .join(', '))}`);
+                if (config.route.methods?.length) {
+                    this.log(`    Methods: ${style.dim(config.route.methods
+                        .map((m) => String(m).toUpperCase())
+                        .join(', '))}`);
+                }
                 if (config.route.headers) {
                     const headers = Object.entries(config.route.headers).map(([key, value]) => `${key}: ${value}`);
                     this.log(`    Headers:`);

package/dist/commands/create/content.js

@@ -3,8 +3,8 @@ import { Args, Flags } from '@oclif/core';
 import { CreateCollectionCommand } from '../../create-collection-command.js';
 import { ConfigType } from '../../lib/apps/index.js';
 import { parseFields, parseViews, validateViews, } from '../../lib/create/content.js';
-import { SCHEMAS } from '../../lib/create/schemas.js';
 import { toCollectionLabel, toCollectionName, toFileName, } from '../../lib/create/index.js';
+import { SCHEMAS } from '../../lib/create/schemas.js';
 export default class CreateContent extends CreateCollectionCommand {
     static args = {
         collection: Args.string({

package/dist/commands/create/index.js

@@ -26,9 +26,13 @@ export default class Create extends Command {
                     name: 'Notification',
                     value: 'notification',
                 },
+                {
+                    name: 'Tests',
+                    value: 'tests',
+                },
             ],
             message: 'What do you want to create?',
         });
-        this.log(JSON.stringify(createTarget));
+        await this.config.runCommand(`create:${createTarget}`);
     }
 }

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

@@ -0,0 +1,15 @@
+import { AppCommand } from '../../app-command.js';
+export default class CreateTests extends AppCommand {
+    static description: string;
+    static summary: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private logScaffoldResult;
+}

package/dist/commands/create/tests.js

@@ -0,0 +1,79 @@
+import { Flags } from '@oclif/core';
+import { AppCommand } from '../../app-command.js';
+import { toAppId } from '../../lib/create/index.js';
+import { createTestsScaffold, } from '../../lib/create/tests.js';
+export default class CreateTests extends AppCommand {
+    static description = 'Initialize a vitest + Cloudflare Workers test setup that reuses swell-cli authentication.';
+    static summary = 'Create test scaffolding for your Swell app.';
+    static examples = [
+        {
+            command: 'swell create tests',
+            description: 'Create a basic test setup using TypeScript.',
+        },
+        {
+            command: 'swell create tests --overwrite',
+            description: 'Regenerate test files, overwriting existing ones.',
+        },
+    ];
+    static flags = {
+        overwrite: Flags.boolean({
+            default: false,
+            description: 'overwrite existing test files if they already exist',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'accept defaults, skip prompts (no prompts currently, included for consistency)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CreateTests);
+        const appIdFromConfig = (this.swellConfig.get('id') ||
+            this.swellConfig.get('private_id') ||
+            this.swellConfig.get('public_id'));
+        const appId = appIdFromConfig ||
+            toAppId(this.swellConfig.get('name')) ||
+            'app';
+        const result = await createTestsScaffold({
+            appPath: this.appPath,
+            appId,
+            overwrite: Boolean(flags.overwrite),
+        });
+        this.logScaffoldResult(result);
+    }
+    logScaffoldResult(result) {
+        const hasChanges = result.createdFiles.length > 0 || result.packageJsonUpdated;
+        if (hasChanges) {
+            this.log('');
+            this.log('✓ Created test scaffolding');
+        }
+        if (result.createdFiles.length > 0) {
+            this.log('');
+            this.log('Created:');
+            for (const file of result.createdFiles) {
+                this.log(`  ${file}`);
+            }
+        }
+        if (result.skippedFiles.length > 0) {
+            this.log('');
+            this.log('Skipped (already exist):');
+            for (const file of result.skippedFiles) {
+                this.log(`  ${file}`);
+            }
+        }
+        if (result.packageJsonUpdated) {
+            this.log('');
+            this.log('Updated package.json with test scripts and devDependencies.');
+        }
+        for (const warning of result.warnings) {
+            this.warn(warning);
+        }
+        if (hasChanges) {
+            this.log('');
+            this.log('Next steps:');
+            this.log('  1. npm install');
+            this.log('  2. npm test');
+        }
+        this.log('');
+    }
+}

package/dist/commands/inspect/content.js

@@ -132,7 +132,7 @@ With a content ID, it retrieves the configuration for that specific content view
             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}$/)) {
+        if (/^[\da-f]{24}$/.test(identifier)) {
             return resolvedId; // already unresolved format
         }
         // type === 'app': resolve slug to app ID

package/dist/lib/apps/index.js

@@ -56,6 +56,7 @@ const StandardConfigTypes = [
     'NOTIFICATION',
     'SETTING',
     'WEBHOOK',
+    'THEME',
 ];
 export const StorefrontConfigTypes = [
     'FRONTEND',

package/dist/lib/create/tests/templates/env-dts.d.ts

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

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

@@ -0,0 +1,14 @@
+export function envDtsTemplate() {
+    return `\
+declare module "cloudflare:test" {
+  interface ProvidedEnv {
+    SWELL_STORE_ID: string;
+    SWELL_SESSION_ID: string;
+    SWELL_API_BASE_URL: string;
+    SWELL_APP_ID: string;
+  }
+}
+
+export {};
+`;
+}

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

@@ -0,0 +1,8 @@
+export { envDtsTemplate } from './env-dts.js';
+export { integrationTestTemplate } from './integration-test.js';
+export { mockRequestTemplate } from './mock-request.js';
+export { setupGlobalsTemplate } from './setup-globals.js';
+export { swellClientTemplate } from './swell-client.js';
+export { tsconfigTemplate } from './tsconfig.js';
+export { unitTestTemplate } from './unit-test.js';
+export { vitestConfigTemplate } from './vitest-config.js';

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

@@ -0,0 +1,8 @@
+export { envDtsTemplate } from './env-dts.js';
+export { integrationTestTemplate } from './integration-test.js';
+export { mockRequestTemplate } from './mock-request.js';
+export { setupGlobalsTemplate } from './setup-globals.js';
+export { swellClientTemplate } from './swell-client.js';
+export { tsconfigTemplate } from './tsconfig.js';
+export { unitTestTemplate } from './unit-test.js';
+export { vitestConfigTemplate } from './vitest-config.js';

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

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

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

@@ -0,0 +1,19 @@
+export function integrationTestTemplate() {
+    return `\
+import { describe, it, expect } from "vitest";
+import { createSwellClient } from "../helpers/swell-client";
+
+describe("Store settings (read-only)", () => {
+  it("loads general store settings using CLI auth", async () => {
+    const swell = createSwellClient();
+
+    const general = await swell.get("/settings/general");
+
+    expect(general).toBeDefined();
+    expect(general.id).toBe("general");
+    expect(general.features).toBeDefined();
+    expect(typeof general.features.carts).toBe("boolean");
+  });
+});
+`;
+}

package/dist/lib/create/tests/templates/mock-request.d.ts

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

package/dist/lib/create/tests/templates/mock-request.js

@@ -0,0 +1,112 @@
+export function mockRequestTemplate(options) {
+    return `\
+import { env } from "cloudflare:test";
+import { createSwellClient } from "./swell-client";
+
+export interface MockRequestOptions {
+  data?: SwellData;
+  query?: { [key: string]: string };
+  session?: { [key: string]: any };
+  headers?: Record<string, string>;
+  method?: string;
+  url?: string;
+  swell?: Partial<SwellAPI>;
+  store?: Partial<SwellStore>;
+  appId?: string;
+  useRealSwell?: boolean;
+}
+
+function createDefaultSwellMock(): Partial<SwellAPI> {
+  const notMocked = (method: string) => () => {
+    throw new Error(
+      \`swell.\${method}() not mocked. Pass { swell: { \${method}: vi.fn() } } to createMockRequest().\`
+    );
+  };
+  return {
+    get: notMocked("get"),
+    post: notMocked("post"),
+    put: notMocked("put"),
+    delete: notMocked("delete"),
+    settings: notMocked("settings"),
+  };
+}
+
+export function createMockRequest(options: MockRequestOptions = {}): SwellRequest {
+  const {
+    data = {},
+    query = {},
+    session = {},
+    headers = {},
+    method = "POST",
+    url = "https://example.com/test",
+    swell,
+    store,
+    appId,
+    useRealSwell = false,
+  } = options;
+
+  const requestHeaders = new Headers(headers);
+  const originalRequest = new Request(url, {
+    method,
+    headers: requestHeaders,
+    body: method === "GET" ? undefined : JSON.stringify(data),
+  });
+
+  const storeId = store?.id || env.SWELL_STORE_ID || "test-store";
+
+  const resolvedStore = {
+    id: storeId,
+    url: store?.url || "",
+    admin_url: store?.admin_url || "",
+  };
+
+  const context = {
+    waitUntil: async (promise: Promise<unknown>) => {
+      await promise;
+    },
+  };
+
+  const swellClient =
+    swell || (useRealSwell ? createSwellClient() : createDefaultSwellMock());
+
+  const resolvedAppId = appId || env.SWELL_APP_ID || "${options.appId}";
+
+  const req: Partial<SwellRequest> & { appId: string; storeId: string } = {
+    originalRequest,
+    context,
+    url,
+    method,
+    headers: requestHeaders,
+    referrer: originalRequest.referrer,
+    credentials: "include",
+    appId: resolvedAppId,
+    storeId,
+    accessToken: null,
+    publicKey: null,
+    store: resolvedStore,
+    session,
+    apiHost: env.SWELL_API_BASE_URL || "",
+    logParams: undefined,
+    swell: swellClient as SwellAPI,
+    body: data,
+    data,
+    query,
+    initialize: async () => {},
+    parseJson: (input: string) => JSON.parse(input),
+    appValues: (idOrValues: string | SwellData, values?: SwellData) => {
+      const targetAppId =
+        typeof idOrValues === "string" ? idOrValues : resolvedAppId;
+      const appValues = typeof idOrValues === "string" ? values : idOrValues;
+      if (!targetAppId || !appValues) return undefined;
+      return {
+        $app: {
+          [targetAppId]: appValues,
+        },
+      };
+    },
+  };
+
+  return req as SwellRequest;
+}
+`;
+}

package/dist/lib/create/tests/templates/setup-globals.d.ts

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

package/dist/lib/create/tests/templates/setup-globals.js

@@ -0,0 +1,23 @@
+export function setupGlobalsTemplate() {
+    return `\
+class SwellErrorImpl extends Error {
+  status: number;
+
+  constructor(message: string | object, options: { status?: number } = {}) {
+    const text =
+      typeof message === "string"
+        ? message
+        : JSON.stringify(message, null, 2);
+
+    super(text);
+    this.name = "SwellError";
+    this.status = options.status ?? 500;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(globalThis as any).SwellError = SwellErrorImpl;
+
+export {};
+`;
+}

package/dist/lib/create/tests/templates/swell-client.d.ts

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

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;