@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/templates/workspace/verticals/shared/api.checkout-cart-endpoints.ts.handlebars

@@ -0,0 +1,23 @@
+
+    .add(
+      HttpApiEndpoint.get('getCart', '/checkout/cart', {
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('addCartItem', '/checkout/cart/items', {
+        payload: checkoutAddCartItemPayloadSchema,
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('removeCartItem', '/checkout/cart/remove', {
+        payload: checkoutRemoveCartItemPayloadSchema,
+        success: checkoutCartSchema,
+      }),
+    )
+    .add(
+      HttpApiEndpoint.post('clearCart', '/checkout/cart/clear', {
+        success: checkoutCartSchema,
+      }),
+    )

package/templates/workspace/verticals/shared/api.checkout-cart-operation-contexts.ts.handlebars

@@ -0,0 +1,25 @@
+
+  addCartItem: {
+    method: 'POST',
+    operationId: '{{value0}}:{{value1}}:addCartItem',
+    routePath: '/checkout/cart/items',
+    source: 'generated-client',
+  },
+  clearCart: {
+    method: 'POST',
+    operationId: '{{value2}}:{{value3}}:clearCart',
+    routePath: '/checkout/cart/clear',
+    source: 'generated-client',
+  },
+  getCart: {
+    method: 'GET',
+    operationId: '{{value4}}:{{value5}}:getCart',
+    routePath: '/checkout/cart',
+    source: 'generated-client',
+  },
+  removeCartItem: {
+    method: 'POST',
+    operationId: '{{value6}}:{{value7}}:removeCartItem',
+    routePath: '/checkout/cart/remove',
+    source: 'generated-client',
+  },

package/templates/workspace/verticals/shared/api.checkout-cart-schemas.ts.handlebars

@@ -0,0 +1,48 @@
+
+export interface CheckoutCartLine {
+  readonly sku: string;
+  readonly name: string;
+  readonly quantity: number;
+  readonly unitPriceCents: number;
+}
+
+export interface CheckoutCart {
+  readonly lines: readonly CheckoutCartLine[];
+  readonly subtotalCents: number;
+  readonly totalQuantity: number;
+}
+
+export interface CheckoutAddCartItemPayload {
+  readonly sku: string;
+  readonly name?: string;
+  readonly quantity: number;
+  readonly unitPriceCents?: number;
+}
+
+export interface CheckoutRemoveCartItemPayload {
+  readonly sku: string;
+}
+
+export const checkoutCartLineSchema: Schema.Codec<CheckoutCartLine> = Schema.Struct({
+  sku: Schema.String,
+  name: Schema.String,
+  quantity: Schema.Finite,
+  unitPriceCents: Schema.Finite,
+});
+
+export const checkoutCartSchema: Schema.Codec<CheckoutCart> = Schema.Struct({
+  lines: Schema.Array(checkoutCartLineSchema),
+  subtotalCents: Schema.Finite,
+  totalQuantity: Schema.Finite,
+});
+
+export const checkoutAddCartItemPayloadSchema: Schema.Codec<CheckoutAddCartItemPayload> = Schema.Struct({
+  sku: Schema.String,
+  name: Schema.optional(Schema.String),
+  quantity: Schema.Finite,
+  unitPriceCents: Schema.optional(Schema.Finite),
+});
+
+export const checkoutRemoveCartItemPayloadSchema: Schema.Codec<CheckoutRemoveCartItemPayload> = Schema.Struct({
+  sku: Schema.String,
+});

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,
+ /runtime\s*=\s*apiRuntime/u,
+ 'must export the generated Effect BFF 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,299 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+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');
+// 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 ?? '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,
+  };
+}
+
+function createRemoteEntrySource(app) {
+  const exposes = backendFederationExposes(app);
+  return `const factories = {
+${exposes
+  .map(
+    expose => `${JSON.stringify(expose)}: async () =>
+  import(new URL('../api/backend-federation.ts', import.meta.url).href),
+`,
+  )
+  .join('')}
+};
+
+export async function init() {}
+
+export function get(id) {
+  const factory = factories[id];
+  if (!factory) {
+    throw new Error(\`Unknown backend federation expose \${id}\`);
+  }
+  return factory;
+}
+
+export default { init, get };
+`;
+}
+
+function createManifest(app) {
+  const backend = normalizeBackendFederation(app);
+  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;
+  return {
+    schemaVersion: 1,
+    name: backend.name,
+    id: backend.name,
+    version: buildIdentity.version,
+    buildVersion: buildIdentity.buildVersion,
+    type: backend.remoteType,
+    entry: {
+      url: backend.containerEntry,
+      type: backend.remoteType,
+    },
+    metaData: {
+      name: backend.name,
+      type: backend.remoteType,
+      buildInfo: {
+        buildName: buildIdentity.packageName,
+        buildVersion: buildIdentity.buildVersion,
+      },
+      remoteEntry: {
+        name: 'backendRemoteEntry.mjs',
+        path: '',
+        type: backend.remoteType,
+      },
+        exposes: backend.exposes.map(expose => ({
+          id: expose,
+          name: expose,
+        path: expose,
+      })),
+    },
+    exposes: backend.exposes.map(expose => ({
+      id: expose,
+      name: expose,
+      path: expose,
+    })),
+    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.mjs'),
+    createRemoteEntrySource(app),
+    'utf-8',
+  );
+  fs.writeFileSync(
+    path.join(outputDir, 'backend-mf-manifest.json'),
+    `${JSON.stringify(createManifest(app), 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');
+}