@swell/cli 2.9.26 → 2.9.28

package/dist/lib/apps/components.js

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { bundleComponentModule } from '../bundle.js';
+import { getNameFromFilePath } from './index.js';
+/** Path of component modules on the `swell app dev` proxy */
+export const COMPONENT_DEV_PATH = '/.swell/components/';
+const COMPONENT_EXTENSIONS = new Set(['.jsx', '.tsx']);
+/**
+ * Whether a file is a component entry: a .tsx or .jsx file directly in components/
+ * @param {string} file path relative to the app
+ * @returns {boolean} true for a root component
+ */
+export function isRootComponentFile(file) {
+    const parts = file.split('/');
+    return (parts.length === 2 &&
+        parts[0] === 'components' &&
+        COMPONENT_EXTENSIONS.has(path.extname(parts[1])));
+}
+/**
+ * Component entries of an app
+ * @param {string} appPath app directory
+ * @returns {Promise<string[]>} paths relative to the app, sorted
+ */
+export async function listRootComponentFiles(appPath) {
+    let names;
+    try {
+        names = await fs.readdir(path.join(appPath, 'components'));
+    }
+    catch {
+        return [];
+    }
+    return names
+        .map((name) => `components/${name}`)
+        .filter((file) => isRootComponentFile(file))
+        .sort();
+}
+/**
+ * Components to rebuild after a change: root components bundle their shared
+ * code, so a change under components/ outside the root rebuilds all of them
+ * @param {string} appPath app directory
+ * @param {string} changedFile changed file, relative to the app
+ * @returns {Promise<string[]>} root components to push again
+ */
+export async function componentsToRebuild(appPath, changedFile) {
+    if (!changedFile.startsWith('components/') ||
+        isRootComponentFile(changedFile)) {
+        return [];
+    }
+    return listRootComponentFiles(appPath);
+}
+/**
+ * Builds and serves `/.swell/components/<Name>.js` for `swell app dev`
+ * @param {string} appPath app directory
+ * @param {string} pathname request path
+ * @param {http.ServerResponse} res response to write
+ * @returns {Promise<void>} resolves when the response is written
+ */
+export async function serveComponentModule(appPath, pathname, res) {
+    const headers = {
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'no-store',
+    };
+    const name = /^\/\.swell\/components\/([\w-]+)\.js$/.exec(pathname)?.[1];
+    const files = name ? await listRootComponentFiles(appPath) : [];
+    const file = files.find((entry) => getNameFromFilePath(entry) === name);
+    if (!file) {
+        res.writeHead(404, headers).end('Component not found');
+        return;
+    }
+    try {
+        const { code } = await bundleComponentModule(file, appPath);
+        res
+            .writeHead(200, { ...headers, 'Content-Type': 'text/javascript' })
+            .end(code);
+    }
+    catch (error) {
+        res
+            .writeHead(500, { ...headers, 'Content-Type': 'text/plain' })
+            .end(error.message);
+    }
+}

package/dist/lib/apps/frontend-scaffold.js

@@ -252,7 +252,7 @@ export async function setupPackage(name, config, pkg) {
             moduleResolution: 'bundler',
             types: ['@swell/app-types'],
         },
-        exclude: ['node_modules', 'frontend', 'test', 'vitest.config.ts'],
+        exclude: ['node_modules', 'frontend', 'test', 'vitest.config.mts'],
     };
     await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
     // create frontend can initialize a workspace around an existing manifest.

package/dist/lib/apps/index.d.ts

@@ -205,6 +205,7 @@ export declare function writeJsonFile(file: string, data?: any): Promise<void>;
 export declare function hashFile(filePath: string, fileContents?: Buffer, relativePath?: string): string;
 export declare function hashString(...contents: (Buffer | string)[]): string;
 export declare function appAssetImage(appPath: string, fileName: string): Promise<string | undefined>;
