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

package/dist/esm/ultramodern-workspace/module-federation/config.js

@@ -0,0 +1,289 @@
+import { createDispatchWorkerNameEnv, createWorkerBindingEnv, createWorkerBindingName } from "../backend-federation.js";
+import { createDeliveryUnitRecord } from "../delivery-unit.js";
+import { appEmitsBrowserUi, appHasApi, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, distributedSsrExposes, distributedSsrFragmentRoute, resolveApiPrefix, resolveApiProtocol, resolveRemoteRefs, shellApp } from "../descriptors.js";
+import { renderFileTemplate } from "../fs-io.js";
+import { createRspackChunkLoadingGlobal, createRspackUniqueName } from "../naming.js";
+import { createCloudflareSecurityContract, formatTsJsonValue } from "../policy.js";
+import { sortJsonValue } from "../types.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE } from "../versions.js";
+import { createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig } from "./remote-refs.js";
+import { createSharedModuleFederationConfig, formatTsObjectLiteral } from "./shared-config.js";
+function createAppModernConfig(scope, app, remotes = [], enableTailwind = true, configuredDevPorts) {
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    const emitsUi = appEmitsBrowserUi(app);
+    const bffImport = appHasApi(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
+    const uiImports = emitsUi ? `import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+import { withZephyr as withZephyrRspack } from 'zephyr-rspack-plugin';
+import { ultramodernLocalisedUrls } from './src/routes/ultramodern-route-metadata';
+` : '';
+    const zephyrPluginSource = emitsUi ? `const zephyrRspackPlugin = () => ({
+  name: 'ultramodern-zephyr-rspack-plugin',
+  pre: ['@modern-js/plugin-module-federation-config'],
+  setup(api: {
+    modifyRspackConfig: (
+      handler: ReturnType<typeof withZephyrRspack>,
+    ) => void;
+  }) {
+    // Zephyr uploads federated build artifacts to Zephyr Cloud (the fast
+    // rollback path). Uploading REQUIRES a Zephyr Cloud account and, in CI, a
+    // deploy-scoped ZE_CI_TOKEN; without it Zephyr fatally fails to load its
+    // application configuration. Zephyr therefore engages ONLY for such an
+    // authoritative deploy — a plain build never contacts Zephyr Cloud, needs
+    // no account, and is never blocked. This is the framework's "works with or
+    // without Zephyr" contract. The plugin stays registered unconditionally
+    // (this gate keys on Zephyr's native deploy token, not any UltraModern
+    // opt-out). When deploying, ZE_FAIL_BUILD=true makes an upload failure a
+    // hard build failure.
+    const zephyrCiDeploy =
+      (getBuildConfigEnvironment('ZE_CI_TOKEN') ?? '').length > 0;
+    if (!zephyrCiDeploy) {
+      return;
+    }
+    api.modifyRspackConfig(
+      withBuildConfigEnvironment('ZE_FAIL_BUILD', 'true', withZephyrRspack()),
+    );
+  },
+});
+
+` : '';
+    const localisedUrlsEntry = emitsUi ? '            localisedUrls: ultramodernLocalisedUrls as Record<string, Record<string, string>>,\n' : '';
+    const uiPluginEntries = emitsUi ? '        moduleFederationPlugin(),\n        zephyrRspackPlugin(),\n' : '';
+    const tailwindImport = enableTailwind ? "import { pluginTailwindcss } from '@rsbuild/plugin-tailwindcss';\n" : '';
+    const bffConfig = appHasApi(app) ? `      bff: {
+        effect: {
+          entry: './api/index',
+${'rest' === resolveApiProtocol(app) ? "          openapi: {\n            path: '/openapi.json',\n          },\n" : ''}
+          strictEffectApproach: true,
+        },
+        prefix: '${resolveApiPrefix(app)}',
+        runtimeFramework: 'effect',
+      },
+` : '';
+    const tailwindBuilderPluginsConfig = enableTailwind ? '  builderPlugins: [pluginTailwindcss()],\n' : '';
+    const bffPluginEntry = appHasApi(app) ? '        bffPlugin(),\n' : '';
+    const serviceBindings = resolveRemoteRefs(app, remotes).filter((remote)=>appHasApi(remote) || distributedSsrExposes(remote).length > 0);
+    const serviceBindingsConfig = serviceBindings.length > 0 ? `          services: [
+${serviceBindings.map((service)=>`            {
+              binding:
+                envValue('${createWorkerBindingEnv(service)}') ??
+                '${createWorkerBindingName(service)}',
+${distributedSsrExposes(service).length > 0 ? `              fragments: [
+${distributedSsrExposes(service).map((expose)=>`                {
+                  boundaryId: '${service.mfName}',
+                  expose: '${expose}',
+                  path: '${distributedSsrFragmentRoute(expose)}',
+                  remote: '${service.id}',
+                },`).join('\n')}
+              ],
+` : ''}${appHasApi(service) ? `              prefix: '${resolveApiPrefix(service)}',\n` : ''}              service:
+                envValue('${createDispatchWorkerNameEnv(service)}') ??
+                '${createCloudflareWorkerName(scope, service)}',
+            },`).join('\n')}
+          ],
+` : '';
+    const defaultAssetPrefixSource = 'shell' === app.kind ? "const defaultAssetPrefix = '/';" : `const remoteAssetOrigin =
+  configuredCloudflareUrl ||
+  inferredCloudflareUrl ||
+  (cloudflareDeployEnabled ? '' : \`http://localhost:\${port}\`);
+// When deploying to Cloudflare without a configured public URL, publish an
+// 'auto' publicPath so the remote resolves its chunks from the origin its
+// remoteEntry.js was loaded from (the vertical's Worker), not the host shell's
+// origin — otherwise cross-origin chunk loading 404s and MF reports an empty
+// moduleId. A configured/inferred URL still wins as an absolute prefix.
+const defaultRemoteAssetPrefix = remoteAssetOrigin
+  ? \`\${remoteAssetOrigin.replace(/\\/+$/u, '')}/\`
+  : 'auto';
+const defaultAssetPrefix = defaultRemoteAssetPrefix;`;
+    const devAssetPrefixSource = 'shell' === app.kind ? `        // Keep shell dev assets origin-relative so the shell works through
+        // tunnels and local previews without rewriting its own chunks.
+        assetPrefix: '/',` : `        // Remote dev manifests must publish an absolute publicPath so host
+        // shells load remoteEntry.js and exposed chunks from this dev server.
+        assetPrefix,`;
+    const developmentPorts = [
+        ...new Set((configuredDevPorts ?? [
+            shellApp.port,
+            app.port,
+            ...remotes.map((remote)=>remote.port)
+        ]).filter((port)=>'number' == typeof port && Number.isFinite(port)))
+    ].toSorted((left, right)=>left - right);
+    const legacyCorsSource = `const moduleFederationDevServerOrigin =
+  envValue('ULTRAMODERN_MF_DEV_ORIGIN') || 'http://localhost:${shellApp.port}';`;
+    const configuredCorsSource = `const moduleFederationDevServerAllowedOrigins = [
+${developmentPorts.map((port)=>`  'http://localhost:${port}',`).join('\n')}
+];`;
+    const configuredCorsDevServer = `        // MF assets are non-credentialed and only permit configured local app origins.
+        server: {
+          cors: {
+            credentials: false,
+            origin: moduleFederationDevServerAllowedOrigins,
+          },
+        },`;
+    const useConfiguredCorsAllowlist = void 0 !== configuredDevPorts;
+    const configuredCorsHeader = useConfiguredCorsAllowlist ? 1 === developmentPorts.length ? "'Access-Control-Allow-Origin': moduleFederationDevServerAllowedOrigins[0]," : '' : "'Access-Control-Allow-Origin': moduleFederationDevServerOrigin,";
+    return renderFileTemplate('workspace/apps/modern.config.ts', {
+        value0: `${bffImport}${tailwindImport}`,
+        value1: app.id,
+        value2: createCloudflareWorkerName(scope, app),
+        value3: app.portEnv,
+        value4: String(app.port),
+        value5: createCloudflarePublicUrlEnv(app),
+        value6: String(shellApp.port),
+        value7: defaultAssetPrefixSource,
+        value8: createCloudflarePublicUrlEnv(app),
+        value9: bffConfig,
+        value10: CLOUDFLARE_COMPATIBILITY_DATE,
+        value11: formatTsJsonValue(sortJsonValue(createCloudflareSecurityContract()), 16),
+        value12: serviceBindingsConfig,
+        value13: devAssetPrefixSource,
+        value14: resolveApiPrefix(app),
+        value15: bffPluginEntry,
+        value16: createRspackUniqueName(app),
+        value17: createRspackChunkLoadingGlobal(app),
+        value18: tailwindBuilderPluginsConfig,
+        value19: useConfiguredCorsAllowlist ? configuredCorsSource : legacyCorsSource,
+        value20: useConfiguredCorsAllowlist ? configuredCorsDevServer : '',
+        value21: configuredCorsHeader,
+        value22: uiImports,
+        value23: zephyrPluginSource,
+        value24: localisedUrlsEntry,
+        value25: uiPluginEntries,
+        value26: deliveryUnit.unitId,
+        value27: deliveryUnit.buildMarker,
+        value28: deliveryUnit.version
+    });
+}
+function createModuleFederationDtsConfig(hasExposes) {
+    return hasExposes ? `  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: tsgoCompilerInstance,
+    },
+    tsConfigPath: './tsconfig.mf-types.json',
+  },` : `  dts: {
+    consumeTypes: true,
+    generateTypes: false,
+    tsConfigPath: './tsconfig.mf-types.json',
+  },`;
+}
+function createShellModuleFederationConfig(scope, shell, remotes = []) {
+    const shellHost = {
+        ...shell,
+        verticalRefs: shell.verticalRefs ?? remotes.map((remote)=>remote.id)
+    };
+    return `// ultramodern-mf: host-only
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+${createModuleFederationRemoteUrlHelpers(shellHost, remotes)}
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+const moduleFederationConfig: Parameters<
+  typeof createModuleFederationConfig
+>[0] = createModuleFederationConfig({
+${createModuleFederationDtsConfig(false)}
+  filename: 'remoteEntry.js',
+  name: '${shell.mfName}',
+${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedModuleFederationConfig()},
+});
+
+export default moduleFederationConfig;
+`;
+}
+function createBackendModuleFederationConfig(app) {
+    return `import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const bffVersion = (
+  require('@modern-js/plugin-bff/package.json') as { version: string }
+).version;
+const effectVersion = (
+  require('effect/package.json') as { version: string }
+).version;
+
+const moduleFederationConfig: Parameters<
+  typeof createModuleFederationConfig
+>[0] = createModuleFederationConfig({
+  dts: false,
+  exposes: {
+    './effect-api': './api/effect-api.ts',
+  },
+  filename: 'backendRemoteEntry.cjs',
+  library: {
+    type: 'commonjs-module',
+  },
+  name: '${createBackendFederationName(app)}',
+  shared: {
+    '@modern-js/plugin-bff': {
+      requiredVersion: bffVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@module-federation/runtime': {
+      requiredVersion: dependencies['@module-federation/runtime'],
+      singleton: true,
+      treeShaking: false,
+    },
+    effect: {
+      requiredVersion: effectVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+  },
+});
+
+export default moduleFederationConfig;
+`;
+}
+function createRemoteModuleFederationConfig(scope, app, remotes = []) {
+    const exposes = formatTsObjectLiteral(app.exposes ?? {});
+    const hasExposes = Object.keys(app.exposes ?? {}).length > 0;
+    const hasRemoteRefs = resolveRemoteRefs(app, remotes).length > 0;
+    const hostOnlyMarker = hasExposes ? '' : '\n// ultramodern-mf: no-exposes';
+    const appToolsConfigImports = [
+        ...hasRemoteRefs ? [
+            'getBuildConfigEnvironment'
+        ] : [],
+        ...hasExposes ? [
+            'resolveEffectTsgoCompiler'
+        ] : []
+    ];
+    const appToolsConfigImport = appToolsConfigImports.length > 0 ? `import { ${appToolsConfigImports.join(', ')} } from '@modern-js/app-tools/config';\n` : '';
+    const tsgoCompilerInstance = hasExposes ? `
+const tsgoCompilerInstance =
+  resolveEffectTsgoCompiler({ from: import.meta.url });
+` : '';
+    return `${hostOnlyMarker}
+${appToolsConfigImport}import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+${createModuleFederationRemoteUrlHelpers(app, remotes, false)}
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+${tsgoCompilerInstance}
+const moduleFederationConfig: Parameters<
+  typeof createModuleFederationConfig
+>[0] = createModuleFederationConfig({
+${createModuleFederationDtsConfig(hasExposes)}
+  exposes: ${exposes},
+  filename: 'remoteEntry.js',
+  name: '${app.mfName}',
+${createModuleFederationRemotesConfig(scope, app, remotes)}${createSharedModuleFederationConfig()},
+});
+
+export default moduleFederationConfig;
+`;
+}
+export { createAppModernConfig, createBackendModuleFederationConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig };

package/dist/esm/ultramodern-workspace/module-federation/index.js

@@ -0,0 +1,4 @@
+export { createAppModernConfig, createBackendModuleFederationConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig } from "./config.js";
+export { createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "./reexport-module.js";
+export { createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig } from "./remote-refs.js";
+export { createSharedModuleFederationConfig, formatTsObjectLiteral } from "./shared-config.js";

package/dist/esm/ultramodern-workspace/module-federation/reexport-module.js

@@ -0,0 +1,67 @@
+import { createUltramodernBuildArtifact } from "@modern-js/utils/universal";
+import { createDeliveryUnitRecord } from "../delivery-unit.js";
+function deliveryUnitRecordFor(scope, app) {
+    return app.deliveryUnit ? app.deliveryUnit : createDeliveryUnitRecord(scope, app);
+}
+function createUltramodernBuildArtifactJson(scope, app) {
+    const record = deliveryUnitRecordFor(scope, app);
+    return `${JSON.stringify(createUltramodernBuildArtifact(record), null, 2)}\n`;
+}
+function createUltramodernBuildModule(scope, app) {
+    const record = deliveryUnitRecordFor(scope, app);
+    return `declare const ULTRAMODERN_BUILD_MARKER: string;
+declare const ULTRAMODERN_SOURCE_REVISION: string;
+
+const ultramodernGeneratedBuildArtifact = ${JSON.stringify(createUltramodernBuildArtifact(record), null, 2)} as const;
+const ultramodernBuildMarker =
+  typeof ULTRAMODERN_BUILD_MARKER === 'string'
+    ? ULTRAMODERN_BUILD_MARKER
+    : ultramodernGeneratedBuildArtifact.deliveryUnit.buildMarker;
+const ultramodernSourceRevision =
+  typeof ULTRAMODERN_SOURCE_REVISION === 'string'
+    ? ULTRAMODERN_SOURCE_REVISION
+    : ultramodernGeneratedBuildArtifact.deliveryUnit.sourceRevision;
+const ultramodernBuildArtifact = {
+  ...ultramodernGeneratedBuildArtifact,
+  deliveryUnit: {
+    ...ultramodernGeneratedBuildArtifact.deliveryUnit,
+    build: ultramodernBuildMarker,
+    buildMarker: ultramodernBuildMarker,
+    sourceRevision: ultramodernSourceRevision,
+  },
+  surfaces: {
+    api: {
+      ...ultramodernGeneratedBuildArtifact.surfaces.api,
+      build: ultramodernBuildMarker,
+      buildMarker: ultramodernBuildMarker,
+      sourceRevision: ultramodernSourceRevision,
+    },
+    ui: {
+      ...ultramodernGeneratedBuildArtifact.surfaces.ui,
+      build: ultramodernBuildMarker,
+      buildMarker: ultramodernBuildMarker,
+      sourceRevision: ultramodernSourceRevision,
+    },
+  },
+} as const;
+
+export { ultramodernBuildArtifact };
+
+export const ultramodernDeliveryUnit =
+  ultramodernBuildArtifact.deliveryUnit;
+export const ultramodernVerticalIdentity = ultramodernDeliveryUnit;
+export const ultramodernUiMarker = ultramodernBuildArtifact.surfaces.ui;
+export const ultramodernApiMarker = ultramodernBuildArtifact.surfaces.api;
+`;
+}
+function createUltramodernBuildReexportModule() {
+    return `export {
+  ultramodernBuildArtifact,
+  ultramodernApiMarker,
+  ultramodernDeliveryUnit,
+  ultramodernUiMarker,
+  ultramodernVerticalIdentity,
+} from '../shared/ultramodern-build';
+`;
+}
+export { createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule };

package/dist/esm/ultramodern-workspace/module-federation/remote-refs.js

@@ -0,0 +1,65 @@
+import { createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, remoteDependencyAlias, resolveRemoteRefs } from "../descriptors.js";
+function createModuleFederationRemoteUrlHelpers(app, remotes = [], includeAppToolsImport = true) {
+    if (0 === resolveRemoteRefs(app, remotes).length) return '';
+    const appToolsImport = includeAppToolsImport ? "import { getBuildConfigEnvironment } from '@modern-js/app-tools/config';\n\n" : '';
+    return `${appToolsImport}const cloudflareDeployEnabled =
+  getBuildConfigEnvironment('MODERNJS_DEPLOY') === 'cloudflare';
+const cloudflareWorkersDevSubdomain =
+  getBuildConfigEnvironment('ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN')?.trim();
+const requireCloudflarePublicUrls =
+  getBuildConfigEnvironment('ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS') === 'true';
+
+const createRemoteManifestUrl = (options: {
+  manifestEnv: string;
+  mfName: string;
+  port: number;
+  publicUrlEnv: string;
+  workerName: string;
+}) => {
+  const configuredManifest = getBuildConfigEnvironment(options.manifestEnv)?.trim();
+  if (configuredManifest !== undefined && configuredManifest.length > 0) {
+    return configuredManifest;
+  }
+
+  const configuredPublicUrl = getBuildConfigEnvironment(options.publicUrlEnv)?.trim();
+  if (configuredPublicUrl !== undefined && configuredPublicUrl.length > 0) {
+    return \`\${options.mfName}@\${configuredPublicUrl.replace(/\\/+$/u, '')}/mf-manifest.json\`;
+  }
+
+  if (
+    cloudflareDeployEnabled &&
+    cloudflareWorkersDevSubdomain !== undefined &&
+    cloudflareWorkersDevSubdomain.length > 0
+  ) {
+    return \`\${options.mfName}@https://\${options.workerName}.\${cloudflareWorkersDevSubdomain}.workers.dev/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && requireCloudflarePublicUrls) {
+    throw new Error(
+      \`Cloudflare deploy needs \${options.publicUrlEnv}, \${options.manifestEnv}, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN for remote \${options.mfName}.\`,
+    );
+  }
+
+  return \`\${options.mfName}@http://localhost:\${options.port}/mf-manifest.json\`;
+};
+
+`;
+}
+function createModuleFederationRemotesConfig(scope, app, remotes = []) {
+    const remoteEntries = resolveRemoteRefs(app, remotes).toSorted((left, right)=>remoteDependencyAlias(left).localeCompare(remoteDependencyAlias(right))).map((remote)=>{
+        const key = remoteDependencyAlias(remote);
+        return `    ${key}: createRemoteManifestUrl({
+      manifestEnv: '${createRemoteManifestEnv(remote)}',
+      mfName: '${remote.mfName}',
+      port: ${remote.port},
+      publicUrlEnv: '${createCloudflarePublicUrlEnv(remote)}',
+      workerName: '${createCloudflareWorkerName(scope, remote)}',
+    }),`;
+    }).join('\n');
+    if (!remoteEntries) return '';
+    return `  remotes: {
+${remoteEntries}
+  },
+`;
+}
+export { createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig };

package/dist/esm/ultramodern-workspace/module-federation/shared-config.js

@@ -0,0 +1,12 @@
+import { renderFileTemplate } from "../fs-io.js";
+function createSharedModuleFederationConfig() {
+    return renderFileTemplate('workspace/apps/modern.config.shared-module-federation.ts', {});
+}
+function formatTsObjectLiteral(value) {
+    const entries = Object.entries(value).sort(([left], [right])=>left.localeCompare(right));
+    if (0 === entries.length) return '{}';
+    return `{
+${entries.map(([key, entryValue])=>`    '${key}': '${entryValue}',`).join('\n')}
+  }`;
+}
+export { createSharedModuleFederationConfig, formatTsObjectLiteral };