@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/templates/workspace/verticals/src/api/checkout-cart-client-exports.ts.handlebars

@@ -0,0 +1,70 @@
+
+export interface CheckoutCartLine {
+  sku: string;
+  name: string;
+  quantity: number;
+  unitPriceCents: number;
+}
+
+export interface CheckoutCart {
+  lines: readonly CheckoutCartLine[];
+  subtotalCents: number;
+  totalQuantity: number;
+}
+
+export interface CheckoutAddCartItemInput {
+  sku: string;
+  name?: string;
+  quantity: number;
+  unitPriceCents?: number;
+}
+
+export const getCheckoutCart = (
+  options: {{value0}} = {},
+): {{value1}}<CheckoutCart> =>
+  {{value2}}({
+    ...options,
+    operationContext:
+      options.operationContext ?? {{value3}}OperationContexts.getCart,
+  }).pipe(
+    Effect.flatMap(client => client.{{value4}}.getCart({})),
+  );
+
+export const addCheckoutCartItem = (
+  payload: CheckoutAddCartItemInput,
+  options: {{value5}} = {},
+): {{value6}}<CheckoutCart> =>
+  {{value7}}({
+    ...options,
+    operationContext:
+      options.operationContext ?? {{value8}}OperationContexts.addCartItem,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.{{value9}}.addCartItem({ payload }),
+    ),
+  );
+
+export const removeCheckoutCartItem = (
+  sku: string,
+  options: {{value10}} = {},
+): {{value11}}<CheckoutCart> =>
+  {{value12}}({
+    ...options,
+    operationContext:
+      options.operationContext ?? {{value13}}OperationContexts.removeCartItem,
+  }).pipe(
+    Effect.flatMap(client =>
+      client.{{value14}}.removeCartItem({ payload: { sku } }),
+    ),
+  );
+
+export const clearCheckoutCart = (
+  options: {{value15}} = {},
+): {{value16}}<CheckoutCart> =>
+  {{value17}}({
+    ...options,
+    operationContext:
+      options.operationContext ?? {{value18}}OperationContexts.clearCart,
+  }).pipe(
+    Effect.flatMap(client => client.{{value19}}.clearCart({})),
+  );

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