+export declare function getNameFromFilePath(filePath: string): string;
 export declare function appConfigFromFile(filePath: string, configType: ConfigType, appPath: string): Promise<AppConfig>;
 export declare function findAppConfig(app: App, filePath: string, configType: ConfigType): AppConfig | undefined;
 interface BatchAppFiles {

package/dist/lib/apps/index.js

@@ -52,9 +52,11 @@ export var ConfigType;
     ConfigType["THEME"] = "theme";
     ConfigType["WEBHOOK"] = "webhook";
 })(ConfigType || (ConfigType = {}));
-// Models and content should come first in order
+// Models first; then components, which content and settings fields reference
+// by name; then content
 const ConfigTypeBatchOrder = [
     ConfigType.MODEL,
+    ConfigType.COMPONENT,
     ConfigType.CONTENT,
     ConfigType.ASSET,
     ConfigType.FUNCTION,
@@ -63,7 +65,6 @@ const ConfigTypeBatchOrder = [
     ConfigType.WEBHOOK,
     ConfigType.THEME,
     ConfigType.FRONTEND,
-    ConfigType.COMPONENT,
     ConfigType.FILE,
 ];
 // All available configs
@@ -89,6 +90,7 @@ const StandardConfigTypes = [
     'NOTIFICATION',
     'SETTING',
     'WEBHOOK',
+    'COMPONENT',
 ];
 // Configs available for storefront app types
 export const StorefrontConfigTypes = [
@@ -359,7 +361,7 @@ export async function appAssetImage(appPath, fileName) {
         }
     }
 }
-function getNameFromFilePath(filePath) {
+export function getNameFromFilePath(filePath) {
     return path.parse(filePath).name.replaceAll('_', '-');
 }
 export async function appConfigFromFile(filePath, configType, appPath) {

package/dist/lib/bundle.d.ts

@@ -9,4 +9,24 @@ import type { FunctionSourceAnalysis } from './function-source-analysis.js';
 export declare function getLocalInputs(entryPoint: string, rootDir: string): Promise<string[]>;
 export declare function bundleFunction(filePath: string): Promise<any>;
 export declare function bundleWorkflow(filePath: string, analysis: FunctionSourceAnalysis): Promise<any>;
-export declare function bundleComponent(filePath: string): Promise<any>;
+/**
+ * Legacy build for checkout payment components, which swell-js evaluates as an
+ * IIFE exposing `Component.default`, `Component.config` and `Component.preact`.
+ * @param {string} filePath absolute path of the component file
+ * @returns {Promise<string>} the bundle code
+ */
+export declare function bundleComponent(filePath: string): Promise<string>;
+export interface ComponentModuleBuild {
+    /** ES module exporting mount, update and unmount */
+    code: string;
+    /** App files the component imports, relative to the app root */
+    inputs: string[];
+}
+/**
+ * Builds a component into the module the component frame loads: generated
+ * mount, update and unmount functions render its default export with Preact.
+ * @param {string} filePath component file, relative to appRoot
+ * @param {string} appRoot app directory
+ * @returns {Promise<ComponentModuleBuild>} the module code and the app files it includes
+ */
+export declare function bundleComponentModule(filePath: string, appRoot: string): Promise<ComponentModuleBuild>;

package/dist/lib/bundle.js

@@ -84,6 +84,12 @@ export async function bundleWorkflow(filePath, analysis) {
         throw new Error(`Unable to compile workflow "${filePath}": ${error.message}`, { cause: error });
     }
 }
+/**
+ * Legacy build for checkout payment components, which swell-js evaluates as an
+ * IIFE exposing `Component.default`, `Component.config` and `Component.preact`.
+ * @param {string} filePath absolute path of the component file
+ * @returns {Promise<string>} the bundle code
+ */
 export async function bundleComponent(filePath) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -113,11 +119,7 @@ export async function bundleComponent(filePath) {
             write: false,
             logLevel: 'silent',
         });
