@swell/cli 2.2.0 → 2.2.1

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 };