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

package/dist/esm-node/plugins/backend-federation/config.mjs

@@ -0,0 +1,129 @@
+import "node:module";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, deliveryUnitContractBlock, isUltramodernBuildArtifact, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/utils/universal";
+import { resolveUltramodernSourceRevision } from "../../ultramodern-release-identity.mjs";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const readJsonFile = async (filePath)=>JSON.parse(await promises.readFile(filePath, 'utf8'));
+const buildArtifactPathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
+const buildModulePathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
+const readBuildIdentity = async (appDirectory)=>{
+    const buildArtifactPath = buildArtifactPathFor(appDirectory);
+    if (existsSync(buildArtifactPath)) {
+        const artifact = await readJsonFile(buildArtifactPath);
+        const artifactValidation = validateUltramodernBuildArtifact(artifact, buildArtifactPath);
+        if (!artifactValidation.ok) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        if (!isUltramodernBuildArtifact(artifact)) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        const deliveryUnit = artifact.deliveryUnit;
+        return {
+            artifact,
+            appId: deliveryUnit.appId,
+            buildVersion: deliveryUnit.buildMarker,
+            packageName: deliveryUnit.packageName,
+            version: deliveryUnit.version,
+            unitId: deliveryUnit.unitId,
+            sourceRevision: deliveryUnit.sourceRevision
+        };
+    }
+    const buildModulePath = buildModulePathFor(appDirectory);
+    if (!existsSync(buildModulePath)) return {};
+    console.warn(`[backend-federation-build] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ${ULTRAMODERN_BUILD_ARTIFACT_FILE}.`);
+    const source = await promises.readFile(buildModulePath, 'utf8');
+    return {
+        appId: source.match(/\bappId:\s*['"]([^'"]+)['"]/u)?.[1],
+        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]
+    };
+};
+const toPascalCase = (value)=>value.split(/[^a-zA-Z0-9]+/u).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+const stringValue = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const createBackendName = (app, id)=>{
+    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ?? stringValue(app.serverExecution?.node?.remoteName);
+    if (configuredName) return configuredName;
+    const mfName = stringValue(app.moduleFederation?.name);
+    return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
+};
+const findWorkspaceRoot = (appDirectory)=>{
+    let current = appDirectory;
+    while(true){
+        if (existsSync(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = node_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveWorkspaceSourceRevision = async (workspaceRoot)=>resolveUltramodernSourceRevision(workspaceRoot);
+const createStampedDeliveryUnit = (input)=>{
+    if (!input.unitId || !input.buildMarker || !input.packageName || !input.version) return;
+    const record = {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: DELIVERY_UNIT_KIND,
+        appId: input.appId,
+        unitId: input.unitId,
+        packageName: input.packageName,
+        version: input.version,
+        buildMarker: input.buildMarker,
+        sourceRevision: input.sourceRevision,
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+    const validation = validateDeliveryUnitRecord(record);
+    if (!validation.ok) return;
+    return deliveryUnitContractBlock(record);
+};
+const createAppFromCompactMetadata = (workspaceRoot, appDirectory, compactApp)=>{
+    const id = stringValue(compactApp.id);
+    const appPath = stringValue(compactApp.path);
+    if (!id || 'vertical' !== compactApp.kind || !isRecord(compactApp.api)) return;
+    const directory = appPath ? normalizeRelativePath(appPath) : `verticals/${id}`;
+    if (node_path.resolve(workspaceRoot, directory) !== node_path.resolve(appDirectory)) return;
+    const port = 'number' == typeof compactApp.port ? compactApp.port : void 0;
+    if (void 0 === port) return;
+    const apiPrefix = stringValue(compactApp.api.prefix) ?? `/${id}-api`;
+    const apiStem = stringValue(compactApp.api.stem) ?? id;
+    const backendName = createBackendName(compactApp, id);
+    const manifestUrl = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.manifestUrl) ?? stringValue(compactApp.serverExecution?.node?.manifestUrl) ?? `http://localhost:${port}/${BACKEND_FEDERATION_MANIFEST_FILE}`;
+    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
+    const configuredRemoteType = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.remoteType) ?? stringValue(compactApp.serverExecution?.node?.remoteType);
+    if (void 0 !== configuredRemoteType && 'commonjs-module' !== configuredRemoteType) throw new Error(`[backend-federation-build] Node backend federation remoteType must be "commonjs-module"; received "${configuredRemoteType}" for ${id}.`);
+    if (!new URL(containerEntry).pathname.endsWith(`/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`)) throw new Error(`[backend-federation-build] Node backend federation containerEntry must end with "/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}"; received "${containerEntry}" for ${id}.`);
+    const remoteType = 'commonjs-module';
+    const packageName = stringValue(compactApp.package);
+    const uiManifestUrl = stringValue(compactApp.backendFederation?.versionBoundary?.ui?.manifestUrl) ?? stringValue(compactApp.moduleFederation?.manifestUrl);
+    const compactDeliveryUnit = isRecord(compactApp.deliveryUnit) ? {
+        unitId: stringValue(compactApp.deliveryUnit.unitId),
+        buildMarker: stringValue(compactApp.deliveryUnit.buildMarker),
+        sourceRevision: stringValue(compactApp.deliveryUnit.sourceRevision),
+        packageName: stringValue(compactApp.deliveryUnit.packageName),
+        version: stringValue(compactApp.deliveryUnit.version)
+    } : void 0;
+    return {
+        id,
+        directory,
+        packageName,
+        port,
+        apiPrefix,
+        apiStem,
+        backendName,
+        manifestUrl,
+        containerEntry,
+        remoteType,
+        uiManifestUrl,
+        compactDeliveryUnit
+    };
+};
+const findBackendFederationApp = async (workspaceRoot, appDirectory)=>{
+    const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+    const compactConfig = await readJsonFile(compactConfigPath);
+    const apps = Array.isArray(compactConfig.topology?.apps) ? compactConfig.topology.apps : [];
+    for (const app of apps){
+        const resolved = createAppFromCompactMetadata(workspaceRoot, appDirectory, app);
+        if (resolved) return resolved;
+    }
+};
+export { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createAppFromCompactMetadata, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };

package/dist/esm-node/plugins/backend-federation/emit.mjs

@@ -0,0 +1,98 @@
+import "node:module";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactIdentity } from "@modern-js/utils/universal";
+import { resolveUltramodernReleaseIdentity } from "../../ultramodern-release-identity.mjs";
+import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
+import { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
+const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
+    const workspaceRoot = findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    const effectApiPath = node_path.join(appDirectory, 'api/effect-api.ts');
+    const backendFederationConfigPath = node_path.join(appDirectory, 'backend-federation.config.ts');
+    if (!existsSync(effectApiPath) || !existsSync(backendFederationConfigPath)) return;
+    const app = await findBackendFederationApp(workspaceRoot, appDirectory);
+    if (!app) return;
+    const buildIdentity = await readBuildIdentity(appDirectory);
+    const compactDeliveryUnit = app.compactDeliveryUnit;
+    const hasCompactDeliveryUnit = void 0 !== compactDeliveryUnit && (void 0 !== compactDeliveryUnit.unitId || void 0 !== compactDeliveryUnit.buildMarker || void 0 !== compactDeliveryUnit.packageName || void 0 !== compactDeliveryUnit.version);
+    const hasBuildIdentity = void 0 !== buildIdentity.unitId || void 0 !== buildIdentity.buildVersion || void 0 !== buildIdentity.packageName || void 0 !== buildIdentity.version;
+    if (hasBuildIdentity) {
+        const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+        const buildIdentityPath = existsSync(buildArtifactPathFor(appDirectory)) ? buildArtifactPathFor(appDirectory) : buildModulePathFor(appDirectory);
+        const mismatches = [];
+        const compare = (label, a, b, leftLabel = 'deliveryUnit')=>{
+            if (void 0 !== a && void 0 !== b && a !== b) mismatches.push(`${label}: ${leftLabel}=${a} vs ultramodern-build=${b}`);
+        };
+        compare('appId', app.id, buildIdentity.appId, 'topology');
+        if (hasCompactDeliveryUnit) {
+            compare('unitId', compactDeliveryUnit?.unitId, buildIdentity.unitId);
+            compare('buildMarker/build', compactDeliveryUnit?.buildMarker, buildIdentity.buildVersion);
+            compare('packageName', compactDeliveryUnit?.packageName, buildIdentity.packageName);
+            compare('version', compactDeliveryUnit?.version, buildIdentity.version);
+        }
+        if (mismatches.length > 0) throw new Error(`[backend-federation-build] Delivery-unit identity drift between ${compactConfigPath} (topology) and ${buildIdentityPath}: ${mismatches.join('; ')}`);
+    }
+    const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+    const generationBuildMarker = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
+    const buildVersion = generationBuildMarker && unitId ? resolveUltramodernReleaseIdentity({
+        generationBuildMarker,
+        unitId,
+        workspaceRoot
+    }).buildMarker : void 0;
+    const packageName = compactDeliveryUnit?.packageName ?? buildIdentity.packageName ?? app.packageName;
+    const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+    const deliveryUnit = createStampedDeliveryUnit({
+        appId: app.id,
+        unitId,
+        buildMarker: buildVersion,
+        packageName,
+        version,
+        sourceRevision
+    });
+    const stampedBuildArtifact = buildIdentity.artifact ? stampUltramodernBuildArtifactIdentity(buildIdentity.artifact, {
+        buildMarker: buildVersion ?? buildIdentity.artifact.deliveryUnit.buildMarker,
+        sourceRevision
+    }) : void 0;
+    const resolvedApp = {
+        ...app,
+        packageName,
+        version,
+        buildVersion,
+        unitId,
+        sourceRevision,
+        deliveryUnit
+    };
+    const manifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
+    const entryPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
+    const deliveryUnitArtifactPath = stampedBuildArtifact ? node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE) : void 0;
+    await promises.mkdir(distDirectory, {
+        recursive: true
+    });
+    await promises.writeFile(entryPath, await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath));
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp), null, 2)}\n`);
+    if (stampedBuildArtifact && deliveryUnitArtifactPath) await promises.writeFile(deliveryUnitArtifactPath, `${JSON.stringify(stampedBuildArtifact, null, 2)}\n`);
+    return {
+        appId: resolvedApp.id,
+        manifestPath,
+        containerPath: entryPath,
+        ...deliveryUnitArtifactPath ? {
+            deliveryUnitArtifactPath
+        } : {},
+        remoteName: resolvedApp.backendName,
+        remoteType: resolvedApp.remoteType
+    };
+};
+const emit = ()=>({
+        name: '@modern-js/backend-federation-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory } = api.getAppContext();
+                await emitBackendFederationArtifacts(appDirectory, distDirectory);
+            });
+        }
+    });
+export default emit;
+export { emitBackendFederationArtifacts };

package/dist/esm-node/plugins/backendFederationBuild.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { default, emitBackendFederationArtifacts } from "./backend-federation/emit.mjs";

package/dist/esm-node/plugins/deploy/index.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { provider } from "std-env";
-import { createCloudflarePreset } from "./platforms/cloudflare.mjs";
+import { createCloudflarePreset } from "./platforms/cloudflare/index.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";

package/dist/esm-node/plugins/deploy/platforms/cloudflare/artifacts.mjs

@@ -0,0 +1,65 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_SPEC_OUTPUT } from "./constants.mjs";
+import { normalizeRelativePath } from "./utils.mjs";
+const normalizeCloudflareArtifact = (artifact, index)=>{
+    const from = normalizeRelativePath(artifact.from, `deploy.worker.artifacts[${index}].from`, 'app root');
+    const to = normalizeRelativePath(artifact.to, `deploy.worker.artifacts[${index}].to`, 'Cloudflare output');
+    const [topLevelDestination] = to.split('/');
+    const reservedDestination = RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ? to : topLevelDestination;
+    if (RESERVED_ARTIFACT_DESTINATION_FILES.has(to) || RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)) throw new Error(`deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(reservedDestination)}.`);
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
+const normalizeCloudflarePublicAsset = (asset, index)=>{
+    const from = normalizeRelativePath(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
+    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
+        allowRoot: true
+    });
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
+const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
+    for (const artifact of artifacts){
+        const sourcePath = node_path.join(appDirectory, artifact.from);
+        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`);
+        await fs.copy(sourcePath, node_path.join(outputDirectory, artifact.to));
+    }
+};
+const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
+    for (const asset of publicAssets){
+        const sourcePath = node_path.join(appDirectory, asset.from);
+        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
+        await fs.copy(sourcePath, node_path.join(publicDirectory, asset.to));
+    }
+};
+const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
+    for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
+        if (!database.migrationsDir) continue;
+        const migrationsDir = normalizeRelativePath(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
+        const sourcePath = node_path.join(appDirectory, migrationsDir);
+        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.d1Databases[${index}].migrationsDir does not exist: ${migrationsDir}`);
+        await fs.copy(sourcePath, node_path.join(outputDirectory, migrationsDir));
+    }
+};
+const readRouteSpec = async (outputDirectory)=>{
+    const routeSpecPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    if (!await fs.pathExists(routeSpecPath)) return {
+        routes: []
+    };
+    const routeSpec = await fs.readJSON(routeSpecPath);
+    return {
+        ...routeSpec,
+        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
+    };
+};
+export { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets, readRouteSpec };

package/dist/esm-node/plugins/deploy/platforms/cloudflare/constants.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WRANGLER_CONFIG_FILE } from "../cloudflare-output-contract.mjs";
+const WORKER_ENTRY = CLOUDFLARE_WORKER_ENTRY;
+const WORKER_MANIFEST = CLOUDFLARE_WORKER_MANIFEST;
+const WRANGLER_CONFIG_FILE = CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = CLOUDFLARE_ASSETS_BINDING;
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const SERVER_OUTPUT_DIRECTORY = 'server';
+const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
+    'api',
+    'shared'
+];
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = '__modern_create_effect_bff_dispatcher';
+const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
+const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+const REQUIRED_COMPATIBILITY_FLAGS = CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
+    WRANGLER_CONFIG_FILE,
+    OUTPUT_PACKAGE_FILE
+]);
+const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
+    PUBLIC_ASSETS_DIRECTORY,
+    SERVER_OUTPUT_DIRECTORY,
+    WORKER_BUNDLE_DIRECTORY
+]);
+export { ASSETS_BINDING, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, OUTPUT_PACKAGE_FILE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, SERVER_OUTPUT_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY, WORKER_MANIFEST, WRANGLER_CONFIG_FILE };

package/dist/esm-node/plugins/deploy/platforms/cloudflare/delivery-unit.mjs

@@ -0,0 +1,89 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/utils/universal";
+import { resolveUltramodernReleaseIdentity } from "../../../../ultramodern-release-identity.mjs";
+import { isRecord } from "./utils.mjs";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = node_path.resolve(appDirectory);
+    for(;;){
+        if (await fs.pathExists(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = node_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const stampReleaseIdentity = (identity, workspaceRoot)=>{
+    if ('workspace' !== identity.sourceRevision) return identity;
+    return {
+        ...identity,
+        ...resolveUltramodernReleaseIdentity({
+            generationBuildMarker: identity.buildMarker,
+            unitId: identity.unitId,
+            workspaceRoot
+        })
+    };
+};
+const resolveTopologyDeliveryUnit = async (appDirectory)=>{
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    let compactConfig;
+    try {
+        compactConfig = await fs.readJSON(node_path.join(workspaceRoot, COMPACT_CONFIG_PATH));
+    } catch  {
+        return;
+    }
+    if (!isRecord(compactConfig)) return;
+    const topology = isRecord(compactConfig.topology) ? compactConfig.topology : void 0;
+    const apps = Array.isArray(topology?.apps) ? topology.apps : void 0;
+    const resolvedAppDirectory = node_path.resolve(appDirectory);
+    if (apps) {
+        for (const app of apps){
+            if (!isRecord(app)) continue;
+            const appPath = nonEmptyString(app.path);
+            if (appPath && node_path.resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) {
+                const identity = toDeliveryUnitIdentity(app.deliveryUnit);
+                return identity ? stampReleaseIdentity(identity, workspaceRoot) : void 0;
+            }
+        }
+        return;
+    }
+    const identity = toDeliveryUnitIdentity(compactConfig.deliveryUnit);
+    return identity ? stampReleaseIdentity(identity, workspaceRoot) : void 0;
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildArtifactPath = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
+    const buildModulePath = node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
+    let identity;
+    if (await fs.pathExists(buildArtifactPath)) {
+        const artifact = await fs.readJSON(buildArtifactPath);
+        if (!isUltramodernBuildArtifact(artifact)) return;
+        identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
+    } else if (await fs.pathExists(buildModulePath)) {
+        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
+        const source = await fs.readFile(buildModulePath, 'utf8');
+        identity = toDeliveryUnitIdentity({
+            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+        });
+    }
+    if (!identity) return;
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (workspaceRoot) identity = stampReleaseIdentity(identity, workspaceRoot);
+    return {
+        ...identity,
+        surfaces: {
+            ui: {
+                ...identity,
+                surface: 'ui'
+            },
+            api: {
+                ...identity,
+                surface: 'api'
+            }
+        }
+    };
+};
+export { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp };

package/dist/esm-node/plugins/deploy/platforms/cloudflare/i18n-worker.mjs

@@ -0,0 +1,98 @@
+import "node:module";
+import { isRecord } from "./utils.mjs";
+const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupHeader: 'accept-language'
+};
+const SERVER_SIDE_I18N_DETECTORS = new Set([
+    'querystring',
+    'cookie',
+    'header'
+]);
+const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
+const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
+const removeLocaleDetectionByEntry = (config)=>{
+    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
+    return rest;
+};
+const getEntryLocaleDetection = (entryName, localeDetection)=>{
+    const byEntry = isRecord(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
+    const entryConfig = byEntry?.[entryName];
+    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
+    return isRecord(entryConfig) ? {
+        ...globalConfig,
+        ...entryConfig
+    } : globalConfig;
+};
+const normalizeI18nDetection = (detection)=>{
+    const configured = isRecord(detection) ? detection : {};
+    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
+    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
+    return {
+        order: order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ],
+        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
+        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
+        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
+    };
+};
+const normalizeLocalisedUrls = (localisedUrls)=>{
+    if (!isRecord(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
+    const normalized = {};
+    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
+        if (!isRecord(languageMap)) continue;
+        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
+        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+};
+const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
+    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
+    const languages = toStringArray(entryConfig.languages);
+    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
+    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
+    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
+    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
+    return {
+        i18nextDetector: false !== entryConfig.i18nextDetector,
+        languages,
+        fallbackLanguage,
+        detection: normalizeI18nDetection(entryConfig.detection),
+        ignoreRedirectRoutes,
+        staticRoutePrefixes,
+        ...localisedUrls ? {
+            localisedUrls
+        } : {}
+    };
+};
+const createI18nWorkerManifest = (routeSpec, appContext)=>{
+    const i18nServerPlugin = getI18nServerPlugin(appContext);
+    const localeDetection = i18nServerPlugin?.options?.localeDetection;
+    if (!isRecord(localeDetection)) return;
+    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
+    const entries = {};
+    for (const route of routeSpec.routes){
+        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
+        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
+        if (entry) entries[route.entryName] = entry;
+    }
+    return Object.keys(entries).length > 0 ? {
+        entries
+    } : void 0;
+};
+export { createI18nWorkerManifest };

package/dist/esm-node/plugins/deploy/platforms/cloudflare/index.mjs

@@ -0,0 +1,103 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { MICROVERTICAL_RELEASE_ENVELOPE_PATH, emitCloudflareStagedReleaseEnvelope, emitFrameworkMicroVerticalReleaseEnvelope, stageCloudflareReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyCloudflareReleaseEnvelopeStaging } from "../../../../ultramodern-release-envelope/framework-output.mjs";
+import { readTemplate } from "../../utils/index.mjs";
+import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
+import { assertCloudflareOutput } from "../cloudflare-output-verifier/index.mjs";
+import { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets } from "./artifacts.mjs";
+import { ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, WORKER_BUNDLE_DIRECTORY } from "./constants.mjs";
+import { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp } from "./delivery-unit.mjs";
+import { createWorkerManifest, createWorkerModuleLoaders, getPublicAssetExcludes, shouldCopyToPublicAssets, shouldCopyToWorkerBundle } from "./worker-manifest.mjs";
+import { createWranglerConfig } from "./wrangler-config.mjs";
+const CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS = [
+    'cloudflare-entry.001-bootstrap-security.mjs',
+    'cloudflare-entry.002-assets-routes.mjs',
+    'cloudflare-entry.003-i18n-locales.mjs',
+    'cloudflare-entry.004-rendering-css.mjs',
+    'cloudflare-entry.005-worker-dispatch.mjs',
+    'cloudflare-entry.006-fetch-handler.mjs'
+];
+const readCloudflareEntryTemplate = async ()=>(await Promise.all(CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS.map((fragment)=>readTemplate(fragment)))).join('');
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { apiOnly, appDirectory, distDirectory } = appContext;
+    const outputDirectory = node_path.join(appDirectory, '.output');
+    const outputPlan = createCloudflareOutputPlan(outputDirectory);
+    const publicDirectory = outputPlan.paths.publicAssets;
+    const workerEntryPath = outputPlan.paths.workerEntry;
+    const workerManifestPath = outputPlan.paths.workerManifest;
+    const routeSpecOutputPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = outputPlan.paths.wranglerConfig;
+    const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
+    const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
+    let hasReleaseEnvelope = false;
+    return {
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            if (await fs.pathExists(node_path.join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await emitFrameworkMicroVerticalReleaseEnvelope({
+                apiOnly,
+                distDirectory,
+                target: 'cloudflare'
+            });
+            await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
+            await fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>{
+                    const relativePath = node_path.relative(distDirectory, src).replace(/\\/gu, '/');
+                    return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes);
+                }
+            });
+            const generatedPublicDirectory = node_path.join(distDirectory, 'public');
+            if (await fs.pathExists(generatedPublicDirectory)) await fs.copy(generatedPublicDirectory, publicDirectory);
+            await fs.ensureDir(node_path.dirname(workerEntryPath));
+            await fs.ensureDir(node_path.dirname(workerManifestPath));
+            const routeSpecSourcePath = node_path.join(distDirectory, ROUTE_SPEC_FILE);
+            if (await fs.pathExists(routeSpecSourcePath)) await fs.copy(routeSpecSourcePath, routeSpecOutputPath);
+            const workerBundleSourceDirectory = node_path.join(distDirectory, WORKER_BUNDLE_DIRECTORY);
+            const workerBundleOutputDirectory = outputPlan.paths.workerBundle;
+            if (await fs.pathExists(workerBundleSourceDirectory)) {
+                await fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
+                    filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+                });
+                await fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
+            }
+            await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
+            await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
+            await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
+            await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
+                spaces: 2
+            });
+            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory);
+            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
+                spaces: 2
+            });
+            await fs.writeJSON(outputPlan.paths.outputPackage, outputPlan.packages.output);
+            hasReleaseEnvelope = Boolean(await stageCloudflareReleaseEnvelope({
+                distDirectory,
+                outputDirectory
+            }));
+        },
+        async genEntry () {
+            const template = await readCloudflareEntryTemplate();
+            const manifest = await fs.readJSON(workerManifestPath);
+            await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+            const topologyDeliveryUnit = await resolveTopologyDeliveryUnit(appDirectory);
+            await assertCloudflareOutput({
+                outputDirectory,
+                importWorker: false,
+                ...topologyDeliveryUnit ? {
+                    deliveryUnit: topologyDeliveryUnit
+                } : {}
+            });
+            if (hasReleaseEnvelope) {
+                await emitCloudflareStagedReleaseEnvelope({
+                    distDirectory,
+                    outputDirectory
+                });
+                await verifyCloudflareReleaseEnvelopeStaging(outputDirectory);
+            } else if (await fs.pathExists(node_path.join(outputDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) throw new Error('[ultramodern-release-envelope] Cloudflare staging contains an envelope not selected from this MicroVertical build.');
+        }
+    };
+};
+export { createCloudflarePreset };