-        const { outputFiles: [{ text: code }], } = buildResult;
-        // eslint-disable-next-line no-new-func
-        const evalFn = new Function(`${code}\nreturn { ...Component }`);
-        const { config } = evalFn();
-        return { code, config };
+        return buildResult.outputFiles[0].text;
     }
     catch (error) {
         throw new Error(`Unable to compile component "${filePath}": ${error.message}`, { cause: error });
@@ -435,3 +437,84 @@ function replaceModuleExports(code) {
         .replaceAll(/^module\.exports\b/gm, 'var moduleExports')
         .replaceAll(/\bmodule\.exports\b/gm, 'moduleExports');
 }
+const COMPONENT_ENTRY = 'swell-component-entry.js';
+// Components render with Preact; React imports in third-party libraries resolve to its compat layer
+const COMPONENT_ALIASES = {
+    react: 'preact/compat',
+    'react-dom': 'preact/compat',
+};
+// The nearest tsconfig.json overrides esbuild's jsx options per file, and
+// apps may still say "jsx": "react". A pragma wins over both, so the app's
+// own .jsx/.tsx files always compile with Preact's automatic runtime, while
+// the rest of its tsconfig (paths, baseUrl) still applies.
+const preactJsxPlugin = {
+    name: 'swell-preact-jsx',
+    setup(build) {
+        build.onLoad({ filter: /\.[jt]sx$/ }, async (args) => {
+            if (args.path.split(path.sep).includes('node_modules')) {
+                return;
+            }
+            const source = await fs.readFile(args.path, 'utf8');
+            return {
+                contents: `/** @jsxRuntime automatic @jsxImportSource preact */ ${source}`,
+                loader: args.path.endsWith('.tsx') ? 'tsx' : 'jsx',
+            };
+        });
+    },
+};
+/**
+ * Builds a component into the module the component frame loads: generated
+ * mount, update and unmount functions render its default export with Preact.
+ * @param {string} filePath component file, relative to appRoot
+ * @param {string} appRoot app directory
+ * @returns {Promise<ComponentModuleBuild>} the module code and the app files it includes
+ */
+export async function bundleComponentModule(filePath, appRoot) {
+    const entry = `./${filePath.split(path.sep).join('/')}`;
+    try {
+        const { metafile, outputFiles } = await esbuild.build({
+            absWorkingDir: appRoot,
+            alias: COMPONENT_ALIASES,
+            bundle: true,
+            format: 'esm',
+            jsx: 'automatic',
+            jsxImportSource: 'preact',
+            logLevel: 'silent',
+            metafile: true,
+            minify: true,
+            platform: 'browser',
+            plugins: [preactJsxPlugin],
+            stdin: {
+                contents: [
+                    "import { h, render } from 'preact';",
+                    `import Component from ${JSON.stringify(entry)};`,
+                    'export function mount(root, props) { render(h(Component, props), root); }',
+                    'export function update(root, props) { render(h(Component, props), root); }',
+                    'export function unmount(root) { render(null, root); }',
+                ].join('\n'),
+                loader: 'js',
+                resolveDir: appRoot,
+                sourcefile: COMPONENT_ENTRY,
+            },
+            target: 'es2020',
+            write: false,
+        });
+        const inputs = Object.keys(metafile.inputs).filter((input) => !input.includes('node_modules/') &&
+            !input.startsWith('<') &&
+            input !== COMPONENT_ENTRY);
+        return { code: outputFiles[0].text, inputs };
+    }
+    catch (error) {
+        const nonJs = /Cannot import "([^"]+)" into a JavaScript file|No loader is configured for "[^"]+" files: (\S+)/.exec(error.message);
+        let reason = error.message;
+        if (/Could not resolve "preact(?:\/[^"]*)?"/.test(error.message)) {
+            reason = 'install preact in the app (npm install preact)';
+        }
+        else if (nonJs) {
+            reason = `components cannot import CSS or other non-JavaScript files yet (${nonJs[1] ?? nonJs[2]}); use inline styles or a <style> element`;
+        }
+        throw new Error(`Unable to compile component "${filePath}": ${reason}`, {
+            cause: error,
+        });
+    }
+}

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

