@webstir-io/webstir 0.1.1 → 0.1.2

package/src/add-backend.ts

@@ -1,20 +1,91 @@
+import type {
+  AddJobOptions,
+  AddRouteOptions,
+  UpdateRouteContractOptions as BackendUpdateRouteContractOptions,
+} from '@webstir-io/webstir-backend';
+
 import type { AddCommandResult } from './add.ts';
 
-import { runAddJob, runAddRoute } from '@webstir-io/webstir-backend';
+import { monorepoRoot } from './paths.ts';
 
 export interface RunAddBackendOptions {
   readonly workspaceRoot: string;
   readonly rawArgs: readonly string[];
 }
 
+export type AddRouteScaffoldOptions = AddRouteOptions;
+export type AddJobScaffoldOptions = AddJobOptions;
+export type UpdateRouteContractOptions = BackendUpdateRouteContractOptions;
+
 export async function runAddRouteCommand(options: RunAddBackendOptions): Promise<AddCommandResult> {
-  const parsed = parseBackendCommandArgs(options.rawArgs, {
+  return await runAddRouteScaffold({
+    workspaceRoot: options.workspaceRoot,
+    ...parseAddRouteScaffoldArgs(options.rawArgs),
+  });
+}
+
+export async function runAddRouteScaffold(
+  options: AddRouteScaffoldOptions,
+): Promise<AddCommandResult> {
+  const backendAdd = await loadBackendAddModule();
+  const result = await backendAdd.runAddRoute(options);
+
+  return {
+    workspaceRoot: options.workspaceRoot,
+    subject: 'route',
+    target: result.target,
+    changes: result.changes,
+  };
+}
+
+export async function runAddJobCommand(options: RunAddBackendOptions): Promise<AddCommandResult> {
+  return await runAddJobScaffold({
+    workspaceRoot: options.workspaceRoot,
+    ...parseAddJobScaffoldArgs(options.rawArgs),
+  });
+}
+
+export async function runAddJobScaffold(options: AddJobScaffoldOptions): Promise<AddCommandResult> {
+  const backendAdd = await loadBackendAddModule();
+  const result = await backendAdd.runAddJob(options);
+
+  return {
+    workspaceRoot: options.workspaceRoot,
+    subject: 'job',
+    target: result.target,
+    changes: result.changes,
+  };
+}
+
+export async function runUpdateRouteContract(
+  options: UpdateRouteContractOptions,
+): Promise<AddCommandResult> {
+  const backendAdd = await loadBackendAddModule();
+  const result = await backendAdd.runUpdateRouteContract(options);
+
+  return {
+    workspaceRoot: options.workspaceRoot,
+    subject: 'route',
+    target: result.target,
+    changes: result.changes,
+  };
+}
+
+export function parseAddRouteScaffoldArgs(
+  rawArgs: readonly string[],
+): Omit<AddRouteScaffoldOptions, 'workspaceRoot'> {
+  const parsed = parseBackendCommandArgs(rawArgs, {
     valueFlags: new Set([
       '--method',
       '--path',
       '--summary',
       '--description',
       '--tags',
+      '--interaction',
+      '--session',
+      '--fragment-target',
+      '--fragment-selector',
+      '--fragment-mode',
       '--params-schema',
       '--query-schema',
       '--body-schema',
@@ -23,30 +94,37 @@ export async function runAddRouteCommand(options: RunAddBackendOptions): Promise
       '--response-status',
       '--response-headers-schema',
     ]),
-    booleanFlags: new Set(['--fastify']),
+    booleanFlags: new Set(['--session-write', '--form-urlencoded', '--csrf']),
   });
 
   const name = parsed.positionals[0];
   if (!name) {
     throw new Error(
-      'Usage: webstir add-route <name> --workspace <path> [--method <METHOD>] [--path <path>] [--fastify].'
+      'Usage: webstir add-route <name> --workspace <path> [--method <METHOD>] [--path <path>].',
     );
   }
 
-  const tags = parsed.values.get('--tags')
+  const tags = parsed.values
+    .get('--tags')
     ?.split(',')
     .map((tag) => tag.trim())
     .filter(Boolean);
 
-  const result = await runAddRoute({
-    workspaceRoot: options.workspaceRoot,
+  return {
     name,
     method: parsed.values.get('--method'),
     path: parsed.values.get('--path'),
-    fastify: parsed.booleans.has('--fastify'),
     summary: parsed.values.get('--summary'),
     description: parsed.values.get('--description'),
     tags,
+    interaction: parsed.values.get('--interaction'),
+    sessionMode: parsed.values.get('--session'),
+    sessionWrite: parsed.booleans.has('--session-write'),
+    formUrlEncoded: parsed.booleans.has('--form-urlencoded'),
+    formCsrf: parsed.booleans.has('--csrf'),
+    fragmentTarget: parsed.values.get('--fragment-target'),
+    fragmentSelector: parsed.values.get('--fragment-selector'),
+    fragmentMode: parsed.values.get('--fragment-mode'),
     paramsSchema: parsed.values.get('--params-schema'),
     querySchema: parsed.values.get('--query-schema'),
     bodySchema: parsed.values.get('--body-schema'),
@@ -54,18 +132,13 @@ export async function runAddRouteCommand(options: RunAddBackendOptions): Promise
     responseSchema: parsed.values.get('--response-schema'),
     responseStatus: parsed.values.get('--response-status'),
     responseHeadersSchema: parsed.values.get('--response-headers-schema'),
-  });
-
-  return {
-    workspaceRoot: options.workspaceRoot,
-    subject: 'route',
-    target: result.target,
-    changes: result.changes,
   };
 }
 
-export async function runAddJobCommand(options: RunAddBackendOptions): Promise<AddCommandResult> {
-  const parsed = parseBackendCommandArgs(options.rawArgs, {
+export function parseAddJobScaffoldArgs(
+  rawArgs: readonly string[],
+): Omit<AddJobScaffoldOptions, 'workspaceRoot'> {
+  const parsed = parseBackendCommandArgs(rawArgs, {
     valueFlags: new Set(['--schedule', '--description', '--priority']),
     booleanFlags: new Set(),
   });
@@ -75,19 +148,11 @@ export async function runAddJobCommand(options: RunAddBackendOptions): Promise<A
     throw new Error('Usage: webstir add-job <name> --workspace <path> [--schedule <expression>].');
   }
 
-  const result = await runAddJob({
-    workspaceRoot: options.workspaceRoot,
+  return {
     name,
     schedule: parsed.values.get('--schedule'),
     description: parsed.values.get('--description'),
     priority: parsed.values.get('--priority'),
-  });
-
-  return {
-    workspaceRoot: options.workspaceRoot,
-    subject: 'job',
-    target: result.target,
-    changes: result.changes,
   };
 }
 
@@ -102,7 +167,70 @@ interface ParsedBackendCommandArgs {
   readonly booleans: ReadonlySet<string>;
 }
 
-function parseBackendCommandArgs(rawArgs: readonly string[], spec: ParseSpec): ParsedBackendCommandArgs {
+interface BackendAddResult {
+  readonly target: string;
+  readonly changes: readonly string[];
+}
+
+interface BackendAddModule {
+  readonly runAddRoute: (options: AddRouteOptions) => Promise<BackendAddResult>;
+  readonly runAddJob: (options: AddJobOptions) => Promise<BackendAddResult>;
+  readonly runUpdateRouteContract: (
+    options: UpdateRouteContractOptions,
+  ) => Promise<BackendAddResult>;
+}
+
+let backendAddModulePromise: Promise<BackendAddModule> | null = null;
+
+async function loadBackendAddModule(): Promise<BackendAddModule> {
+  if (backendAddModulePromise) {
+    return await backendAddModulePromise;
+  }
+
+  backendAddModulePromise = import('@webstir-io/webstir-backend').then(async (module) => {
+    if (
+      typeof module.runAddRoute === 'function' &&
+      typeof module.runAddJob === 'function' &&
+      typeof module.runUpdateRouteContract === 'function'
+    ) {
+      return module as BackendAddModule;
+    }
+
+    if (monorepoRoot) {
+      throw new Error(
+        'Installed @webstir-io/webstir-backend package does not export runAddRoute/runAddJob/runUpdateRouteContract.',
+      );
+    }
+
+    const compat = await import('./add-backend-compat.ts');
+    return {
+      async runAddRoute(options: AddRouteOptions): Promise<BackendAddResult> {
+        return await compat.runAddRoute(options);
+      },
+      async runAddJob(options: AddJobOptions): Promise<BackendAddResult> {
+        return await compat.runAddJob({
+          workspaceRoot: options.workspaceRoot,
+          name: options.name,
+          schedule: options.schedule,
+          description: options.description,
+          ...(options.priority !== undefined ? { priority: String(options.priority) } : {}),
+        });
+      },
+      async runUpdateRouteContract(): Promise<BackendAddResult> {
+        throw new Error(
+          'Installed @webstir-io/webstir-backend package does not export runUpdateRouteContract.',
+        );
+      },
+    };
+  });
+
+  return await backendAddModulePromise;
+}
+
+function parseBackendCommandArgs(
+  rawArgs: readonly string[],
+  spec: ParseSpec,
+): ParsedBackendCommandArgs {
   const positionals: string[] = [];
   const values = new Map<string, string>();
   const booleans = new Set<string>();

package/src/add.ts

@@ -1,9 +1,10 @@
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 
 import { runAddPage } from '@webstir-io/webstir-frontend';
-import { runAddTest } from '@webstir-io/webstir-testing';
+import { monorepoRoot, packageRoot } from './paths.ts';
 
 export interface RunAddPageOptions {
   readonly workspaceRoot: string;
@@ -23,6 +24,12 @@ export interface AddCommandResult {
   readonly note?: string;
 }
 
+interface AddTestInvocationResult {
+  readonly normalizedName: string;
+  readonly created: boolean;
+  readonly relativePath: string;
+}
+
 export async function runAddPageCommand(options: RunAddPageOptions): Promise<AddCommandResult> {
   const pageName = options.args[0];
   if (!pageName) {
@@ -60,6 +67,7 @@ export async function runAddTestCommand(options: RunAddTestOptions): Promise<Add
     throw new Error('Usage: webstir add-test <name-or-path> --workspace <path>.');
   }
 
+  const runAddTest = await loadAddTestRunner();
   const result = await runAddTest({
     workspaceRoot: options.workspaceRoot,
     name: nameArg,
@@ -70,14 +78,111 @@ export async function runAddTestCommand(options: RunAddTestOptions): Promise<Add
     subject: 'test',
     target: result.normalizedName,
     changes: result.created ? [result.relativePath.replaceAll(path.sep, '/')] : [],
-    note: result.created ? undefined : `File already exists: ${result.relativePath.replaceAll(path.sep, '/')}`,
+    note: result.created
+      ? undefined
+      : `File already exists: ${result.relativePath.replaceAll(path.sep, '/')}`,
+  };
+}
+
+async function loadAddTestRunner(): Promise<
+  (options: {
+    readonly workspaceRoot: string;
+    readonly name: string;
+  }) => Promise<AddTestInvocationResult>
+> {
+  const mod = (await import('@webstir-io/webstir-testing')) as {
+    runAddTest?: (options: {
+      readonly workspaceRoot: string;
+      readonly name: string;
+    }) => Promise<AddTestInvocationResult>;
+  };
+  if (typeof mod.runAddTest === 'function') {
+    return mod.runAddTest;
+  }
+
+  if (monorepoRoot) {
+    throw new Error('Installed @webstir-io/webstir-testing package does not export runAddTest.');
+  }
+
+  // The published regular-install path exposes the add-test binary before it exposes the helper.
+  return async (options) => await runPublishedAddTestCli(options.workspaceRoot, options.name);
+}
+
+async function runPublishedAddTestCli(
+  workspaceRoot: string,
+  name: string,
+): Promise<AddTestInvocationResult> {
+  const target = resolveAddTestTarget(workspaceRoot, name);
+  const existedBefore = existsSync(target.absolutePath);
+  const binaryPath = path.join(
+    packageRoot,
+    '..',
+    '..',
+    '.bin',
+    process.platform === 'win32' ? 'webstir-testing-add.cmd' : 'webstir-testing-add',
+  );
+  const result = spawnSync(process.execPath, [binaryPath, name, '--workspace', workspaceRoot], {
+    cwd: workspaceRoot,
+    env: process.env,
+    encoding: 'utf8',
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    const detail = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join('\n');
+    throw new Error(
+      `Command failed (${result.status}): ${process.execPath} ${binaryPath} ${name} --workspace ${workspaceRoot}${detail ? `\n${detail}` : ''}`,
+    );
+  }
+
+  if (!existsSync(target.absolutePath)) {
+    throw new Error(`Expected add-test output at ${target.relativePath}`);
+  }
+
+  return {
+    normalizedName: target.normalizedName,
+    created: !existedBefore,
+    relativePath: target.relativePath,
+  };
+}
+
+function resolveAddTestTarget(
+  workspaceRoot: string,
+  rawName: string,
+): {
+  readonly normalizedName: string;
+  readonly relativePath: string;
+  readonly absolutePath: string;
+} {
+  const normalizedName = rawName
+    .trim()
+    .replace(/\\/g, '/')
+    .replace(/(\.test\.ts)$/i, '');
+  const hasSlash = normalizedName.includes('/');
+
+  const relativePath = hasSlash
+    ? path.join(
+        'src',
+        path.posix.dirname(normalizedName),
+        'tests',
+        `${path.posix.basename(normalizedName)}.test.ts`,
+      )
+    : path.join('src', 'tests', `${normalizedName}.test.ts`);
+
+  return {
+    normalizedName,
+    relativePath,
+    absolutePath: path.join(workspaceRoot, relativePath),
   };
 }
 
 async function collectChangedFiles(
   workspaceRoot: string,
   absolutePaths: readonly string[],
-  before: ReadonlyMap<string, string | null>
+  before: ReadonlyMap<string, string | null>,
 ): Promise<string[]> {
   const changes: string[] = [];
   for (const absolutePath of absolutePaths) {
@@ -90,7 +195,9 @@ async function collectChangedFiles(
   return changes;
 }
 
-async function captureFileState(absolutePaths: readonly string[]): Promise<Map<string, string | null>> {
+async function captureFileState(
+  absolutePaths: readonly string[],
+): Promise<Map<string, string | null>> {
   const state = new Map<string, string | null>();
   for (const absolutePath of absolutePaths) {
     state.set(absolutePath, await readFileIfExists(absolutePath));