refactor: consolidate single-source routing and protocol helpers

scripts/dev/copy-runtime-db-generated.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -16,15 +16,23 @@ afterEach(() => {
 });
 
 describe('copyRuntimeDbGeneratedAssets', () => {
-  it('copies generated runtime db artifacts into dist', () => {
+  it('copies generated runtime db artifacts and shared runtime modules into dist', () => {
     const repoRoot = mkdtempSync(join(tmpdir(), 'metapi-runtime-db-assets-'));
     tempDirs.push(repoRoot);
 
     const sourceDir = join(repoRoot, 'src', 'server', 'db', 'generated');
     const nestedDir = join(sourceDir, 'fixtures');
+    const sharedDir = join(repoRoot, 'src', 'shared');
+    const staleSharedDistDir = join(repoRoot, 'dist', 'shared');
     mkdirSync(nestedDir, { recursive: true });
+    mkdirSync(sharedDir, { recursive: true });
+    mkdirSync(staleSharedDistDir, { recursive: true });
     writeFileSync(join(sourceDir, 'mysql.bootstrap.sql'), 'create table demo ();');
     writeFileSync(join(nestedDir, 'baseline.json'), '{"ok":true}');
+    writeFileSync(join(sharedDir, 'tokenRouteContract.d.ts'), 'export declare const demo: number;\n');
+    writeFileSync(join(sharedDir, 'tokenRouteContract.js'), 'export const demo = 1;\n');
+    writeFileSync(join(sharedDir, 'tokenRouteContract.test.ts'), 'throw new Error("should not ship");\n');
+    writeFileSync(join(staleSharedDistDir, 'tokenRouteContract.test.ts'), 'stale test artifact\n');
 
     copyRuntimeDbGeneratedAssets(repoRoot);
 
@@ -34,5 +42,14 @@ describe('copyRuntimeDbGeneratedAssets', () => {
     expect(
       readFileSync(join(repoRoot, 'dist', 'server', 'db', 'generated', 'fixtures', 'baseline.json'), 'utf8'),
     ).toBe('{"ok":true}');
+    expect(
+      readFileSync(join(repoRoot, 'dist', 'shared', 'tokenRouteContract.js'), 'utf8'),
+    ).toBe('export const demo = 1;\n');
+    expect(
+      readFileSync(join(repoRoot, 'dist', 'shared', 'tokenRouteContract.d.ts'), 'utf8'),
+    ).toBe('export declare const demo: number;\n');
+    expect(
+      existsSync(join(repoRoot, 'dist', 'shared', 'tokenRouteContract.test.ts')),
+    ).toBe(false);
   });
 });

scripts/dev/copy-runtime-db-generated.ts

@@ -1,14 +1,22 @@
-import { cpSync, existsSync, mkdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { cpSync, existsSync, mkdirSync, rmSync, statSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 function resolveRepoRoot(): string {
   return resolve(dirname(fileURLToPath(import.meta.url)), '../..');
 }
 
+function shouldCopySharedArtifact(sourcePath: string): boolean {
+  if (statSync(sourcePath).isDirectory()) return true;
+  const filename = basename(sourcePath);
+  return filename.endsWith('.js') || filename.endsWith('.d.ts');
+}
+
 export function copyRuntimeDbGeneratedAssets(repoRoot: string = resolveRepoRoot()): void {
   const sourceDir = resolve(repoRoot, 'src/server/db/generated');
   const targetDir = resolve(repoRoot, 'dist/server/db/generated');
+  const sharedSourceDir = resolve(repoRoot, 'src/shared');
+  const sharedTargetDir = resolve(repoRoot, 'dist/shared');
 
   if (!existsSync(sourceDir)) {
     throw new Error(`Runtime DB generated assets directory does not exist: ${sourceDir}`);
@@ -16,6 +24,16 @@ export function copyRuntimeDbGeneratedAssets(repoRoot: string = resolveRepoRoot(
 
   mkdirSync(dirname(targetDir), { recursive: true });
   cpSync(sourceDir, targetDir, { recursive: true, force: true });
+
+  if (existsSync(sharedSourceDir)) {
+    rmSync(sharedTargetDir, { recursive: true, force: true });
+    mkdirSync(dirname(sharedTargetDir), { recursive: true });
+    cpSync(sharedSourceDir, sharedTargetDir, {
+      recursive: true,
+      force: true,
+      filter: (sourcePath) => shouldCopySharedArtifact(sourcePath),
+    });
+  }
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {