@shipfox/client-shell 0.2.0 → 2.0.0

package/test/external/verify.mjs

@@ -1,17 +1,30 @@
 import {spawn} from 'node:child_process';
 import {globSync} from 'node:fs';
-import {cp, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile} from 'node:fs/promises';
+import {
+  cp,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  realpath,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises';
 import {tmpdir} from 'node:os';
-import {basename, join, relative, resolve, sep} from 'node:path';
+import {basename, dirname, join, relative, resolve, sep} from 'node:path';
 import {fileURLToPath, pathToFileURL} from 'node:url';
 
 const repositoryRoot = resolve(fileURLToPath(new URL('../../../../..', import.meta.url)));
 const externalRoot = fileURLToPath(new URL('.', import.meta.url));
 const fixtureTemplate = join(externalRoot, 'fixture');
 const REGISTRY_SHIPFOX_PACKAGE_PATTERN = /^@shipfox\+[^@]+@\d/u;
-const linkMode = process.argv.includes('--link');
+const EXPECTED_COLLISION_DIAGNOSTIC =
+  'Route "/auth/login" is contributed by both features "shipfox.auth" and "fixture.unapproved-collision". Set override: true to replace it explicitly.';
+const arguments_ = process.argv.slice(2).filter((argument) => argument !== '--');
+const linkMode = arguments_.includes('--link');
 
-if (process.argv.some((argument) => argument.startsWith('--') && argument !== '--link')) {
+if (arguments_.some((argument) => argument.startsWith('--') && argument !== '--link')) {
   throw new Error('Usage: node verify.mjs [--link]');
 }
 
@@ -26,18 +39,29 @@ const {
 } = await import(
   pathToFileURL(join(repositoryRoot, 'tools/application-release/dist/package-closure.js')).href
 );
+const {productionizeManifest} = await import(
+  pathToFileURL(join(repositoryRoot, 'tools/utils/src/productionize.js')).href
+);
 const config = readPublicationClosureConfig(join(repositoryRoot, 'publication-closure.json'));
 const workspacePackages = readWorkspacePackages(repositoryRoot);
 validatePublicationState(workspacePackages, config, repositoryRoot);
 const clientRoots = config.roots.filter((root) => root.startsWith('@shipfox/client-'));
+const fixtureSupportPackages = ['@shipfox/client-config'];
+const consumerPackages = [...clientRoots, ...fixtureSupportPackages];
 const closure = computePublicationClosure(workspacePackages, clientRoots);
 const entryPoints = closure.flatMap((name) =>
   listConcreteEntryPoints(name, requiredPackage(workspacePackages, name)),
 );
+const consumerTypeEntryPoints = clientRoots.flatMap((name) =>
+  listConcreteEntryPoints(name, requiredPackage(workspacePackages, name)),
+);
+const closureTypeEntryPoints = entryPoints
+  .filter(({target}) => entryPointSupportsTypeResolution(target))
+  .map(({specifier}) => specifier);
 const runtimeEntryPoints = entryPoints
   .filter(({target}) => entryPointSupportsRuntimeImport(target))
   .map(({specifier}) => specifier);
-const typeEntryPoints = entryPoints
+const typeEntryPoints = consumerTypeEntryPoints
   .filter(({target}) => entryPointSupportsTypeResolution(target))
   .map(({specifier}) => specifier);
 const temporaryRoot = await mkdtemp(join(tmpdir(), 'shipfox-client-composition-'));
@@ -48,23 +72,51 @@ try {
   const packageSpecs = linkMode
     ? linkedPackageSpecs(closure, workspacePackages)
     : await packedPackageSpecs(closure, workspacePackages, temporaryRoot);
-  await configureFixture(fixtureRoot, packageSpecs);
+  await configureFixture(fixtureRoot, consumerPackages, packageSpecs);
   await writeTypeFixture(fixtureRoot, typeEntryPoints);
-  await run('pnpm', ['install', '--prefer-offline', '--ignore-scripts'], fixtureRoot);
+  await run('pnpm', ['install', '--prefer-offline', '--ignore-scripts'], fixtureRoot, {
+    capture: true,
+  });
 
-  if (linkMode) await validateLinkedPackages(fixtureRoot, closure, workspacePackages);
+  if (linkMode) await validateLinkedPackages(fixtureRoot, consumerPackages, workspacePackages);
   else {
     await validateInstalledPackages(fixtureRoot, closure, workspacePackages);
     await validateNoRegistryShipfoxPackages(fixtureRoot);
-    await validateDefaultPackageResolution(fixtureRoot, runtimeEntryPoints);
+    await validatePackageResolution(fixtureRoot, runtimeEntryPoints, {
+      conditionLabel: 'default',
+    });
+    await validatePackageResolution(fixtureRoot, runtimeEntryPoints, {
+      nodeArgs: ['--conditions=development'],
+      conditionLabel: 'development',
+    });
+    await validateFullClosureTypeDeclarations(fixtureRoot, closureTypeEntryPoints);
   }
 
-  await run('pnpm', ['exec', 'vite', 'build'], fixtureRoot);
-  await run('pnpm', ['exec', 'tsc', '--noEmit'], fixtureRoot);
+  await run('pnpm', ['exec', 'vite', 'build'], fixtureRoot, {capture: true});
+  await validateGeneratedModule(fixtureRoot);
+  await run('pnpm', ['exec', 'vitest', 'run', '--mode', 'production'], fixtureRoot, {
+    capture: true,
+    env: {NODE_ENV: 'production'},
+  });
+  await run('pnpm', ['exec', 'tsc', '--noEmit'], fixtureRoot, {capture: true});
+
+  const collision = await run('pnpm', ['exec', 'vite', 'build'], fixtureRoot, {
+    capture: true,
+    allowFailure: true,
+    env: {SHIPFOX_COMPOSITION_COLLISION: '1'},
+  });
+  if (collision.code === 0) throw new Error('Collision fixture unexpectedly built successfully.');
+  const collisionOutput = `${collision.stdout}\n${collision.stderr}`;
+  if (!collisionOutput.includes(EXPECTED_COLLISION_DIAGNOSTIC)) {
+    throw new Error(
+      `Collision output did not include the contract diagnostic:\n${EXPECTED_COLLISION_DIAGNOSTIC}\n\n${collisionOutput}`,
+    );
+  }
 
   process.stdout.write(
-    `Verified ${closure.length} external client runtime packages and ${entryPoints.length} public entry points in ${linkMode ? 'linked' : 'packed-tarball'} mode.\n`,
+    `Verified the default client composition, ${closure.length} runtime packages, and ${entryPoints.length} public entry points in ${linkMode ? 'linked' : 'packed-tarball'} mode.\n`,
   );
+  process.stdout.write(`Collision: ${EXPECTED_COLLISION_DIAGNOSTIC}\n`);
 } finally {
   await rm(temporaryRoot, {recursive: true, force: true});
 }
@@ -80,20 +132,42 @@ function linkedPackageSpecs(names, packages) {
 
 async function packedPackageSpecs(names, packages, root) {
   const tarballRoot = join(root, 'tarballs');
-  await mkdir(tarballRoot);
+  const stagingRoot = join(root, 'packages');
+  await Promise.all([
+    mkdir(tarballRoot),
+    mkdir(stagingRoot),
+    cp(join(repositoryRoot, 'pnpm-workspace.yaml'), join(stagingRoot, 'pnpm-workspace.yaml')),
+  ]);
   const tarballs = await mapWithConcurrency(names, 4, async (name) => {
     const workspacePackage = requiredPackage(packages, name);
     const tarball = join(tarballRoot, `${safePackageName(name)}.tgz`);
-    await run('pnpm', ['pack', '--out', tarball], workspacePackage.directory, {capture: true});
+    await packProductionizedPackage(workspacePackage, tarball, stagingRoot);
     return [name, `file:${tarball}`];
   });
   return Object.fromEntries(tarballs);
 }
 
-async function configureFixture(root, packageSpecs) {
+async function packProductionizedPackage(workspacePackage, tarball, stagingRoot) {
+  const packageRoot = join(stagingRoot, safePackageName(workspacePackage.manifest.name));
+  await cp(workspacePackage.directory, packageRoot, {recursive: true});
+
+  const manifestPath = join(packageRoot, 'package.json');
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+  const productionized = productionizeManifest(manifest);
+  if (productionized !== manifest) {
+    await writeFile(manifestPath, `${JSON.stringify(productionized, null, 2)}\n`);
+  }
+
+  await run('pnpm', ['pack', '--out', tarball], packageRoot, {capture: true});
+}
+
+async function configureFixture(root, consumerPackages, packageSpecs) {
   const manifestPath = join(root, 'package.json');
   const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
-  manifest.dependencies = {...manifest.dependencies, ...packageSpecs};
+  const consumerDependencies = Object.fromEntries(
+    consumerPackages.map((name) => [name, packageSpecs[name]]),
+  );
+  manifest.dependencies = {...manifest.dependencies, ...consumerDependencies};
   await Promise.all([
     writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`),
     writeFile(
@@ -131,21 +205,24 @@ async function validateLinkedPackages(root, names, packages) {
 async function validateInstalledPackages(root, names, packages) {
   const realFixtureRoot = await realpath(root);
   for (const name of names) {
-    const installedManifestPath = join(root, 'node_modules', name, 'package.json');
-    const installedManifest = JSON.parse(await readFile(installedManifestPath, 'utf8'));
-    const expectedManifest = requiredPackage(packages, name).manifest;
-    if (installedManifest.version !== expectedManifest.version) {
-      throw new Error(
-        `Packed ${name} has version ${installedManifest.version}; expected ${expectedManifest.version}`,
+    for (const packageRoot of installedPackageRoots(root, name)) {
+      const installedManifest = JSON.parse(
+        await readFile(join(packageRoot, 'package.json'), 'utf8'),
       );
-    }
-    const workspaceRange = findWorkspaceRange(installedManifest);
-    if (workspaceRange)
-      throw new Error(`Packed ${name} contains a workspace range at ${workspaceRange}`);
-    validateDefaultInternalImports(name, installedManifest);
-    const installedRoot = await realpath(join(root, 'node_modules', name));
-    if (!installedRoot.startsWith(realFixtureRoot)) {
-      throw new Error(`Packed ${name} resolved outside the external consumer`);
+      const expectedManifest = requiredPackage(packages, name).manifest;
+      if (installedManifest.version !== expectedManifest.version) {
+        throw new Error(
+          `Packed ${name} has version ${installedManifest.version}; expected ${expectedManifest.version}`,
+        );
+      }
+      const workspaceRange = findWorkspaceRange(installedManifest);
+      if (workspaceRange)
+        throw new Error(`Packed ${name} contains a workspace range at ${workspaceRange}`);
+      validateDefaultInternalImports(name, installedManifest);
+      const installedRoot = await realpath(packageRoot);
+      if (!installedRoot.startsWith(realFixtureRoot)) {
+        throw new Error(`Packed ${name} resolved outside the external consumer`);
+      }
     }
   }
 }
@@ -153,6 +230,7 @@ async function validateInstalledPackages(root, names, packages) {
 function validateDefaultInternalImports(name, manifest) {
   const internalImports = manifest.imports?.['#*'];
   if (internalImports === undefined) return;
+  if (internalImports === './dist/*') return;
   if (
     !internalImports ||
     typeof internalImports !== 'object' ||
@@ -163,26 +241,96 @@ function validateDefaultInternalImports(name, manifest) {
   }
 }
 
-async function validateDefaultPackageResolution(root, specifiers) {
-  const resolution = await run(
-    process.execPath,
-    [
-      '--input-type=module',
-      '--eval',
-      `const specifiers = ${JSON.stringify(specifiers)};
+async function validatePackageResolution(root, specifiers, {nodeArgs = [], conditionLabel}) {
+  const specifiersByPackage = Map.groupBy(specifiers, packageNameFromSpecifier);
+  for (const [packageName, packageSpecifiers] of specifiersByPackage) {
+    for (const packageRoot of installedPackageRoots(root, packageName)) {
+      const resolution = await run(
+        process.execPath,
+        [
+          ...nodeArgs,
+          '--input-type=module',
+          '--eval',
+          `const specifiers = ${JSON.stringify(packageSpecifiers)};
 const resolved = Object.fromEntries(specifiers.map((specifier) => [specifier, import.meta.resolve(specifier)]));
 process.stdout.write(JSON.stringify(resolved));`,
-    ],
-    root,
-    {capture: true},
-  );
-  const resolved = JSON.parse(resolution.stdout);
-  for (const specifier of specifiers) {
-    const resolvedPath = fileURLToPath(resolved[specifier]);
-    if (!resolvedPath.split(sep).includes('dist')) {
-      throw new Error(`Packed ${specifier} resolved to source instead of dist: ${resolvedPath}`);
+        ],
+        packageRoot,
+        {capture: true},
+      );
+      const resolved = JSON.parse(resolution.stdout);
+      for (const specifier of packageSpecifiers) {
+        const resolvedPath = fileURLToPath(resolved[specifier]);
+        if (!resolvedPath.split(sep).includes('dist')) {
+          throw new Error(
+            `Packed ${specifier} resolved to source instead of dist under the ${conditionLabel} condition: ${resolvedPath}`,
+          );
+        }
+      }
+    }
+  }
+}
+
+async function validateFullClosureTypeDeclarations(root, specifiers) {
+  const typeScriptCli = join(root, 'node_modules', 'typescript', 'bin', 'tsc');
+  const specifiersByPackage = Map.groupBy(specifiers, packageNameFromSpecifier);
+  const auditRoot = join(root, 'full-closure-types');
+  const typeFixtures = [];
+  let auditIndex = 0;
+  for (const [packageName, packageSpecifiers] of specifiersByPackage) {
+    for (const packageRoot of installedPackageRoots(root, packageName)) {
+      const packageAuditRoot = join(auditRoot, String(auditIndex));
+      auditIndex += 1;
+      await writeTypeAudit(packageAuditRoot, packageName, packageRoot, packageSpecifiers);
+      typeFixtures.push(relative(auditRoot, join(packageAuditRoot, 'types.ts')));
     }
   }
+
+  await writeTypeAuditConfig(auditRoot, typeFixtures);
+  await run(process.execPath, [typeScriptCli, '--project', 'tsconfig.json'], auditRoot, {
+    capture: true,
+  });
+}
+
+async function writeTypeAudit(root, packageName, packageRoot, specifiers) {
+  const packageLink = join(root, 'node_modules', ...packageName.split('/'));
+  await mkdir(dirname(packageLink), {recursive: true});
+  await symlink(packageRoot, packageLink, 'dir');
+  await writeTypeFixture(root, specifiers);
+}
+
+async function writeTypeAuditConfig(root, typeFixtures) {
+  await writeFile(
+    join(root, 'tsconfig.json'),
+    `${JSON.stringify(
+      {
+        compilerOptions: {
+          strict: true,
+          target: 'ES2022',
+          lib: ['ES2022', 'DOM', 'DOM.Iterable'],
+          module: 'ESNext',
+          moduleResolution: 'bundler',
+          jsx: 'react-jsx',
+          skipLibCheck: false,
+          verbatimModuleSyntax: true,
+          noEmit: true,
+        },
+        files: typeFixtures,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+function installedPackageRoots(root, packageName) {
+  const packageRoots = globSync(
+    join(root, 'node_modules/.pnpm/**/node_modules', packageName),
+  ).sort();
+  if (!packageRoots.length) {
+    throw new Error(`Packed closure package is not installed: ${packageName}`);
+  }
+  return packageRoots;
 }
 
 async function validateNoRegistryShipfoxPackages(root) {
@@ -198,6 +346,28 @@ async function validateNoRegistryShipfoxPackages(root) {
   }
 }
 
+async function validateGeneratedModule(root) {
+  const generated = await readFile(join(root, 'src/shipfox-app.gen.ts'), 'utf8');
+  const manifest = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+  const declaredDependencies = new Set(Object.keys(manifest.dependencies));
+
+  for (const match of generated.matchAll(/\bfrom\s+['"]([^'"]+)['"]/gu)) {
+    const specifier = match[1];
+    if (specifier.startsWith('.') || specifier.startsWith('/')) continue;
+    const packageName = packageNameFromSpecifier(specifier);
+    if (!declaredDependencies.has(packageName)) {
+      throw new Error(
+        `Generated default composition imports undeclared package ${JSON.stringify(packageName)} from ${JSON.stringify(specifier)}.`,
+      );
+    }
+  }
+}
+
+function packageNameFromSpecifier(specifier) {
+  if (!specifier.startsWith('@')) return specifier.split('/')[0];
+  return specifier.split('/').slice(0, 2).join('/');
+}
+
 function requiredPackage(packages, name) {
   const workspacePackage = packages.get(name);
   if (!workspacePackage) throw new Error(`Missing workspace package: ${name}`);
@@ -303,7 +473,7 @@ function run(command, args, cwd, options = {}) {
       stderr += chunk;
     });
     child.on('error', reject);
-    child.on('exit', (code) => {
+    child.on('close', (code) => {
       const result = {code: code ?? 1, stdout, stderr};
       if (code === 0 || allowFailure) resolvePromise(result);
       else {

package/test/typecheck/shipfox-app.gen.ts

@@ -3,9 +3,9 @@
 // biome-ignore-all assist/source/organizeImports: generated imports follow route order.
 import {createRoute, createRouter} from '@tanstack/react-router';
 import {buildAnchorSkeleton, isRouteImpl, type RouteImpl, type RouterContext} from '@shipfox/client-shell/runtime';
-import route0Impl from "#test/search-route-impl.js";
-import route1Impl from "#test/default-route-impl.js";
-import route2Impl from "#test/named-route-impl.js";
+import * as route0Module from "#test/search-route-impl.js";
+import * as route1Module from "#test/default-route-impl.js";
+import * as route2Module from "#test/named-route-impl.js";
 
 function routeOptions<T extends RouteImpl>(routeImpl: T, impl: string, path: string): T['options'] {
   if (!isRouteImpl(routeImpl)) {
@@ -45,19 +45,19 @@ const skeleton = buildAnchorSkeleton({
 const route0 = createRoute({
   getParentRoute: () => skeleton.projectLayout,
   path: "/overview",
-  ...routeOptions(route0Impl, "#test/search-route-impl.js", "/workspaces/$wid/projects/$pid/overview"),
+  ...routeOptions(route0Module.default, "#test/search-route-impl.js", "/workspaces/$wid/projects/$pid/overview"),
 });
 
 const route1 = createRoute({
   getParentRoute: () => skeleton.workspaceSettings,
   path: "/members",
-  ...routeOptions(route1Impl, "#test/default-route-impl.js", "/workspaces/$wid/settings/members"),
+  ...routeOptions(route1Module.default, "#test/default-route-impl.js", "/workspaces/$wid/settings/members"),
 });
 
 const route2 = createRoute({
   getParentRoute: () => skeleton.workspaceLayout,
   path: "/insights",
-  ...routeOptions(route2Impl, "#test/named-route-impl.js", "/workspaces/$wid/insights"),
+  ...routeOptions(route2Module.default, "#test/named-route-impl.js", "/workspaces/$wid/insights"),
 });
 
 const projectLayout = skeleton.projectLayout.addChildren([route0]);

package/test/typecheck/types.tsx

@@ -1,10 +1,15 @@
-import {Link, useSearch} from '@tanstack/react-router';
+import {getRouteApi, Link, useSearch} from '@tanstack/react-router';
 import './shipfox-app.gen.js';
 
 export function CompositionTypes(): React.ReactNode {
   const search = useSearch({from: '/workspaces/$wid/projects/$pid/overview'});
   const tab: 'activity' | 'overview' = search.tab;
 
+  getRouteApi('/workspaces/$wid/projects/$pid/overview');
+
+  // @ts-expect-error The generated route tree rejects unknown route ids.
+  getRouteApi('/not-a-route');
+
   return (
     <>
       <Link to="/workspaces/$wid/insights" params={{wid: 'workspace'}}>