@swell/cli 2.2.0 → 2.3.0

package/dist/lib/apps/index.js

@@ -46,6 +46,18 @@ const ConfigTypeBatchOrder = [
     ConfigType.FRONTEND,
     ConfigType.FILE,
 ];
+// All available configs
+const AllConfigTypes = [
+    'ASSET',
+    'CONTENT',
+    'FRONTEND',
+    'FUNCTION',
+    'MODEL',
+    'NOTIFICATION',
+    'SETTING',
+    'THEME',
+    'WEBHOOK',
+];
 // Configs available for admin/integration app types
 const StandardConfigTypes = [
     'MODEL',
@@ -57,11 +69,13 @@ const StandardConfigTypes = [
     'SETTING',
     'WEBHOOK',
 ];
+// Configs available for storefront app types
 export const StorefrontConfigTypes = [
     'FRONTEND',
     'ASSET',
     'SETTING',
 ];
+// Configs available for theme types
 export const ThemeConfigTypes = ['THEME', 'ASSET'];
 const getConfigPaths = (types) => 
 // eslint-disable-next-line unicorn/no-array-reduce
@@ -76,7 +90,10 @@ Object.keys(ConfigType).reduce((acc, type) => {
     }
     return acc;
 }, {});
-export const ConfigPaths = {
+export const AllConfigPaths = {
+    ...getConfigPaths(AllConfigTypes),
+};
+export const StandardConfigPaths = {
     ...getConfigPaths(StandardConfigTypes),
 };
 export const StorefrontConfigPaths = {
@@ -217,8 +234,8 @@ export function getFrontendProjectType(appPath) {
     return undefined;
 }
 export function getConfigTypeFromPath(path) {
-    for (const type in ConfigPaths) {
-        if (ConfigPaths[type] === path) {
+    for (const type in AllConfigPaths) {
+        if (AllConfigPaths[type] === path) {
             const configType = ConfigType[type];
             return configType;
         }
@@ -289,7 +306,7 @@ export function hashString(...contents) {
     return hash.digest('hex', { length: 16 });
 }
 export function appAssetImage(appPath, fileName) {
-    const assetsDirPath = path.join(appPath, ConfigPaths['ASSET']);
+    const assetsDirPath = path.join(appPath, AllConfigPaths['ASSET']);
     if (!filePathExists(assetsDirPath)) {
         return;
     }

package/dist/lib/apps/paths.js

@@ -1,7 +1,7 @@
 import { globby, globbySync, isGitIgnored, } from 'globby';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { ConfigPaths, ConfigType, StorefrontConfigPaths, ThemeConfigPaths, filePathExists, } from './index.js';
+import { AllConfigPaths, ConfigType, StandardConfigPaths, StorefrontConfigPaths, ThemeConfigPaths, filePathExists, } from './index.js';
 function globOptions(appPath, options) {
     return {
         cwd: appPath,
@@ -35,7 +35,7 @@ export function getGlobIgnorePathsChecker(appPath) {
 function getConfigDirsPaths(appPath) {
     const configDirsPaths = [];
     for (const [type, configType] of Object.entries(ConfigType)) {
-        const configPath = ConfigPaths[type];
+        const configPath = AllConfigPaths[type];
         if (!configPath) {
             continue;
         }
@@ -57,7 +57,7 @@ export function* allConfigFilesPaths(appPath) {
     }
 }
 export function* allConfigFilesPathsByType(appPath, configTypeKey) {
-    const configPath = ConfigPaths[configTypeKey];
+    const configPath = AllConfigPaths[configTypeKey];
     yield* allConfigFilesInDir(appPath, configPath, ConfigType[configTypeKey]);
 }
 export function* allConfigFilesInDir(appPath, dirPath, configType) {
@@ -76,16 +76,17 @@ export function* allBaseFilesInDir(appPath) {
         yield path;
     }
 }
+// this function is used to create folders for app
 export function getAllConfigPaths(appType) {
     const configPaths = [];
     const ConfigPathsByType = appType === 'storefront'
         ? StorefrontConfigPaths
         : appType === 'theme'
             ? ThemeConfigPaths
-            : ConfigPaths;
+            : StandardConfigPaths;
     for (const type of Object.keys(ConfigPathsByType)) {
-        if (Object.hasOwn(ConfigPaths, type)) {
-            const configPath = ConfigPaths[type];
+        if (Object.hasOwn(AllConfigPaths, type)) {
+            const configPath = AllConfigPaths[type];
             configPaths.push(configPath);
         }
     }

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

@@ -8,6 +8,7 @@ interface WriteNotificationsFileParams {
     subject: string;
 }
 interface CreateNotificationFileBody {
+    $schema: string;
     admin?: boolean;
     collection: string;
     conditions: Record<any, any>;

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

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

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.d.ts

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

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

@@ -0,0 +1,15 @@
+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;
+    SWELL_ENVIRONMENT?: 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,128 @@
+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;
+  const environment = env.SWELL_ENVIRONMENT || "test";
+
+  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,
+    "Swell-Env": environment,
+  };
+
+  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,17 @@
+export function tsconfigTemplate() {
+    const config = {
+        extends: '../tsconfig.json',
+        compilerOptions: {
+            moduleResolution: 'bundler',
+            skipLibCheck: true,
+            types: [
+                '@cloudflare/vitest-pool-workers',
+                '@swell/app-types',
+                'vitest/globals',
+            ],
+        },
+        include: ['./**/*.ts', '../functions/**/*.ts'],
+        exclude: ['../node_modules'],
+    };
+    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;