cabloy 5.1.201 → 5.1.203

package/scripts/upgrade.test.ts

@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import test from 'node:test';
+
+import { mergeFrameworkE2eAssets, reconcileFrameworkE2ePackageJson } from './upgrade.ts';
+
+const frameworkFiles = [
+  'repo-e2e/config/playwright.config.ts',
+  'repo-e2e/scripts/runE2e.ts',
+  'repo-e2e/specs/cabloy-basic.spec.ts',
+  'repo-e2e/specs/home-user-account.spec.ts',
+  'repo-e2e/specs/a-commerce.spec.ts',
+];
+
+function writeFile(root: string, path: string, content: string): void {
+  const file = resolve(root, path);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, content);
+}
+
+function readPackage(root: string): {
+  scripts: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+} {
+  return JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf-8'));
+}
+
+function fixture(): { root: string; project: string; source: string; dispose(): void } {
+  const root = mkdtempSync(resolve(tmpdir(), 'cabloy-upgrade-e2e-'));
+  const project = resolve(root, 'project');
+  const source = resolve(root, 'source');
+  writeFile(project, '__CABLOY_BASIC__', '');
+  writeFile(
+    project,
+    'package.json',
+    `${JSON.stringify(
+      {
+        scripts: {
+          'test:e2e': 'node repo-e2e/scripts/runE2e.ts --clean',
+          'test:e2e:fast': 'node repo-e2e/scripts/runE2e.ts --fast',
+          'test:project': 'node project-tests.ts',
+        },
+        dependencies: { '@playwright/test': '^1.0.0', 'project-owned': '^2.0.0' },
+        devDependencies: { 'another-tool': '^3.0.0' },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  writeFile(
+    source,
+    'package.json',
+    `${JSON.stringify({ scripts: { 'test:e2e': 'node repo-e2e/scripts/runE2e.ts' }, devDependencies: { '@playwright/test': '^1.62.1' } })}\n`,
+  );
+  for (const path of frameworkFiles) {
+    writeFile(project, path, `old ${path}`);
+    writeFile(source, path, `new ${path}`);
+  }
+  writeFile(project, 'repo-e2e/specs/project-owned.spec.ts', 'project browser test');
+  writeFile(project, 'repo-e2e/config/playwright.basic.config.ts', 'legacy config');
+  return { root, project, source, dispose: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test('reconciles one managed E2E script and removes only the known retired fast script', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    const first = readFileSync(resolve(project, 'package.json'), 'utf-8');
+    const pkg = readPackage(project);
+    assert.equal(pkg.scripts['test:e2e'], 'node repo-e2e/scripts/runE2e.ts');
+    assert.equal(Object.hasOwn(pkg.scripts, 'test:e2e:fast'), false);
+    assert.equal(pkg.scripts['test:project'], 'node project-tests.ts');
+    assert.deepEqual(pkg.dependencies, { 'project-owned': '^2.0.0' });
+    assert.deepEqual(pkg.devDependencies, {
+      'another-tool': '^3.0.0',
+      '@playwright/test': '^1.62.1',
+    });
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), first);
+  } finally {
+    dispose();
+  }
+});
+
+test('preserves a customized fast alias and project-owned browser specs', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    const pkg = readPackage(project);
+    pkg.scripts['test:e2e:fast'] = 'node project-tests.ts --quick';
+    writeFile(project, 'package.json', `${JSON.stringify(pkg, null, 2)}\n`);
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    mergeFrameworkE2eAssets(false, project, source);
+    assert.equal(readPackage(project).scripts['test:e2e:fast'], 'node project-tests.ts --quick');
+    for (const path of frameworkFiles) {
+      assert.equal(readFileSync(resolve(project, path), 'utf-8'), `new ${path}`);
+    }
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/specs/project-owned.spec.ts'), 'utf-8'),
+      'project browser test',
+    );
+    assert.equal(existsSync(resolve(project, 'repo-e2e/config/playwright.basic.config.ts')), false);
+  } finally {
+    dispose();
+  }
+});
+
+test('isolated dry-run reports changes without writing files or contacting npm', () => {
+  const { project, source, dispose } = fixture();
+  const before = readFileSync(resolve(project, 'package.json'), 'utf-8');
+  try {
+    reconcileFrameworkE2ePackageJson(true, project, source);
+    mergeFrameworkE2eAssets(true, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), before);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/scripts/runE2e.ts'), 'utf-8'),
+      'old repo-e2e/scripts/runE2e.ts',
+    );
+    assert.equal(existsSync(resolve(project, 'repo-e2e/config/playwright.basic.config.ts')), true);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/specs/project-owned.spec.ts'), 'utf-8'),
+      'project browser test',
+    );
+  } finally {
+    dispose();
+  }
+});
+
+test('Start edition is not reconciled by the Basic framework E2E upgrader', () => {
+  const { project, source, dispose } = fixture();
+  try {
+    rmSync(resolve(project, '__CABLOY_BASIC__'));
+    writeFile(project, '__CABLOY_START__', '');
+    const before = readFileSync(resolve(project, 'package.json'), 'utf-8');
+    reconcileFrameworkE2ePackageJson(false, project, source);
+    mergeFrameworkE2eAssets(false, project, source);
+    assert.equal(readFileSync(resolve(project, 'package.json'), 'utf-8'), before);
+    assert.equal(
+      readFileSync(resolve(project, 'repo-e2e/scripts/runE2e.ts'), 'utf-8'),
+      'old repo-e2e/scripts/runE2e.ts',
+    );
+  } finally {
+    dispose();
+  }
+});

package/scripts/upgrade.ts

@@ -68,7 +68,8 @@ const FRAMEWORK_E2E_FILES_CABLOY_BASIC: string[] = [
   'repo-e2e/specs/a-commerce.spec.ts',
 ];
 
-const FRAMEWORK_E2E_SCRIPT_NAMES_CABLOY_BASIC: string[] = ['test:e2e', 'test:e2e:fast'];
+const FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC = 'test:e2e';
+const LEGACY_FRAMEWORK_E2E_FAST_SCRIPT_CABLOY_BASIC = 'node repo-e2e/scripts/runE2e.ts --fast';
 
 const FRAMEWORK_E2E_DEV_DEPENDENCY_CABLOY_BASIC = '@playwright/test';
 
@@ -147,9 +148,9 @@ function copyDirectory(src: string, dest: string): void {
   cpSync(src, dest, { recursive: true, filter: shouldCopyPath });
 }
 
-function resolveEdition(): 'basic' | 'start' {
-  const hasBasic = existsSync(resolve(ROOT_DIR, '__CABLOY_BASIC__'));
-  const hasStart = existsSync(resolve(ROOT_DIR, '__CABLOY_START__'));
+function resolveEdition(rootDir = ROOT_DIR): 'basic' | 'start' {
+  const hasBasic = existsSync(resolve(rootDir, '__CABLOY_BASIC__'));
+  const hasStart = existsSync(resolve(rootDir, '__CABLOY_START__'));
   if (hasBasic === hasStart) {
     throw new Error(
       hasBasic
@@ -226,12 +227,16 @@ async function extractTarball(tarballPath: string, targetDir: string): Promise<v
   }
 }
 
-function mergeFrameworkE2eAssets(dryRun?: boolean): void {
-  if (!isCabloyBasic()) return;
+export function mergeFrameworkE2eAssets(
+  dryRun?: boolean,
+  rootDir = ROOT_DIR,
+  tempDir = TEMP_DIR,
+): void {
+  if (resolveEdition(rootDir) !== 'basic') return;
 
   for (const dir of FRAMEWORK_E2E_DIRS_CABLOY_BASIC) {
-    const src = resolve(TEMP_DIR, dir);
-    const dest = resolve(ROOT_DIR, dir);
+    const src = resolve(tempDir, dir);
+    const dest = resolve(rootDir, dir);
     if (!existsSync(src)) {
       throw new Error(`Expected framework E2E directory in package: ${dir}`);
     }
@@ -243,8 +248,8 @@ function mergeFrameworkE2eAssets(dryRun?: boolean): void {
   }
 
   for (const file of FRAMEWORK_E2E_FILES_CABLOY_BASIC) {
-    const src = resolve(TEMP_DIR, file);
-    const dest = resolve(ROOT_DIR, file);
+    const src = resolve(tempDir, file);
+    const dest = resolve(rootDir, file);
     if (!existsSync(src)) {
       throw new Error(`Expected framework E2E file in package: ${file}`);
     }
@@ -265,7 +270,7 @@ function mergeFrameworkE2eAssets(dryRun?: boolean): void {
     'repo-e2e/specs/a-commerce/commerce.spec.ts',
   ];
   for (const file of legacyFrameworkFiles) {
-    const dest = resolve(ROOT_DIR, file);
+    const dest = resolve(rootDir, file);
     if (!existsSync(dest)) continue;
     if (dryRun) {
       log(`  [dry-run] Remove legacy framework E2E file: ${file}`);
@@ -334,11 +339,15 @@ function reconcileGovernanceAssets(dryRun?: boolean): void {
   }
 }
 
-function reconcileFrameworkE2ePackageJson(dryRun?: boolean): void {
-  if (!isCabloyBasic()) return;
+export function reconcileFrameworkE2ePackageJson(
+  dryRun?: boolean,
+  rootDir = ROOT_DIR,
+  tempDir = TEMP_DIR,
+): void {
+  if (resolveEdition(rootDir) !== 'basic') return;
 
-  const projectPackagePath = resolve(ROOT_DIR, 'package.json');
-  const sourcePackagePath = resolve(TEMP_DIR, 'package.json');
+  const projectPackagePath = resolve(rootDir, 'package.json');
+  const sourcePackagePath = resolve(tempDir, 'package.json');
   const projectPackage = readPackageJson(projectPackagePath);
   const sourcePackage = readPackageJson(sourcePackagePath);
   const sourcePlaywrightVersion =
@@ -349,19 +358,30 @@ function reconcileFrameworkE2ePackageJson(dryRun?: boolean): void {
     );
   }
 
+  const sourceScript = sourcePackage.scripts?.[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC];
+  if (!sourceScript) {
+    throw new Error(
+      `Expected framework E2E script in package.json: ${FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC}`,
+    );
+  }
+
   let changed = false;
-  for (const name of FRAMEWORK_E2E_SCRIPT_NAMES_CABLOY_BASIC) {
-    const sourceValue = sourcePackage.scripts?.[name];
-    if (!sourceValue) {
-      throw new Error(`Expected framework E2E script in package.json: ${name}`);
-    }
-    if (projectPackage.scripts?.[name] === sourceValue) continue;
+  if (projectPackage.scripts?.[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC] !== sourceScript) {
     changed = true;
     if (dryRun) {
-      log(`  [dry-run] Set package.json scripts.${name}`);
+      log(`  [dry-run] Set package.json scripts.${FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC}`);
     } else {
       projectPackage.scripts ??= {};
-      projectPackage.scripts[name] = sourceValue;
+      projectPackage.scripts[FRAMEWORK_E2E_SCRIPT_CABLOY_BASIC] = sourceScript;
+    }
+  }
+
+  if (projectPackage.scripts?.['test:e2e:fast'] === LEGACY_FRAMEWORK_E2E_FAST_SCRIPT_CABLOY_BASIC) {
+    changed = true;
+    if (dryRun) {
+      log('  [dry-run] Remove package.json scripts.test:e2e:fast (retired framework value)');
+    } else {
+      delete projectPackage.scripts['test:e2e:fast'];
     }
   }
 
@@ -635,7 +655,9 @@ async function main(): Promise<void> {
   }
 }
 
-main().catch(err => {
-  console.error(`\nUpgrade failed: ${err.message}`);
-  process.exit(1);
-});
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch(err => {
+    console.error(`\nUpgrade failed: ${err.message}`);
+    process.exit(1);
+  });
+}

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.157",
+  "version": "1.1.158",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.155",
+  "version": "1.1.156",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.dev.ts

@@ -2,6 +2,7 @@ import type { glob } from '@cabloy/module-glob';
 import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/module-info';
 
 import { BeanCliBase } from '@cabloy/cli';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import nodemon from 'nodemon';
 import { rimraf } from 'rimraf';
@@ -11,10 +12,23 @@ import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 import { getImportEsm } from '../utils.ts';
 import { generateVonaMeta } from './toolsBin/generateVonaMeta.ts';
 
+export function resolveDevMode(mode: unknown): 'dev' | 'test' {
+  if (mode === undefined || mode === 'dev') return 'dev';
+  if (mode === 'test') return 'test';
+  throw new Error('Invalid --mode: expected dev or test');
+}
+
+export function resolveTestWorkers(mode: 'dev' | 'test', workers: unknown): number | undefined {
+  if (mode !== 'test') return workers as number | undefined;
+  if (workers === undefined || workers === 1) return 1;
+  throw new Error('--mode=test requires --workers=1');
+}
+
 declare module '@cabloy/cli' {
   interface ICommandArgv {
     workers?: number;
     flavor?: VonaMetaFlavor;
+    mode?: VonaMetaMode;
   }
 }
 
@@ -30,17 +44,49 @@ export class CliBinDev extends BeanCliBase {
 
   async _dev(projectPath: string) {
     const { argv } = this.context;
-    const mode: VonaMetaMode = 'dev';
+    const mode = resolveDevMode(argv.mode);
+    const workers = resolveTestWorkers(mode, argv.workers);
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
       runtimeDir: '.vona',
-      workers: argv.workers,
+      workers,
     };
-    const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
-    await this._run(projectPath, modulesMeta);
-    await rimraf(path.join(projectPath, '.vona'));
+    try {
+      const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+      if (mode === 'test') {
+        await this._runTest(projectPath);
+      } else {
+        await this._run(projectPath, modulesMeta);
+      }
+    } finally {
+      await rimraf(path.join(projectPath, '.vona'));
+    }
+  }
+
+  async _runTest(projectPath: string) {
+    const child = spawn(process.execPath, [getImportEsm(), '.vona/bootstrap.ts'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+    const forwardSignal = (signal: NodeJS.Signals) => child.kill(signal);
+    const onInterrupt = () => forwardSignal('SIGINT');
+    const onTerminate = () => forwardSignal('SIGTERM');
+    process.on('SIGINT', onInterrupt);
+    process.on('SIGTERM', onTerminate);
+    try {
+      await new Promise<void>((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Test-mode dev server exited: ${signal ?? code}`));
+        });
+      });
+    } finally {
+      process.off('SIGINT', onInterrupt);
+      process.off('SIGTERM', onTerminate);
+    }
   }
 
   async _run(projectPath: string, _modulesMeta: Awaited<ReturnType<typeof glob>>) {

package/vona/packages-cli/cli-set-api/src/lib/command/bin.dev.ts

@@ -3,7 +3,7 @@ export default {
   info: {
     version: '5.0.0',
     title: 'Cli: Bin: Dev',
-    usage: 'npm run vona :bin:dev -- [--workers=] [--flavor=]',
+    usage: 'npm run vona :bin:dev -- [--workers=] [--flavor=] [--mode=dev|test]',
   },
   options: {
     workers: {
@@ -14,5 +14,10 @@ export default {
       description: 'flavor',
       type: 'string',
     },
+    mode: {
+      description: 'dev or test',
+      type: 'string',
+      choices: ['dev', 'test'],
+    },
   },
 };

package/vona/packages-cli/cli-set-api/test/binDevMode.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it } from 'node:test';
+
+import { CliBinDev, resolveDevMode, resolveTestWorkers } from '../src/lib/bean/cli.bin.dev.ts';
+import command from '../src/lib/command/bin.dev.ts';
+
+describe('bin.dev mode', () => {
+  it('defaults to dev and accepts test explicitly', () => {
+    assert.equal(resolveDevMode(undefined), 'dev');
+    assert.equal(resolveDevMode('dev'), 'dev');
+    assert.equal(resolveDevMode('test'), 'test');
+    assert.deepEqual(command.options.mode.choices, ['dev', 'test']);
+  });
+
+  it('rejects invalid modes before runtime generation', () => {
+    for (const value of ['', 'prod', 'unknown', true, ['dev', 'test'], null]) {
+      assert.throws(() => resolveDevMode(value), /Invalid --mode: expected dev or test/);
+    }
+  });
+
+  it('forces one worker in test mode without changing dev workers', () => {
+    assert.equal(resolveTestWorkers('test', undefined), 1);
+    assert.equal(resolveTestWorkers('test', 1), 1);
+    assert.equal(resolveTestWorkers('dev', undefined), undefined);
+    assert.equal(resolveTestWorkers('dev', 3), 3);
+    for (const workers of [0, 2, '1', null, [1]]) {
+      assert.throws(() => resolveTestWorkers('test', workers), /requires --workers=1/);
+    }
+  });
+
+  it('supervises test-mode bootstrap exit without starting a server', async () => {
+    const projectPath = mkdtempSync(join(tmpdir(), 'vona-bin-dev-mode-'));
+    try {
+      mkdirSync(join(projectPath, '.vona'));
+      writeFileSync(join(projectPath, '.vona/register.js'), '');
+      const cli = Object.create(CliBinDev.prototype) as CliBinDev;
+      for (const code of [0, 7]) {
+        writeFileSync(join(projectPath, '.vona/bootstrap.ts'), `process.exit(${code});`);
+        if (code === 0) {
+          await cli._runTest(projectPath);
+        } else {
+          await assert.rejects(cli._runTest(projectPath), /Test-mode dev server exited: 7/);
+        }
+      }
+    } finally {
+      rmSync(projectPath, { recursive: true, force: true });
+    }
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-trade/src/.metadata/index.ts

@@ -1063,11 +1063,13 @@ declare module 'vona-module-commerce-trade' {
 /** controller: begin */
 export * from '../controller/cart.ts';
 export * from '../controller/checkout.ts';
+export * from '../controller/e2eFixture.ts';
 export * from '../controller/order.ts';
 export * from '../controller/stockAudit.ts';
 export * from '../controller/stockBalance.ts';
 import type { IControllerOptionsCart } from '../controller/cart.ts';
 import type { IControllerOptionsCheckout } from '../controller/checkout.ts';
+import type { IControllerOptionsE2eFixture } from '../controller/e2eFixture.ts';
 import type { IControllerOptionsOrder } from '../controller/order.ts';
 import type { IControllerOptionsStockAudit } from '../controller/stockAudit.ts';
 import type { IControllerOptionsStockBalance } from '../controller/stockBalance.ts';
@@ -1077,6 +1079,7 @@ declare module 'vona-module-a-web' {
     export interface IControllerRecord {
       'commerce-trade:cart': IControllerOptionsCart;
 'commerce-trade:checkout': IControllerOptionsCheckout;
+'commerce-trade:e2eFixture': IControllerOptionsE2eFixture;
 'commerce-trade:order': IControllerOptionsOrder;
 'commerce-trade:stockAudit': IControllerOptionsStockAudit;
 'commerce-trade:stockBalance': IControllerOptionsStockBalance;
@@ -1108,6 +1111,17 @@ declare module 'vona-module-commerce-trade' {
             get $onionOptions(): IControllerOptionsCheckout;
           }
 
+        export interface ControllerE2eFixture {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ControllerE2eFixture {
+            get $beanFullName(): 'commerce-trade.controller.e2eFixture';
+            get $onionName(): 'commerce-trade:e2eFixture';
+            get $onionOptions(): IControllerOptionsE2eFixture;
+          }
+
         export interface ControllerOrder {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -1148,6 +1162,8 @@ import type { ControllerCart } from '../controller/cart.ts';
 // @ts-ignore ignore
 import type { ControllerCheckout } from '../controller/checkout.ts';
 // @ts-ignore ignore
+import type { ControllerE2eFixture } from '../controller/e2eFixture.ts';
+// @ts-ignore ignore
 import type { ControllerOrder } from '../controller/order.ts';
 // @ts-ignore ignore
 import type { ControllerStockAudit } from '../controller/stockAudit.ts';
@@ -1163,6 +1179,10 @@ declare module 'vona-module-commerce-trade' {
       actions?: TypeControllerOptionsActions<ControllerCheckout>;
     }
 
+    export interface IControllerOptionsE2eFixture {
+      actions?: TypeControllerOptionsActions<ControllerE2eFixture>;
+    }
+
     export interface IControllerOptionsOrder {
       actions?: TypeControllerOptionsActions<ControllerOrder>;
     }
@@ -1192,6 +1212,9 @@ declare module 'vona-module-a-web' {
 export interface IApiPathPostRecord{
         '/commerce/trade/cart/items': undefined;
 '/commerce/trade/checkout': undefined;
+'/commerce/trade/e2eFixture/catalogue': undefined;
+'/commerce/trade/e2eFixture/order/:orderId/payment/:attemptId/dispatch': undefined;
+'/commerce/trade/e2eFixture/order/:orderId/refund/:attemptId/dispatch': undefined;
 '/commerce/trade/order/:id/requestRefund': undefined;
 '/commerce/trade/order/:id/approveRefund': undefined;
 '/commerce/trade/order/:id/rejectRefund': undefined;
@@ -1207,6 +1230,9 @@ export interface IApiPathPatchRecord{
 export interface IApiPathDeleteRecord{
         '/commerce/trade/cart/items/:id': undefined;
 '/commerce/trade/cart/items': undefined;
+'/commerce/trade/e2eFixture/order/:orderId': undefined;
+'/commerce/trade/e2eFixture/customer': undefined;
+'/commerce/trade/e2eFixture/catalogue/:categoryId': undefined;
     }
 
 }
@@ -1247,6 +1273,7 @@ declare module 'vona' {
 /** bean: end */
 /** service: begin */
 export * from '../service/cart.ts';
+export * from '../service/e2eFixture.ts';
 export * from '../service/order.ts';
 export * from '../service/stockAudit.ts';
 export * from '../service/stockBalance.ts';
@@ -1256,6 +1283,7 @@ declare module 'vona-module-a-bean' {
 
     export interface IServiceRecord {
       'commerce-trade:cart': never;
+'commerce-trade:e2eFixture': never;
 'commerce-trade:order': never;
 'commerce-trade:stockAudit': never;
 'commerce-trade:stockBalance': never;
@@ -1275,6 +1303,16 @@ declare module 'vona-module-commerce-trade' {
             get $onionName(): 'commerce-trade:cart';
           }
 
+        export interface ServiceE2eFixture {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ServiceE2eFixture {
+            get $beanFullName(): 'commerce-trade.service.e2eFixture';
+            get $onionName(): 'commerce-trade:e2eFixture';
+          }
+
         export interface ServiceOrder {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -1308,11 +1346,13 @@ declare module 'vona-module-commerce-trade' {
 /** service: end */
 /** service: begin */
 import type { ServiceCart } from '../service/cart.ts';
+import type { ServiceE2eFixture } from '../service/e2eFixture.ts';
 import type { ServiceOrder } from '../service/order.ts';
 import type { ServiceStockAudit } from '../service/stockAudit.ts';
 import type { ServiceStockBalance } from '../service/stockBalance.ts';
 export interface IModuleService {
   'cart': ServiceCart;
+'e2eFixture': ServiceE2eFixture;
 'order': ServiceOrder;
 'stockAudit': ServiceStockAudit;
 'stockBalance': ServiceStockBalance;
@@ -1324,6 +1364,7 @@ import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGeneral {
     'commerce-trade.service.cart': ServiceCart;
+'commerce-trade.service.e2eFixture': ServiceE2eFixture;
 'commerce-trade.service.order': ServiceOrder;
 'commerce-trade.service.stockAudit': ServiceStockAudit;
 'commerce-trade.service.stockBalance': ServiceStockBalance;

package/vona/src/suite/a-commerce/modules/commerce-trade/src/controller/e2eFixture.ts

@@ -0,0 +1,52 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsE2eFixture extends IDecoratorControllerOptions {}
+
+// Not part of the application contract: this exists solely for owned, local E2E data.
+@Controller<IControllerOptionsE2eFixture>({
+  path: 'e2eFixture',
+  meta: { mode: ['dev', 'test'] },
+})
+@Api.exclude()
+export class ControllerE2eFixture extends BeanBase {
+  @Web.post('catalogue')
+  async createCatalogue() {
+    return await this.scope.service.e2eFixture.createCatalogue();
+  }
+
+  @Web.post('order/:orderId/payment/:attemptId/dispatch')
+  async dispatchPayment(
+    @Arg.param('orderId', v.tableIdentity()) orderId: TableIdentity,
+    @Arg.param('attemptId', v.tableIdentity()) attemptId: TableIdentity,
+  ) {
+    return await this.scope.service.e2eFixture.dispatchPayment(orderId, attemptId);
+  }
+
+  @Web.post('order/:orderId/refund/:attemptId/dispatch')
+  async dispatchRefund(
+    @Arg.param('orderId', v.tableIdentity()) orderId: TableIdentity,
+    @Arg.param('attemptId', v.tableIdentity()) attemptId: TableIdentity,
+  ) {
+    return await this.scope.service.e2eFixture.dispatchRefund(orderId, attemptId);
+  }
+
+  @Web.delete('order/:orderId')
+  async removeOrder(@Arg.param('orderId', v.tableIdentity()) orderId: TableIdentity) {
+    await this.scope.service.e2eFixture.removeOrder(orderId);
+  }
+
+  @Web.delete('customer')
+  async removeCustomer() {
+    await this.scope.service.e2eFixture.removeCustomer();
+  }
+
+  @Web.delete('catalogue/:categoryId')
+  async removeCatalogue(@Arg.param('categoryId', v.tableIdentity()) categoryId: TableIdentity) {
+    await this.scope.service.e2eFixture.removeCatalogue(categoryId);
+  }
+}