@@ -38,7 +38,7 @@ function readGeneratedContractView() {
                   : [],
                 dts: {
                   compilerInstance:
-                    moduleFederation.dts?.compilerInstance ?? 'tsgo',
+                    moduleFederation.dts?.compilerInstance ?? 'effect-tsgo',
                   tsConfigPath:
                     moduleFederation.dts?.tsConfigPath ??
                     './tsconfig.mf-types.json',
@@ -59,7 +59,7 @@ if (args.includes('--help') || args.includes('-h')) {
   process.stdout.write(`Usage:
   node scripts/assert-mf-types.mts [app-dir...]
 
-Checks that every Module Federation remote with exposed modules emitted a non-empty dist/@mf-types.zip archive and uses the workspace TypeScript compiler.
+Checks that every Module Federation remote with exposed modules emitted a non-empty dist/@mf-types.zip archive and uses the @effect/tsgo compiler.
 `);
   process.exit(0);
 }
@@ -85,10 +85,10 @@ for (const appDir of appDirs) {
   if (
     contractEntry &&
     contractEntry.moduleFederation?.dts?.compilerInstance !==
-      'tsgo'
+      'effect-tsgo'
   ) {
     throw new Error(
-      `Module Federation DTS must use the workspace TypeScript compiler: ${appDir}`,
+      `Module Federation DTS must resolve @effect/tsgo compiler: ${appDir}`,
     );
   }
   if (

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

@@ -189,6 +189,7 @@ if (exists('apps/shell-super-app') && verticalDirectories.length > 0) {
 
 function assertApiSurface(appPath) {
   const apiEntry = `${appPath}/api/index.ts`;
+  const backendEffectExpose = `${appPath}/api/effect-api.ts`;
   const sharedApi = `${appPath}/shared/api.ts`;
   const srcApiDirectory = `${appPath}/src/api`;
   const modernConfig = `${appPath}/modern.config.ts`;
@@ -235,8 +236,45 @@ function assertApiSurface(appPath) {
       'must import the contract from ../shared/api.ts.',
     );
   }
-
-  if (exists(sharedApi)) {
+ if (exists(backendEffectExpose)) {
+ const backendExpose = readText(backendEffectExpose);
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /backendFederationContract/u,
+ 'must export backendFederationContract metadata.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /role:\s*['"]microvertical-server['"]/u,
+ 'must describe the MicroVertical server role.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /strictEffectApproach:\s*true/u,
+ 'must preserve strict Effect backend execution.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /contractVersion:\s*['"]microvertical-server-effect-v1['"]/u,
+ 'must preserve the MicroVertical server contract version.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /export\s*\{\s*default\s*,\s*default\s+as\s+runtime\s*\}\s+from\s+['"]\.\/index\.ts['"]/u,
+ 'must re-export the generated Effect BFF runtime as both default and runtime.',
+ );
+ assert(
+ !/\b(request|handler)\s*:\s*async\s*\(/u.test(backendExpose),
+ `${backendEffectExpose}: must not expose raw request handlers.`,
+ );
+ }
+
+ if (exists(sharedApi)) {
     const contract = readText(sharedApi);
     assertContains(
       sharedApi,

package/templates/workspace-scripts/generate-node-backend-federation.mjs

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const workspaceRoot = path.resolve(
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '../..'),
+);
+const configPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
+const { build } = createRequire(import.meta.url)('esbuild');
+// Keep these constants/checks in sync with
+// @modern-js/utils/universal backend-federation-contract. Generated workspace
+// scripts do not currently import @modern-js/utils directly.
+const contractVersion = 'microvertical-server-effect-v1';
+const nodeAdapterVersion = 'backend-mf-effect-v1';
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function readBuildIdentity(app) {
+  const buildArtifactPath = path.join(
+    workspaceRoot,
+    app.path,
+    'shared/ultramodern-build.json',
+  );
+  if (fs.existsSync(buildArtifactPath)) {
+    const artifact = readJson(buildArtifactPath);
+    const deliveryUnit = artifact.deliveryUnit ?? {};
+    return {
+      buildVersion: deliveryUnit.buildMarker ?? deliveryUnit.build,
+      packageName: deliveryUnit.packageName,
+      version: deliveryUnit.version,
+      unitId: deliveryUnit.unitId,
+      sourceRevision: deliveryUnit.sourceRevision,
+    };
+  }
+
+  const buildModulePath = path.join(
+    workspaceRoot,
+    app.path,
+    'shared/ultramodern-build.ts',
+  );
+  if (!fs.existsSync(buildModulePath)) {
+    return {};
+  }
+  console.warn(
+    `[backend-federation] ${path.relative(
+      workspaceRoot,
+      buildArtifactPath,
+    )} missing; falling back to legacy regex parsing of ${path.relative(
+      workspaceRoot,
+      buildModulePath,
+    )}.`,
+  );
+
+  const source = fs.readFileSync(buildModulePath, 'utf8');
+  return {
+    buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+    packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+    version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+    unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+    sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1],
+  };
+}
+
+function parseArgs(argv) {
+  const options = {
+    app: undefined,
+    target: 'dist',
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--app') {
+      options.app = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--target') {
+      options.target = argv[index + 1] ?? options.target;
+      index += 1;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      console.log(
+        'Usage: node scripts/generate-node-backend-federation.mts [--app <id>] [--target dist|dist-cloudflare]',
+      );
+      process.exit(0);
+    }
+  }
+  return options;
+}
+
+function backendApps(config, appFilter) {
+  return (config.topology?.apps ?? []).filter(app => {
+    if (app.kind !== 'vertical') {
+      return false;
+    }
+    if (!backendFederationMetadata(app)) {
+      return false;
+    }
+    return appFilter ? app.id === appFilter : true;
+  });
+}
+
+function backendFederationMetadata(app) {
+  return app.backendFederation ?? app.api?.backendFederation;
+}
+
+function backendFederationExposes(app) {
+  const backend = backendFederationMetadata(app);
+  const exposes = Array.isArray(backend.exposes)
+    ? backend.exposes.filter(expose => typeof expose === 'string')
+    : backend.exposes &&
+        typeof backend.exposes === 'object' &&
+        !Array.isArray(backend.exposes)
+      ? Object.keys(backend.exposes)
+    : [];
+
+  if (exposes.length > 0) {
+    return exposes;
+  }
+
+  if (typeof backend.expose === 'string') {
+    return [backend.expose];
+  }
+
+  throw new Error(`${app.id} backend federation expose metadata is missing`);
+}
+
+function normalizeBackendFederation(app) {
+  const backend = backendFederationMetadata(app);
+  const nodeSurface = backend.executionSurfaces?.node ?? {};
+  const exposes = backendFederationExposes(app);
+
+  return {
+    ...backend,
+    name: backend.name ?? nodeSurface.remoteName,
+    remoteType:
+      backend.remoteType ?? nodeSurface.remoteType ?? 'commonjs-module',
+    manifestUrl: backend.manifestUrl ?? nodeSurface.manifestUrl,
+    containerEntry: backend.containerEntry ?? nodeSurface.containerEntry,
+    runtimePackage: backend.runtimePackage ?? nodeSurface.runtimePackage,
+    contractVersion:
+      backend.contractVersion ??
+      backend.compatibility?.contractVersion ??
+      contractVersion,
+    nodeAdapterVersion:
+      backend.nodeAdapterVersion ?? nodeSurface.adapterVersion ?? nodeAdapterVersion,
+    expose:
+      typeof backend.expose === 'string'
+        ? backend.expose
+        : (nodeSurface.expose ?? exposes[0]),
+    exposes,
+  };
+}
+
+async function createRemoteEntrySource(app, outputDir) {
+  const backend = normalizeBackendFederation(app);
+  if (backend.remoteType !== 'commonjs-module') {
+    throw new Error(
+      `${app.id} backend federation remoteType must be commonjs-module`,
+    );
+  }
+  const exposes = backendFederationExposes(app);
+  const buildIdentity = readBuildIdentity(app);
+  const effectApiPath = path.join(workspaceRoot, app.path, 'api/effect-api.ts');
+  const source = `import * as exposedNamespace from ${JSON.stringify(
+    effectApiPath,
+  )};
+
+const exposedModule = {
+  ...exposedNamespace,
+  backendFederationContract: {
+    ...(exposedNamespace.backendFederationContract ?? {}),
+    compatibility: {
+      ...(exposedNamespace.backendFederationContract?.compatibility ?? {}),
+      build: ${JSON.stringify(buildIdentity.buildVersion)},
+      contractVersion: ${JSON.stringify(backend.contractVersion)},
+      nodeAdapterVersion: ${JSON.stringify(backend.nodeAdapterVersion)},
+      packageName: ${JSON.stringify(buildIdentity.packageName)},
+      sourceRevision: ${JSON.stringify(buildIdentity.sourceRevision)},
+      unitId: ${JSON.stringify(buildIdentity.unitId)},
+    },
+    name: ${JSON.stringify(backend.name)},
+    role: 'microvertical-server',
+    runtimeFramework: 'effect',
+    strictEffectApproach: true,
+  },
+};
+const factories = {
+${exposes
+  .map(
+    expose =>
+      `${JSON.stringify(expose)}: () => Promise.resolve(exposedModule),`,
+  )
+  .join('\n')}
+};
+
+function init() {}
+
+function get(id) {
+  const factory = factories[id];
+  if (!factory) {
+    throw new Error(\`Unknown backend federation expose \${id}\`);
+  }
+  return async () => factory();
+}
+
+module.exports = { init, get };
+`;
+  const result = await build({
+    absWorkingDir: path.dirname(effectApiPath),
+    bundle: true,
+    format: 'cjs',
+    logLevel: 'silent',
+    platform: 'node',
+    stdin: {
+      contents: source,
+      loader: 'ts',
+      resolveDir: path.dirname(effectApiPath),
+      sourcefile: path.join(outputDir, 'backendRemoteEntry.cjs'),
+    },
+    target: 'node20',
+    write: false,
+  });
+  const output = result.outputFiles[0];
+  if (!output) {
+    throw new Error(`${app.id} backend federation container emitted no output`);
+  }
+  return output.text;
+}
+
+function createManifest(app, outputDir) {
+  const backend = normalizeBackendFederation(app);
+  if (backend.remoteType !== 'commonjs-module') {
+    throw new Error(
+      `${app.id} backend federation remoteType must be commonjs-module`,
+    );
+  }
+  const buildIdentity = readBuildIdentity(app);
+  const compactDeliveryUnit =
+    app.deliveryUnit && typeof app.deliveryUnit === 'object'
+      ? app.deliveryUnit
+      : undefined;
+  const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+  const sourceRevision =
+    compactDeliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
+  const publicPath = new URL('.', backend.containerEntry).href;
+  return {
+    schemaVersion: 1,
+    name: backend.name,
+    id: backend.name,
+    version: buildIdentity.version,
+    buildVersion: buildIdentity.buildVersion,
+    type: backend.remoteType,
+    entry: {
+      file: 'backendRemoteEntry.cjs',
+      path: path
+        .relative(
+          workspaceRoot,
+          path.join(outputDir, 'backendRemoteEntry.cjs'),
+        )
+        .replaceAll(path.sep, '/'),
+      url: backend.containerEntry,
+      type: backend.remoteType,
+    },
+    metaData: {
+      name: backend.name,
+      type: backend.remoteType,
+      buildInfo: {
+        buildName: buildIdentity.packageName,
+        buildVersion: buildIdentity.buildVersion,
+      },
+      remoteEntry: {
+        name: 'backendRemoteEntry.cjs',
+        path: '',
+        type: backend.remoteType,
+      },
+      globalName: backend.name,
+      publicPath,
+      ssrRemoteEntry: {
+        name: 'backendRemoteEntry.cjs',
+        path: '',
+        type: backend.remoteType,
+      },
+      ssrPublicPath: publicPath,
+    },
+    exposes: backend.exposes.map(expose => ({
+      id: `${backend.name}:${expose}`,
+      name: expose,
+      path: '',
+      assets: {
+        js: {
+          async: [],
+          sync: ['backendRemoteEntry.cjs'],
+        },
+        css: {
+          async: [],
+          sync: [],
+        },
+      },
+    })),
+    shared: [],
+    backendFederation: {
+      role: backend.role ?? 'microvertical-server',
+      name: backend.name,
+      runtimeFramework: backend.runtimeFramework ?? 'effect',
+      strictEffectApproach: backend.strictEffectApproach ?? true,
+      contractVersion: backend.contractVersion,
+      nodeAdapterVersion: backend.nodeAdapterVersion,
+      manifestUrl: backend.manifestUrl,
+      containerEntry: backend.containerEntry,
+      expose: backend.expose,
+      runtimePackage: backend.runtimePackage,
+      ...(unitId && buildIdentity.buildVersion
+        ? {
+            deliveryUnit: {
+              schemaVersion: 1,
+              kind: 'microvertical-delivery-unit',
+              unitId,
+              packageName: buildIdentity.packageName,
+              version: buildIdentity.version,
+              buildMarker: buildIdentity.buildVersion,
+              sourceRevision,
+            },
+          }
+        : {}),
+      versionBoundary: {
+        packageName: buildIdentity.packageName,
+        version: buildIdentity.version,
+        buildVersion: buildIdentity.buildVersion,
+        ...(unitId && buildIdentity.buildVersion
+          ? {
+              deliveryUnit: {
+                unitId,
+                buildMarker: buildIdentity.buildVersion,
+              },
+            }
+          : {}),
+      },
+    },
+  };
+}
+
+const options = parseArgs(process.argv.slice(2));
+const config = readJson(configPath);
+const apps = backendApps(config, options.app);
+
+if (options.app && apps.length === 0) {
+  throw new Error(`No generated backend federation app matched ${options.app}`);
+}
+
+for (const app of apps) {
+  const outputDir = path.join(workspaceRoot, app.path, options.target);
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(outputDir, 'backendRemoteEntry.cjs'),
+    await createRemoteEntrySource(app, outputDir),
+    'utf-8',
+  );
+  fs.writeFileSync(
+    path.join(outputDir, 'backend-mf-manifest.json'),
+    `${JSON.stringify(createManifest(app, outputDir), null, 2)}\n`,
+    'utf-8',
+  );
+  console.log(
+    `[ultramodern] generated backend federation artifacts for ${app.id} in ${path.relative(
+      workspaceRoot,
+      outputDir,
+    )}`,
+  );
+}
+
+if (apps.length === 0) {
+  console.log('[ultramodern] no backend federation apps to generate');
+}

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

@@ -173,7 +173,7 @@ function createPublicSurface(app) {
     metadataExport: './src/routes/ultramodern-route-metadata',
     generator: 'scripts/generate-public-surface-assets.mts',
     outputRoot: 'dist/public',
-    cloudflareOutputRoot: '.output/public',
+    cloudflareBuildOutputRoot: 'dist-cloudflare/public',
     privateRoutePolicy: 'omit-from-generated-public-surface',
     files:
       publicRoutes.length > 0
@@ -280,7 +280,7 @@ function parseArgs(argv) {
   if (!parsed.appId && !parsed.help) {
     throw new Error('Missing required --app argument');
   }
-  if (!['dist', 'cloudflare'].includes(parsed.target)) {
+  if (!['dist', 'cloudflare-dist'].includes(parsed.target)) {
     throw new Error(`Unsupported public surface target: ${parsed.target}`);
   }
 
@@ -289,7 +289,7 @@ function parseArgs(argv) {
 
 function printHelp() {
   process.stdout.write(`Usage:
-  node scripts/generate-public-surface-assets.mts --app shell-super-app [--target dist|cloudflare] [--require-public-origin]
+  node scripts/generate-public-surface-assets.mts --app shell-super-app [--target dist|cloudflare-dist] [--require-public-origin]
 
 Set each app's production URL using the contract env key, for example:
   ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP=https://example.com
@@ -338,8 +338,8 @@ function resolveOrigin(app, requirePublicOrigin) {
 
 function ensureOutputDir(app, target) {
   const relativeDir =
-    target === 'cloudflare'
-      ? app.routes?.publicSurface?.cloudflareOutputRoot
+    target === 'cloudflare-dist'
+      ? app.routes?.publicSurface?.cloudflareBuildOutputRoot
       : app.routes?.publicSurface?.outputRoot;
   if (typeof relativeDir !== 'string') {
     throw new Error(`${app.id} public surface contract is missing outputRoot for ${target}`);