@@ -0,0 +1,22 @@
+export declare const PREACT_VERSION = "^10.28.0";
+export declare const APPS_SDK_VERSION = "^2.0.0-alpha.7";
+export declare const toComponentName: (value: string) => string;
+export interface ComponentTemplateOptions {
+    extension?: string;
+    targets?: string[];
+}
+export declare function getComponentTemplate(name: string, description: string, { extension, targets }?: ComponentTemplateOptions): string;
+export interface ComponentSetupResult {
+    changed: string[];
+    dependenciesAdded: boolean;
+    warnings: string[];
+}
+/**
+ * Adds preact and @swell/apps-sdk to package.json, and gives components their
+ * own tsconfig, excluded from the root one and checked by the typecheck script.
+ * Never overwrites values the app already has, except a 2.x SDK from before
+ * components.
+ * @param {string} appPath app directory
+ * @returns {Promise<ComponentSetupResult>} files changed and warnings to show
+ */
+export declare function setupComponentSupport(appPath: string): Promise<ComponentSetupResult>;

package/dist/lib/create/component.js

@@ -0,0 +1,194 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as semver from 'semver';
+export const PREACT_VERSION = '^10.28.0';
+export const APPS_SDK_VERSION = '^2.0.0-alpha.7';
+// The minimum SDK the scaffold needs
+const COMPONENTS_SDK = semver.minVersion(APPS_SDK_VERSION);
+// Example: 'color picker' => 'ColorPicker'
+export const toComponentName = (value) => {
+    const name = value
+        .split('.')[0]
+        .split(/[^\dA-Za-z]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+    // A component name is also its function name, so it must start with a letter
+    return /^[A-Za-z]/.test(name) ? name : '';
+};
+export function getComponentTemplate(name, description, { extension, targets = [] } = {}) {
+    const config = [`  description: ${JSON.stringify(description)},`];
+    if (extension) {
+        config.push(`  extension: { id: ${JSON.stringify(extension)} },`);
+    }
+    if (targets.length > 0) {
+        const ids = targets.map((id) => `{ id: ${JSON.stringify(id)} }`);
+        config.push(`  targets: [${ids.join(', ')}],`);
+    }
+    return `import type { ComponentProps } from '@swell/apps-sdk/components';
+
+export const config = {
+${config.join('\n')}
+};
+
+export default function ${name}({ value, setValue, readonly }: ComponentProps<string>) {
+  return (
+    <input
+      value={value ?? ''}
+      disabled={readonly}
+      onInput={(event) => setValue(event.currentTarget.value)}
+    />
+  );
+}
+`;
+}
+// undefined when the file is missing, null when it is not valid JSON
+async function readJson(file) {
+    let text;
+    try {
+        text = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+const writeJson = (file, value) => fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
+// Appended to the app's typecheck script, as the scaffold does for test/ and frontend/
+const TYPECHECK_COMPONENTS = ' && ([ ! -f components/tsconfig.json ] || tsc --noEmit -p components)';
+/**
+ * Components render in the browser with Preact, while the root tsconfig
+ * checks functions with the worker libs, which conflict with the DOM ones.
+ * Components get their own config instead.
+ * @param {boolean} extendsRoot whether the app has a root tsconfig to extend
+ * @returns {object} the contents of components/tsconfig.json
+ */
+function getComponentsTsconfig(extendsRoot) {
+    const compilerOptions = {
+        jsx: 'react-jsx',
+        jsxImportSource: 'preact',
+        lib: ['esnext', 'dom', 'dom.iterable'],
+        types: [],
+        // Relative to this file when no baseUrl is set
+        paths: {
+            react: ['../node_modules/preact/compat'],
+            'react-dom': ['../node_modules/preact/compat'],
+        },
+    };
+    if (extendsRoot) {
+        return {
+            extends: '../tsconfig.json',
+            compilerOptions,
+            include: ['**/*'],
+            // The root config excludes components, which would exclude every file here
+            exclude: [],
+        };
+    }
+    return {
+        compilerOptions: {
+            ...compilerOptions,
+            module: 'esnext',
+            moduleResolution: 'bundler',
+            target: 'esnext',
+            noEmit: true,
+        },
+        include: ['**/*'],
+        exclude: [],
+    };
+}
+/**
+ * Adds preact and @swell/apps-sdk to package.json, and gives components their
+ * own tsconfig, excluded from the root one and checked by the typecheck script.
+ * Never overwrites values the app already has, except a 2.x SDK from before
+ * components.
+ * @param {string} appPath app directory
+ * @returns {Promise<ComponentSetupResult>} files changed and warnings to show
+ */
+export async function setupComponentSupport(appPath) {
+    const result = {
+        changed: [],
+        dependenciesAdded: false,
+        warnings: [],
+    };
+    const packagePath = path.join(appPath, 'package.json');
+    const pkg = await readJson(packagePath);
+    if (pkg) {
+        if (!pkg.dependencies?.preact) {
+            pkg.dependencies = { ...pkg.dependencies, preact: PREACT_VERSION };
+            result.dependenciesAdded = true;
+        }
+        const sdkSection = ['dependencies', 'devDependencies'].find((section) => pkg[section]?.['@swell/apps-sdk']);
+        if (sdkSection) {
+            const range = pkg[sdkSection]['@swell/apps-sdk'];
+            const min = semver.validRange(range) ? semver.minVersion(range) : null;
+            if (min && semver.lt(min, COMPONENTS_SDK)) {
+                // `swell create tests` pinned an earlier 2.x; 1.x is another SDK the app may use
+                if (semver.major(min) === 2) {
+                    pkg[sdkSection]['@swell/apps-sdk'] = APPS_SDK_VERSION;
+                    result.dependenciesAdded = true;
+                }
+                else {
+                    result.warnings.push(`@swell/apps-sdk ${range} has no components: install @swell/apps-sdk@${APPS_SDK_VERSION} to type them.`);
+                }
+            }
+        }
+        else {
+            pkg.devDependencies = {
+                ...pkg.devDependencies,
+                '@swell/apps-sdk': APPS_SDK_VERSION,
+            };
+            result.dependenciesAdded = true;
+        }
+        const typecheck = pkg.scripts?.typecheck;
+        const typecheckUpdated = typeof typecheck === 'string' && !typecheck.includes('components');
+        if (typecheckUpdated) {
+            pkg.scripts.typecheck = typecheck + TYPECHECK_COMPONENTS;
+        }
+        if (result.dependenciesAdded || typecheckUpdated) {
+            await writeJson(packagePath, pkg);
+            result.changed.push('package.json');
+        }
+    }
+    else {
+        result.warnings.push(pkg === undefined
+            ? 'package.json not found: run `npm init`, then `npm install preact` and `npm install -D @swell/apps-sdk`.'
+            : 'package.json could not be parsed: add preact to dependencies and @swell/apps-sdk to devDependencies.');
+    }
+    const tsconfigPath = path.join(appPath, 'tsconfig.json');
+    const tsconfig = await readJson(tsconfigPath);
+    if (tsconfig) {
+        const { exclude } = tsconfig;
+        if (!Array.isArray(exclude) || !exclude.includes('components')) {
+            // An explicit exclude replaces TypeScript's default one, so keep node_modules
+            tsconfig.exclude = [
+                ...(Array.isArray(exclude) ? exclude : ['node_modules']),
+                'components',
+            ];
+            await writeJson(tsconfigPath, tsconfig);
+            result.changed.push('tsconfig.json');
+        }
+    }
+    const componentsTsconfigPath = path.join(appPath, 'components', 'tsconfig.json');
+    await fs.mkdir(path.dirname(componentsTsconfigPath), { recursive: true });
+    const created = await fs
+        .writeFile(componentsTsconfigPath, `${JSON.stringify(getComponentsTsconfig(Boolean(tsconfig)), null, 2)}\n`, { flag: 'wx' })
+        .then(() => true, (error) => {
+        if (error.code !== 'EEXIST')
+            throw error;
+        return false;
+    });
+    if (created) {
+        result.changed.push('components/tsconfig.json');
+    }
+    if (tsconfig === null) {
+        result.warnings.push(created
+            ? 'tsconfig.json could not be parsed: add "components" to its "exclude". components/tsconfig.json was created without "extends".'
+            : 'tsconfig.json could not be parsed: add "components" to its "exclude".');
+    }
+    return result;
+}

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

@@ -13,7 +13,7 @@ interface ContentViewProps {
     tabs: [];
 }
 type ContentView = 'edit' | 'list' | 'new';
-type ContentType = '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';
+type ContentType = 'asset' | 'basic_html' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'color_scheme' | 'color_scheme_group' | 'component' | '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';
 interface ContentFieldProps {
     id: string;
     label: string;

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

@@ -9,7 +9,7 @@ interface SettingFieldProps {
     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';
+type SettingFieldType = 'asset' | 'basic_html' | 'boolean' | 'category_lookup' | 'checkbox' | 'checkboxes' | 'collection' | 'color' | 'color_scheme' | 'color_scheme_group' | 'component' | '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';
 export declare function parseFields(fields: string[]): SettingFieldProps[];
 export declare const toSettingLabel: (value: string) => string;
 export {};

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

@@ -1,8 +1,5 @@
-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

@@ -1,8 +1,5 @@
-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/mock-request.js

@@ -1,8 +1,5 @@
 export function mockRequestTemplate(options) {
     return `\
-import { env } from "cloudflare:test";
-import { createSwellClient } from "./swell-client";
-
 export interface MockRequestOptions {
   data?: SwellData;
   query?: { [key: string]: string };
@@ -13,7 +10,6 @@ export interface MockRequestOptions {
   swell?: Partial<SwellAPI>;
   store?: Partial<SwellStore>;
   appId?: string;
-  useRealSwell?: boolean;
 }
 
 function createDefaultSwellMock(): Partial<SwellAPI> {
@@ -42,7 +38,6 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     swell,
     store,
     appId,
-    useRealSwell = false,
   } = options;
 
   const requestHeaders = new Headers(headers);
@@ -58,7 +53,7 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     body: method === "GET" ? undefined : JSON.stringify(data),
   });
 
-  const storeId = store?.id || env.SWELL_STORE_ID || "test-store";
+  const storeId = store?.id || "test-store";
 
   const resolvedStore = {
     id: storeId,
@@ -72,10 +67,9 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     },
   };
 
-  const swellClient =
-    swell || (useRealSwell ? createSwellClient() : createDefaultSwellMock());
+  const swellClient = swell || createDefaultSwellMock();
 
-  const resolvedAppId = appId || env.SWELL_APP_ID || "${options.appId}";
+  const resolvedAppId = appId || "${options.appId}";
 
   const req: Partial<SwellRequest> & { appId: string; storeId: string } = {
     originalRequest,
@@ -91,7 +85,7 @@ export function createMockRequest(options: MockRequestOptions = {}): SwellReques
     publicKey: null,
     store: resolvedStore,
     session,
-    apiHost: env.SWELL_API_BASE_URL || "",
+    apiHost: "",
     logParams: undefined,
     swell: swellClient as SwellAPI,
     rawBody: method === "GET" ? "" : JSON.stringify(data),

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

@@ -5,7 +5,7 @@ export function tsconfigTemplate() {
             moduleResolution: 'bundler',
             skipLibCheck: true,
             types: [
-                '@cloudflare/vitest-pool-workers',
+                '@cloudflare/vitest-plugin/types',
                 '@swell/app-types',
                 'vitest/globals',
             ],

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

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