@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.10 → 3.5.0-ultramodern.101

package/dist/esm-node/plugins/deploy/platforms/templates/vercel-entry.mjs

@@ -2,57 +2,78 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProdServer } from '@modern-js/prod-server';
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 p_genPluginImportsCode;
-if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
 let requestHandler = null;
 let handlerCreationPromise = null;
+
 async function loadRoutes(routeFilepath) {
-    try {
-        await fs.access(routeFilepath);
-        const content = await fs.readFile(routeFilepath, 'utf-8');
-        const routeSpec = JSON.parse(content);
-        return routeSpec.routes || [];
-    } catch (error) {
-        console.warn('route.json not found or invalid, continuing with empty routes.');
-        return [];
-    }
+  try {
+    await fs.access(routeFilepath);
+    const content = await fs.readFile(routeFilepath, 'utf-8');
+    const routeSpec = JSON.parse(content);
+    return routeSpec.routes || [];
+  } catch (error) {
+    console.warn(
+      'route.json not found or invalid, continuing with empty routes.',
+    );
+    return [];
+  }
 }
+
 async function initServer() {
-    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
-    const routes = await loadRoutes(routeFilepath);
-    const dynamicProdOptions = p_dynamicProdOptions;
-    const prodServerOptions = {
-        pwd: __dirname,
-        routes,
-        disableCustomHook: true,
-        appContext: {
-            sharedDirectory: p_sharedDirectory,
-            apiDirectory: p_apiDirectory,
-            lambdaDirectory: p_lambdaDirectory
-        },
-        plugins: p_plugins,
-        serverConfigPath: p_serverDirectory,
-        ...dynamicProdOptions
-    };
-    const app = await createProdServer(prodServerOptions);
-    return app.getRequestListener();
+  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+  const routes = await loadRoutes(routeFilepath);
+
+  const dynamicProdOptions = p_dynamicProdOptions;
+
+  const prodServerOptions = {
+    pwd: __dirname,
+    routes,
+    disableCustomHook: true,
+    appContext: {
+      sharedDirectory: p_sharedDirectory,
+      apiDirectory: p_apiDirectory,
+      lambdaDirectory: p_lambdaDirectory,
+    },
+    plugins: p_plugins,
+    serverConfigPath: p_serverDirectory,
+    ...dynamicProdOptions,
+  };
+  const app = await createProdServer(prodServerOptions);
+
+  return app.getRequestListener();
 }
+
 async function createHandler() {
-    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
-        try {
-            requestHandler = await initServer();
-        } catch (error) {
-            console.error('Error creating server:', error);
-            process.exit(1);
-        }
+  if (!handlerCreationPromise) {
+    handlerCreationPromise = (async () => {
+      try {
+        requestHandler = await initServer();
+      } catch (error) {
+        console.error('Error creating server:', error);
+        process.exit(1);
+      }
     })();
-    await handlerCreationPromise;
-    return requestHandler;
+  }
+  await handlerCreationPromise;
+  return requestHandler;
 }
+
 createHandler();
-const handler = async (req, res)=>{
-    if (!requestHandler) await createHandler();
-    return requestHandler(req, res);
+
+const handler = async (req, res) => {
+  if (!requestHandler) {
+    await createHandler();
+  }
+  return requestHandler(req, res);
 };
+
 export default handler;

package/dist/esm-node/plugins/deploy/utils/npmAliases.mjs

@@ -0,0 +1,175 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+const dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises.readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson) {
+    const aliases = [];
+    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(node_path.join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises.readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(node_path.join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises.readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = node_path.join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(node_path.join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = node_path.resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises.readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = node_path.join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = node_path.resolve(outputDirectory);
+    const resolvedOutputRoot = await promises.realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${node_path.sep}`)){
+        const candidate = node_path.join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises.realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${node_path.sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(node_path.join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = node_path.dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = node_path.join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises.mkdir(node_path.dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises.realpath(aliasPath),
+            promises.realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = node_path.relative(node_path.dirname(aliasPath), target.directory);
+    await promises.symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = node_path.dirname(entryPath);
+    const root = node_path.parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(node_path.join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = node_path.dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(node_path.join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(node_path.join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = node_path.join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises.writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+export { preserveNpmAliases, readPackageIdentity };

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

@@ -26,7 +26,7 @@ const initialize = ()=>({
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();
                 const userConfig = api.getConfig();
-                const port = await getServerPort(resolved);
+                const port = await getServerPort(resolved, appContext.command);
                 appContext = {
                     ...appContext,
                     port,
@@ -61,9 +61,10 @@ function stabilizeConfig(resolve, config, keys) {
         resolve[key] = config[key] || {};
     });
 }
-async function getServerPort(config) {
+async function getServerPort(config, contextCommand) {
     const prodPort = Number(process.env.PORT) || config.server.port || 8080;
-    if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
+    const isProgrammaticDev = 'dev' === contextCommand || 'start' === contextCommand;
+    if (isDev() && (isDevCommand() || isProgrammaticDev)) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
 export default initialize;

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

@@ -18,7 +18,7 @@ const serverBuild = ()=>({
         name: '@modern-js/server-build',
         setup (api) {
             api.onAfterBuild(async ()=>{
-                const { appDirectory, distDirectory, metaName } = api.getAppContext();
+                const { appDirectory, distDirectory, metaName, moduleType } = api.getAppContext();
                 if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) return;
                 const modernConfig = api.getNormalizedConfig();
                 const distDir = path.resolve(distDirectory);
@@ -38,7 +38,8 @@ const serverBuild = ()=>({
                 }, {
                     sourceDirs,
                     distDir,
-                    tsconfigPath
+                    tsconfigPath,
+                    moduleType
                 });
             });
         }

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

@@ -0,0 +1,53 @@
+import "node:module";
+import node_path from "node:path";
+import { emitFrameworkMicroVerticalReleaseEnvelope, emitNodeStagedReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyNodeReleaseEnvelopeStaging } from "../ultramodern-release-envelope/framework-output.mjs";
+import { resolveDeployTarget } from "./deploy/index.mjs";
+const resolveActiveDeployTarget = (api)=>{
+    const { metaName } = api.getAppContext();
+    const config = api.getNormalizedConfig();
+    if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
+    return resolveDeployTarget(config);
+};
+const ultramodernReleaseEnvelope = ()=>({
+        name: '@modern-js/ultramodern-release-envelope',
+        pre: [
+            '@modern-js/backend-federation-build',
+            '@modern-js/plugin-bff'
+        ],
+        setup (api) {
+            const emitBuildEnvelope = async (target)=>{
+                const { apiOnly, distDirectory } = api.getAppContext();
+                await emitFrameworkMicroVerticalReleaseEnvelope({
+                    apiOnly,
+                    distDirectory,
+                    target
+                });
+            };
+            api.onAfterBuild(async ()=>{
+                const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
+                if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
+                await emitBuildEnvelope(configuredTarget);
+            });
+            api.onBeforeDeploy(async ()=>{
+                const configuredTarget = resolveActiveDeployTarget(api);
+                if ('node' !== configuredTarget) return;
+                await emitBuildEnvelope(configuredTarget);
+                const { distDirectory } = api.getAppContext();
+                await verifyBuildOutputReleaseEnvelope(distDirectory, configuredTarget);
+            });
+            api.onAfterDeploy(async ()=>{
+                const configuredTarget = resolveActiveDeployTarget(api);
+                if ('node' !== configuredTarget) return;
+                const { appDirectory, distDirectory } = api.getAppContext();
+                const outputDirectory = node_path.join(appDirectory, '.output');
+                const releaseEnvelope = await emitNodeStagedReleaseEnvelope({
+                    distDirectory,
+                    outputDirectory
+                });
+                if (releaseEnvelope) await verifyNodeReleaseEnvelopeStaging({
+                    outputDirectory
+                });
+            });
+        }
+    });
+export default ultramodernReleaseEnvelope;

package/dist/esm-node/presetUltramodern.mjs

@@ -2,6 +2,8 @@ import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { mergeConfig } from "@modern-js/plugin/cli";
+import { rspack } from "@rsbuild/core";
+import { resolveUltramodernReleaseIdentity } from "./ultramodern-release-identity.mjs";
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -34,8 +36,16 @@ const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
     chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
 };
 const createPresetUltramodernConfig = (options = {})=>{
-    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
+    const { appId = 'app', deliveryUnit, enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
     const server = {};
+    const releaseIdentity = deliveryUnit ? resolveUltramodernReleaseIdentity({
+        generationBuildMarker: deliveryUnit.buildMarker,
+        unitId: deliveryUnit.unitId
+    }) : void 0;
+    const bundledReleaseIdentity = releaseIdentity ? {
+        ...releaseIdentity,
+        releaseVersion: deliveryUnit.version
+    } : void 0;
     if (enableTelemetry) {
         server.telemetry = {
             enabled: true,
@@ -63,8 +73,29 @@ const createPresetUltramodernConfig = (options = {})=>{
             precompress: true
         },
         server,
+        ...deliveryUnit ? {
+            source: {
+                globalVars: {
+                    ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
+                    ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
+                    ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
+                }
+            }
+        } : {},
         tools: {
-            bundlerChain: setReactRouterBridgeSafeAliases
+            bundlerChain: setReactRouterBridgeSafeAliases,
+            ...bundledReleaseIdentity ? {
+                rspack: (config)=>{
+                    config.plugins ??= [];
+                    config.plugins.push(new rspack.BannerPlugin({
+                        banner: `void ${JSON.stringify(bundledReleaseIdentity.buildMarker)};void ${JSON.stringify(bundledReleaseIdentity.sourceRevision)};void ${JSON.stringify(bundledReleaseIdentity.releaseVersion)};`,
+                        raw: true,
+                        stage: rspack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+                        test: /\.(?:c|m)?js$/u
+                    }));
+                    return config;
+                }
+            } : {}
         }
     };
     if (enableBffRequestId) presetConfig.bff = {

package/dist/esm-node/ultramodern-release-envelope/canonical.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { createHash } from "node:crypto";
+const serializeCanonicalValue = (value)=>{
+    if (null === value || 'object' != typeof value) {
+        if ('number' == typeof value && !Number.isFinite(value)) throw new Error('Canonical release-envelope values must be finite.');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) return `[${value.map(serializeCanonicalValue).join(',')}]`;
+    return `{${Object.keys(value).sort().map((key)=>`${JSON.stringify(key)}:${serializeCanonicalValue(value[key])}`).join(',')}}`;
+};
+const releaseEnvelopePayload = (envelope)=>({
+        schemaVersion: envelope.schemaVersion,
+        kind: envelope.kind,
+        target: envelope.target,
+        identity: envelope.identity,
+        artifacts: envelope.artifacts,
+        surfaces: envelope.surfaces
+    });
+const canonicalSerializeMicroVerticalReleaseEnvelopePayload = (payload)=>serializeCanonicalValue(payload);
+const canonicalSerializeMicroVerticalReleaseEnvelope = (envelope)=>serializeCanonicalValue(envelope);
+const digestMicroVerticalReleaseEnvelopePayload = (payload)=>createHash('sha256').update(canonicalSerializeMicroVerticalReleaseEnvelopePayload(payload)).digest('hex');
+export { canonicalSerializeMicroVerticalReleaseEnvelope, canonicalSerializeMicroVerticalReleaseEnvelopePayload, digestMicroVerticalReleaseEnvelopePayload, releaseEnvelopePayload };