@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.12 → 3.2.0-ultramodern.120

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

@@ -1,5 +1,6 @@
 import "node:module";
 import { provider } from "std-env";
+import { createCloudflarePreset } from "./platforms/cloudflare.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
@@ -9,14 +10,18 @@ const deployPresets = {
     node: createNodePreset,
     vercel: createVercelPreset,
     netlify: createNetlifyPreset,
-    ghPages: createGhPagesPreset
+    ghPages: createGhPagesPreset,
+    cloudflare: createCloudflarePreset
 };
+const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
+const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
+const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>modernConfig.deploy?.target || envDeployTarget || detectedProvider || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
+    if (!isDeployTarget(deployTarget)) throw new Error(`Unknown deploy target: '${deployTarget}'. deploy.target or MODERNJS_DEPLOY should be one of: ${getSupportedDeployTargets().join(', ')}.`);
     const createPreset = deployPresets[deployTarget];
-    if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
     return createPreset({
         appContext,
         modernConfig,
@@ -27,12 +32,12 @@ async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
 const deploy = ()=>({
         name: '@modern-js/plugin-deploy',
         setup: (api)=>{
-            const deployTarget = process.env.MODERNJS_DEPLOY || provider || 'node';
             api.deploy(async ()=>{
                 const appContext = api.getAppContext();
                 const { metaName } = appContext;
-                if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
                 const modernConfig = api.getNormalizedConfig();
+                const deployTarget = resolveDeployTarget(modernConfig);
+                if ('modern-js' !== metaName && !modernConfig.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
                 const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
@@ -42,3 +47,4 @@ const deploy = ()=>({
         }
     });
 export default deploy;
+export { getSupportedDeployTargets, resolveDeployTarget };

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

@@ -0,0 +1,337 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { readTemplate } from "../utils/index.mjs";
+const WORKER_ENTRY = 'server/index.mjs';
+const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const ASSETS_BINDING = 'ASSETS';
+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 = 'public';
+const WORKER_BUNDLE_DIRECTORY = 'worker';
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
+const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+const DEFAULT_SECURITY_HEADERS = {
+    referrerPolicy: 'strict-origin-when-cross-origin',
+    contentTypeOptions: 'nosniff',
+    permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
+};
+const DEFAULT_CSP_DIRECTIVES = {
+    'base-uri': [
+        "'self'"
+    ],
+    'connect-src': [
+        "'self'",
+        'https:',
+        'http:',
+        'wss:',
+        'ws:'
+    ],
+    'default-src': [
+        "'self'"
+    ],
+    'font-src': [
+        "'self'",
+        'data:',
+        'https:',
+        'http:'
+    ],
+    'form-action': [
+        "'self'"
+    ],
+    'frame-ancestors': [
+        "'self'"
+    ],
+    'img-src': [
+        "'self'",
+        'data:',
+        'blob:',
+        'https:',
+        'http:'
+    ],
+    'manifest-src': [
+        "'self'",
+        'https:',
+        'http:'
+    ],
+    'object-src': [
+        "'none'"
+    ],
+    "script-src": [
+        "'self'",
+        "'unsafe-inline'",
+        "'unsafe-eval'",
+        'https:',
+        'http:',
+        'blob:'
+    ],
+    'style-src': [
+        "'self'",
+        "'unsafe-inline'",
+        'https:',
+        'http:'
+    ],
+    'worker-src': [
+        "'self'",
+        'blob:'
+    ]
+};
+const getCompatibilityDate = (modernConfig)=>{
+    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
+    const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
+    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+    return compatibilityDate;
+};
+const getWorkerName = (appDirectory)=>{
+    const basename = node_path.basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
+    const configuredName = modernConfig.deploy?.worker?.name?.trim();
+    return configuredName || getWorkerName(appDirectory);
+};
+const normalizeDirectiveValues = (value)=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return [
+        ...new Set(values.map((entry)=>entry.trim()).filter(Boolean))
+    ];
+};
+const appendDirectiveValues = (directives, name, values)=>{
+    if (!values?.length) return;
+    directives[name] = normalizeDirectiveValues([
+        ...directives[name] ?? [],
+        ...values
+    ]);
+};
+const createContentSecurityPolicy = (config)=>{
+    const mode = config?.mode ?? 'report-only';
+    if ('off' === mode) return {
+        mode,
+        directives: {},
+        reason: config?.reason
+    };
+    const directives = Object.fromEntries(Object.entries(DEFAULT_CSP_DIRECTIVES).map(([name, values])=>[
+            name,
+            [
+                ...values
+            ]
+        ]));
+    for (const [name, value] of Object.entries(config?.directives ?? {}))if (false === value) delete directives[name];
+    else directives[name] = normalizeDirectiveValues(value);
+    if (config?.frameAncestors === false) delete directives['frame-ancestors'];
+    else if (config?.frameAncestors) directives['frame-ancestors'] = normalizeDirectiveValues(config.frameAncestors);
+    appendDirectiveValues(directives, "script-src", config?.additionalScriptSrc);
+    appendDirectiveValues(directives, 'style-src', config?.additionalStyleSrc);
+    appendDirectiveValues(directives, 'connect-src', config?.additionalConnectSrc);
+    appendDirectiveValues(directives, 'img-src', config?.additionalImgSrc);
+    if (config?.reportUri) directives['report-uri'] = [
+        config.reportUri
+    ];
+    return {
+        mode,
+        directives,
+        reason: config?.reason
+    };
+};
+const createNoindexPolicy = (noindex)=>{
+    if (false === noindex) return {
+        workersDev: false,
+        localhost: false,
+        previewHostnames: []
+    };
+    if (true === noindex || void 0 === noindex) return {
+        workersDev: true,
+        localhost: true,
+        previewHostnames: []
+    };
+    return {
+        workersDev: noindex.workersDev ?? true,
+        localhost: noindex.localhost ?? true,
+        previewHostnames: noindex.previewHostnames ?? [],
+        reason: noindex.reason
+    };
+};
+const createCloudflareWorkerSecurityPolicy = (modernConfig)=>{
+    const security = modernConfig.deploy?.worker?.security;
+    if (security?.enabled === false) return {
+        enabled: false,
+        reason: security.reason
+    };
+    return {
+        enabled: true,
+        headers: {
+            referrerPolicy: security?.headers?.referrerPolicy ?? DEFAULT_SECURITY_HEADERS.referrerPolicy,
+            contentTypeOptions: security?.headers?.contentTypeOptions ?? DEFAULT_SECURITY_HEADERS.contentTypeOptions,
+            permissionsPolicy: security?.headers?.permissionsPolicy ?? DEFAULT_SECURITY_HEADERS.permissionsPolicy
+        },
+        contentSecurityPolicy: createContentSecurityPolicy(security?.contentSecurityPolicy),
+        noindex: createNoindexPolicy(security?.noindex),
+        cookies: {
+            mutateSetCookie: false,
+            reason: security?.cookies?.reason ?? 'Cloudflare worker does not own application Set-Cookie headers.'
+        },
+        reason: security?.reason
+    };
+};
+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 : []
+    };
+};
+const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+    const routeSpec = await readRouteSpec(outputDirectory);
+    const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
+        const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        return {
+            urlPath: route.urlPath,
+            entryName: route.entryName,
+            entryPath: route.entryPath,
+            isSSR: Boolean(route.isSSR),
+            worker,
+            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false
+        };
+    }));
+    const bffPrefix = modernConfig.bff?.prefix;
+    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const isEffectBff = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectBffWorkerExists = await fs.pathExists(node_path.join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    return {
+        version: 1,
+        runtime: {
+            type: 'cloudflare-module-worker',
+            entry: WORKER_ENTRY,
+            fetchExport: true,
+            nodeListen: false
+        },
+        assets: {
+            binding: ASSETS_BINDING,
+            directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+            runWorkerFirst: true
+        },
+        routeSpec: {
+            file: ROUTE_SPEC_OUTPUT,
+            routes
+        },
+        workerBundles: {
+            directory: WORKER_BUNDLE_DIRECTORY,
+            format: 'commonjs',
+            importableFromModuleWorker: true,
+            requestHandlerExport: 'requestHandler'
+        },
+        resources: {
+            loadableStats: LOADABLE_STATS_FILE,
+            routeManifest: ROUTE_MANIFEST_FILE
+        },
+        security: createCloudflareWorkerSecurityPolicy(modernConfig),
+        bff: isEffectBff && primaryBffPrefix && effectBffWorkerExists ? {
+            runtimeFramework: 'effect',
+            prefix: primaryBffPrefix,
+            worker: BFF_EFFECT_WORKER_ENTRY
+        } : void 0
+    };
+};
+const createWorkerModuleLoaders = (manifest)=>{
+    const imports = new Map();
+    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
+        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
+        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (manifest.bff?.worker) {
+        const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;
+        imports.set(manifest.bff.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (0 === imports.size) return '{}';
+    const loaders = [
+        ...imports.entries()
+    ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
+    return `{\n${loaders.join(',\n')}\n}`;
+};
+const shouldCopyToPublicAssets = (src, distDirectory)=>{
+    const relativePath = node_path.relative(distDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const [topLevelDirectory] = normalizedRelativePath.split('/');
+    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY;
+};
+const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
+    const relativePath = node_path.relative(workerBundleDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const basename = node_path.basename(normalizedRelativePath);
+    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
+    if (fs.statSync(src).isDirectory()) return true;
+    return [
+        '.cjs',
+        '.js',
+        '.mjs'
+    ].includes(node_path.extname(normalizedRelativePath));
+};
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { appDirectory, distDirectory } = appContext;
+    const outputDirectory = node_path.join(appDirectory, '.output');
+    const publicDirectory = node_path.join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
+    const workerEntryPath = node_path.join(outputDirectory, WORKER_ENTRY);
+    const workerManifestPath = node_path.join(outputDirectory, WORKER_MANIFEST);
+    const routeSpecOutputPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = node_path.join(outputDirectory, 'wrangler.json');
+    const workerName = getConfiguredWorkerName(appDirectory, modernConfig);
+    return {
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory)
+            });
+            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);
+            if (await fs.pathExists(workerBundleSourceDirectory)) await fs.copy(workerBundleSourceDirectory, node_path.join(outputDirectory, WORKER_BUNDLE_DIRECTORY), {
+                filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+            });
+            await fs.writeJSON(wranglerConfigPath, {
+                $schema: 'node_modules/wrangler/config-schema.json',
+                name: workerName,
+                main: WORKER_ENTRY,
+                compatibility_date: getCompatibilityDate(modernConfig),
+                compatibility_flags: [
+                    'nodejs_compat',
+                    'global_fetch_strictly_public'
+                ],
+                assets: {
+                    directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+                    binding: ASSETS_BINDING,
+                    run_worker_first: true
+                }
+            }, {
+                spaces: 2
+            });
+            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+                spaces: 2
+            });
+            await fs.writeJSON(node_path.join(outputDirectory, 'package.json'), {
+                type: 'commonjs'
+            });
+        },
+        async genEntry () {
+            const template = await readTemplate('cloudflare-entry.mjs');
+            const manifest = await fs.readJSON(workerManifestPath);
+            await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+        }
+    };
+};
+export { createCloudflarePreset };