@bleedingdev/modern-js-create 3.4.0-ultramodern.19 → 3.4.0-ultramodern.20

package/templates/workspace-scripts/assert-mf-types.mjs.handlebars

@@ -2,10 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 const root = process.cwd();
-const generatedContractPath = path.join(
-  root,
-  '.modernjs/ultramodern-generated-contract.json',
-);
 const compactConfigPath = path.join(root, '.modernjs/ultramodern.json');
 const defaultAppDirs = {{defaultAppDirsJson}};
 
@@ -53,13 +49,7 @@ function readGeneratedContractView() {
         : [],
     };
   }
-  if (fs.existsSync(generatedContractPath)) {
-    return {
-      sourcePath: generatedContractPath,
-      ...readJson(generatedContractPath),
-    };
-  }
-  return undefined;
+  throw new Error('Missing UltraModern config. Expected .modernjs/ultramodern.json.');
 }
 
 const generatedContract = readGeneratedContractView();

package/templates/workspace-scripts/check-ultramodern-api-boundaries.mjs

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd();
+const failures = [];
+
+const ignoredDirectories = new Set([
+  '.git',
+  '.modern',
+  '.output',
+  'coverage',
+  'dist',
+  'node_modules',
+  'repos',
+]);
+
+function normalize(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+function relative(filePath) {
+  return normalize(path.relative(workspaceRoot, filePath));
+}
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(workspaceRoot, relativePath));
+}
+
+function readText(relativePath) {
+  return fs.readFileSync(path.join(workspaceRoot, relativePath), 'utf8');
+}
+
+function fail(message) {
+  failures.push(message);
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    fail(message);
+  }
+}
+
+function listFiles(startDirectory) {
+  const absoluteStart = path.join(workspaceRoot, startDirectory);
+  if (!fs.existsSync(absoluteStart)) {
+    return [];
+  }
+
+  const files = [];
+  const visit = directory => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (ignoredDirectories.has(entry.name)) {
+        continue;
+      }
+
+      const absoluteEntry = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(absoluteEntry);
+        continue;
+      }
+
+      if (entry.isFile()) {
+        files.push(relative(absoluteEntry));
+      }
+    }
+  };
+
+  visit(absoluteStart);
+  return files;
+}
+
+function listDirectories(startDirectory) {
+  const absoluteStart = path.join(workspaceRoot, startDirectory);
+  if (!fs.existsSync(absoluteStart)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(absoluteStart, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && !ignoredDirectories.has(entry.name))
+    .map(entry => path.posix.join(startDirectory, entry.name));
+}
+
+function assertNoPath(relativePath, message) {
+  if (exists(relativePath)) {
+    fail(message);
+  }
+}
+
+function assertContains(relativePath, content, pattern, message) {
+  assert(pattern.test(content), `${relativePath}: ${message}`);
+}
+
+function assertNotContains(relativePath, content, pattern, message) {
+  assert(!pattern.test(content), `${relativePath}: ${message}`);
+}
+
+const generatedFiles = [
+  ...listFiles('apps'),
+  ...listFiles('verticals'),
+  ...listFiles('packages'),
+];
+
+for (const forbiddenPath of [
+  'apps/shell-super-app/src/effect',
+  ...listDirectories('verticals').flatMap(verticalPath => [
+    `${verticalPath}/api/effect`,
+    `${verticalPath}/api/lambda`,
+    `${verticalPath}/shared/effect`,
+    `${verticalPath}/src/effect`,
+  ]),
+]) {
+  assertNoPath(
+    forbiddenPath,
+    `${forbiddenPath} is forbidden in UltraModern strictEffectApproach workspaces; use api/index.ts, shared/api.ts and src/api/* instead.`,
+  );
+}
+
+const textFiles = generatedFiles.filter(file =>
+  /\.(?:[cm]?[jt]sx?|json|md|mjs|mts|cts)$/u.test(file),
+);
+
+for (const file of textFiles) {
+  const content = readText(file);
+
+  if (/\/api\//u.test(file)) {
+    assertNotContains(
+      file,
+      content,
+      /\bnew\s+Response\s*\(|\bResponse\.json\s*\(/u,
+      'API modules must not hand-build Response objects; model the endpoint through Effect HttpApi and schemas.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\brequest\.(?:json|text|formData|arrayBuffer)\s*\(/u,
+      'API modules must not manually parse request bodies; use HttpApiEndpoint payload/query/params schemas.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\bexport\s+const\s+handler\b|\bexport\s+default\s+async\b/u,
+      'API modules must not export raw request handlers; export defineEffectBff(...) from api/index.ts.',
+    );
+    assertNotContains(
+      file,
+      content,
+      /\bcreateHandler\s*[:=]\s*(?!defineEffectBff\b)/u,
+      'API modules must not define unbranded handler factories; use defineEffectBff(...).',
+    );
+  }
+
+  assertNotContains(
+    file,
+    content,
+    /@modern-js\/plugin-bff\/hono-server/u,
+    'Hono server helpers are not part of generated UltraModern API workspaces.',
+  );
+  assertNotContains(
+    file,
+    content,
+    /runtimeFramework:\s*['"]hono['"]/u,
+    'Generated UltraModern API apps must use the Effect runtime.',
+  );
+}
+
+const shellClient = 'apps/shell-super-app/src/api/vertical-clients.ts';
+if (exists('apps/shell-super-app')) {
+  assert(exists(shellClient), `${shellClient} must aggregate vertical API clients.`);
+}
+
+for (const verticalPath of listDirectories('verticals')) {
+  const apiEntry = `${verticalPath}/api/index.ts`;
+  const sharedApi = `${verticalPath}/shared/api.ts`;
+  const srcApiDirectory = `${verticalPath}/src/api`;
+  const modernConfig = `${verticalPath}/modern.config.ts`;
+  const packageJsonPath = `${verticalPath}/package.json`;
+
+  assert(exists(apiEntry), `${apiEntry} is required.`);
+  assert(exists(sharedApi), `${sharedApi} is required.`);
+  assert(exists(srcApiDirectory), `${srcApiDirectory} is required.`);
+
+  if (exists(srcApiDirectory)) {
+    const clientFiles = listFiles(srcApiDirectory).filter(file =>
+      /-client\.ts$/u.test(file),
+    );
+    assert(
+      clientFiles.length > 0,
+      `${srcApiDirectory} must contain a generated API client.`,
+    );
+  }
+
+  if (exists(apiEntry)) {
+    const entry = readText(apiEntry);
+    assertContains(
+      apiEntry,
+      entry,
+      /\bdefineEffectBff\b/u,
+      'must export a defineEffectBff(...) runtime definition.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /\bHttpApiBuilder\b/u,
+      'must implement handlers through HttpApiBuilder.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /\bLayer\b/u,
+      'must compose dependencies with Effect Layer.',
+    );
+    assertContains(
+      apiEntry,
+      entry,
+      /from ['"]\.\.\/shared\/api\.ts['"]/u,
+      'must import the contract from ../shared/api.ts.',
+    );
+  }
+
+  if (exists(sharedApi)) {
+    const contract = readText(sharedApi);
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApi\.make\b/u,
+      'must declare the HttpApi contract.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApiGroup\.make\b/u,
+      'must declare HttpApi groups.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bHttpApiEndpoint\./u,
+      'must declare endpoints through HttpApiEndpoint.',
+    );
+    assertContains(
+      sharedApi,
+      contract,
+      /\bSchema\./u,
+      'must use Schema for request, response and error shapes.',
+    );
+  }
+
+  if (exists(modernConfig)) {
+    const config = readText(modernConfig);
+    assertContains(
+      modernConfig,
+      config,
+      /runtimeFramework:\s*['"]effect['"]/u,
+      'must use bff.runtimeFramework: effect.',
+    );
+    assertContains(
+      modernConfig,
+      config,
+      /entry:\s*['"]\.\/api\/index['"]/u,
+      'must point bff.effect.entry at ./api/index.',
+    );
+    assertContains(
+      modernConfig,
+      config,
+      /strictEffectApproach:\s*true/u,
+      'must enable strictEffectApproach explicitly.',
+    );
+  }
+
+  if (exists(packageJsonPath)) {
+    const packageJson = JSON.parse(readText(packageJsonPath));
+    assert(
+      packageJson.exports?.['./api'] === './shared/api.ts',
+      `${packageJsonPath}: package must export ./api from shared/api.ts.`,
+    );
+    assert(
+      typeof packageJson.exports?.['./api/client'] === 'string' &&
+        packageJson.exports['./api/client'].startsWith('./src/api/'),
+      `${packageJsonPath}: package must export ./api/client from src/api/*.`,
+    );
+  }
+}
+
+if (exists('apps/shell-super-app/package.json')) {
+  const shellPackageJson = JSON.parse(
+    readText('apps/shell-super-app/package.json'),
+  );
+  assert(
+    shellPackageJson.exports?.['./api/clients'] ===
+      './src/api/vertical-clients.ts',
+    'apps/shell-super-app/package.json must export ./api/clients.',
+  );
+}
+
+if (exists('package.json')) {
+  const rootPackageJson = JSON.parse(readText('package.json'));
+  assert(
+    rootPackageJson.scripts?.['api:check'] ===
+      'node ./scripts/check-ultramodern-api-boundaries.mjs',
+    'Root package.json must expose api:check.',
+  );
+  assert(
+    rootPackageJson.scripts?.check?.includes('pnpm api:check'),
+    'Root check script must include pnpm api:check.',
+  );
+}
+
+if (exists('topology/reference-topology.json')) {
+  const topology = JSON.parse(readText('topology/reference-topology.json'));
+  for (const vertical of topology.verticals ?? []) {
+    if (vertical.api?.runtime === 'effect') {
+      assert(
+        vertical.api.bff?.strictEffectApproach === true,
+        `${vertical.id} topology must mark strictEffectApproach as true.`,
+      );
+      assert(
+        typeof vertical.api.serverEntry === 'string' &&
+          vertical.api.serverEntry.endsWith('/api/index.ts'),
+        `${vertical.id} topology must use api/index.ts as the server entry.`,
+      );
+    }
+    assert(
+      !vertical.api?.effect,
+      `${vertical.id} topology must describe the API directly, not under api.effect.`,
+    );
+  }
+}
+
+if (failures.length > 0) {
+  console.error('UltraModern API boundary check failed:');
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  process.exit(1);
+}
+
+console.log('UltraModern API boundary check passed.');

package/templates/workspace-scripts/generate-public-surface-assets.mjs

@@ -7,10 +7,6 @@ const workspaceRoot = path.resolve(
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
     path.join(path.dirname(fileURLToPath(import.meta.url)), '..'),
 );
-const contractPath = path.join(
-  workspaceRoot,
-  '.modernjs/ultramodern-generated-contract.json',
-);
 const compactConfigPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
 
 function readJson(filePath) {
@@ -107,6 +103,10 @@ function normalizeCompactApp(rawApp) {
     marker: {
       appId: id,
     },
+    routes:
+      rawApp.routes && typeof rawApp.routes === 'object'
+        ? rawApp.routes
+        : undefined,
     effectApi:
       rawApp.effectApi && typeof rawApp.effectApi === 'object'
         ? {
@@ -165,7 +165,7 @@ function createPublicRoutes(app) {
 
 function createPublicSurface(app) {
   const publicRoutes = createPublicRoutes(app);
-  return {
+  const basePublicSurface = {
     authoring: 'colocated-route-meta',
     artifactLifecycle: 'build-and-deploy-output',
     generatedManifest: './src/routes/ultramodern-route-metadata',
@@ -195,6 +195,14 @@ function createPublicSurface(app) {
     routeEntries: [],
     concreteUrlPaths: [],
   };
+
+  return app.routes?.publicSurface &&
+    typeof app.routes.publicSurface === 'object'
+    ? {
+        ...basePublicSurface,
+        ...app.routes.publicSurface,
+      }
+    : basePublicSurface;
 }
 
 function createCloudflareDeploy(config, app) {
@@ -237,17 +245,11 @@ function readGeneratedContractView() {
   if (fs.existsSync(compactConfigPath)) {
     return synthesizeContractFromCompactConfig(readJson(compactConfigPath));
   }
-  if (fs.existsSync(contractPath)) {
-    return {
-      sourcePath: contractPath,
-      ...readJson(contractPath),
-    };
-  }
   throw new Error(
     `Missing UltraModern config. Expected ${path.relative(
       workspaceRoot,
       compactConfigPath,
-    )} or ${path.relative(workspaceRoot, contractPath)}.`,
+    )}.`,
   );
 }
 

package/templates/workspace-scripts/proof-cloudflare-version.mjs

@@ -9,10 +9,6 @@ const workspaceRoot = path.resolve(
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
     path.join(path.dirname(fileURLToPath(import.meta.url)), '..'),
 );
-const contractPath = path.join(
-  workspaceRoot,
-  '.modernjs/ultramodern-generated-contract.json',
-);
 const compactConfigPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
 const defaultOut = path.join(
   workspaceRoot,
@@ -219,7 +215,7 @@ function createCloudflareRoutes(app) {
     locale: `/locales/en/${appNamespace(app)}.json`,
     ...(app.effectApi
       ? {
-          effectReadiness: `${app.effectApi.prefix}/effect/${app.effectApi.stem}/readiness`,
+          apiReadiness: `${app.effectApi.prefix}/${app.effectApi.stem}/readiness`,
         }
       : {}),
   };
@@ -285,17 +281,11 @@ function readGeneratedContractView() {
   if (fs.existsSync(compactConfigPath)) {
     return synthesizeContractFromCompactConfig(readJson(compactConfigPath));
   }
-  if (fs.existsSync(contractPath)) {
-    return {
-      sourcePath: contractPath,
-      ...readJson(contractPath),
-    };
-  }
   throw new Error(
     `Missing UltraModern config. Expected ${path.relative(
       workspaceRoot,
       compactConfigPath,
-    )} or ${path.relative(workspaceRoot, contractPath)}.`,
+    )}.`,
   );
 }
 
@@ -379,7 +369,7 @@ async function main(argv = process.argv.slice(2)) {
     schemaVersion: 1,
     generatedAt: new Date().toISOString(),
     status: results.length > 0 ? 'pass' : 'skipped',
-    contractPath: contract.sourcePath ?? contractPath,
+    contractPath: contract.sourcePath ?? compactConfigPath,
     results,
     skipped,
   };

package/templates/workspace-scripts/ultramodern-cloudflare-proof.mjs

@@ -840,13 +840,13 @@ async function validateI18nEvidence(evidence, app, publicUrl, routes) {
 }
 
 async function validateReadinessEvidence(evidence, app, publicUrl, routes) {
-  if (routes.effectReadiness) {
-    const readiness = await fetchText(joinUrl(publicUrl, routes.effectReadiness));
+  if (routes.apiReadiness) {
+    const readiness = await fetchText(joinUrl(publicUrl, routes.apiReadiness));
     const readinessJson = parseMaybeJson(readiness.body);
     const apiMarker = markerFromJson(readinessJson);
     evidence.assertions.push({
       type: 'api-marker',
-      route: routes.effectReadiness,
+      route: routes.apiReadiness,
       expected: app.marker?.build,
       actual: apiMarker,
       status: readiness.ok && apiMarker === app.marker?.build ? 'pass' : 'fail',

package/templates/workspace-scripts/ultramodern-performance-readiness.mjs

@@ -7,7 +7,6 @@ const defaultReportPath =
   '.codex/reports/performance-readiness/ultramodern-performance-readiness.json';
 const configPath = 'scripts/ultramodern-performance-readiness.config.mjs';
 const compactConfigPath = '.modernjs/ultramodern.json';
-const legacyContractPath = '.modernjs/ultramodern-generated-contract.json';
 const optOutEnv = 'ULTRAMODERN_PERFORMANCE_READINESS_DIAGNOSTICS';
 const signalIds = [
   'bfcache',
@@ -219,15 +218,8 @@ const readGeneratedContractView = () => {
     };
   }
 
-  if (exists(legacyContractPath)) {
-    return {
-      sourcePath: legacyContractPath,
-      ...readJson(legacyContractPath),
-    };
-  }
-
   throw new Error(
-    `Missing UltraModern config. Expected ${compactConfigPath} or ${legacyContractPath}.`,
+    `Missing UltraModern config. Expected ${compactConfigPath}.`,
   );
 };