@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

package/dist/esm/utils/runtimeGenerator.mjs

@@ -0,0 +1,89 @@
+import { fs } from "@modern-js/utils";
+import path from "path";
+const getPackageName = (appDirectory)=>{
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = require(packageJsonPath);
+        return packageJson.name;
+    } catch (error) {
+        return;
+    }
+};
+async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName }) {
+    const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'runtime');
+    const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
+    const runtimeImportPath = JSON.stringify(runtime);
+    const requestIdValue = JSON.stringify(requestId);
+    const source = `const { configure: _configure } = require(${runtimeImportPath});
+    const defaultSecureOptions = {
+      requestId: ${requestIdValue},
+      requireEnvelope: true,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+      },
+    };
+    const initProducerClient = (options) => {
+      return _configure({
+        ...defaultSecureOptions,
+        ...options,
+        identityBinding: {
+          ...defaultSecureOptions.identityBinding,
+          ...(options && options.identityBinding ? options.identityBinding : {}),
+        },
+        operationContract: {
+          ...defaultSecureOptions.operationContract,
+          ...(options && options.operationContract ? options.operationContract : {}),
+        },
+      });
+    }
+    const configure = initProducerClient;
+    Object.defineProperty(exports, '__esModule', { value: true });
+    exports.initProducerClient = initProducerClient;
+    exports.configure = configure;
+  `;
+    const pluginPath = path.join(pluginDir, 'index.js');
+    await fs.ensureFile(pluginPath);
+    await fs.writeFile(pluginPath, source);
+    const tsSource = `type ProducerRuntimeModule = typeof import(${runtimeImportPath});
+  type ProducerClientOptions = ProducerRuntimeModule extends {
+    configure: (options: infer TOptions) => unknown;
+  }
+    ? TOptions
+    : {
+        request?: typeof fetch;
+        interceptor?: (request: typeof fetch) => typeof fetch;
+        allowedHeaders?: string[];
+        requireEnvelope?: boolean;
+        allowCrossOriginEnvelope?: boolean;
+        identityBinding?: {
+          enabled?: boolean;
+          strict?: boolean;
+          protectedHeaders?: string[];
+        };
+        operationContract?: {
+          enabled?: boolean;
+          strict?: boolean;
+          requireSchemaHash?: boolean;
+          requireOperationVersion?: boolean;
+        };
+        setDomain?: (ops?: {
+          target: 'server' | 'browser';
+          requestId?: string;
+        }) => string;
+        requestId?: string;
+      };
+  export declare const initProducerClient: (options: ProducerClientOptions) => void;
+  export declare const configure: typeof initProducerClient;`;
+    const pluginTypePath = path.join(pluginDir, 'index.d.ts');
+    await fs.ensureFile(pluginTypePath);
+    await fs.writeFile(pluginTypePath, tsSource);
+}
+const utils_runtimeGenerator = runtimeGenerator;
+export default utils_runtimeGenerator;

package/dist/esm-node/cli.mjs

@@ -0,0 +1,249 @@
+import "node:module";
+import { ApiRouter } from "@modern-js/bff-core";
+import { compile } from "@modern-js/server-utils";
+import { API_DIR, DEFAULT_API_PREFIX, SHARED_DIR, fs, normalizeOutputPath, resolveServerTsconfig } from "@modern-js/utils";
+import path from "path";
+import clientGenerator from "./utils/clientGenerator.mjs";
+import pluginGenerator from "./utils/pluginGenerator.mjs";
+import runtimeGenerator from "./utils/runtimeGenerator.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
+const WATCHABLE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.cts',
+    '.mjs',
+    '.cjs',
+    '.json'
+];
+const isWatchableBffFile = (filename)=>WATCHABLE_EXTENSIONS.some((ext)=>filename.endsWith(ext));
+const normalizePrefixList = (prefix)=>{
+    if (Array.isArray(prefix)) return prefix.filter(Boolean);
+    return [
+        prefix || DEFAULT_API_PREFIX
+    ];
+};
+const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || DEFAULT_API_PREFIX;
+const bffPlugin = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            {
+                const appContext = api.getAppContext();
+                const userRuntimeFramework = api.getConfig()?.bff?.runtimeFramework;
+                api.updateAppContext({
+                    ...appContext,
+                    bffRuntimeFramework: 'hono' === userRuntimeFramework ? 'hono' : 'effect'
+                });
+            }
+            const compileApi = async ()=>{
+                const { appDirectory, distDirectory, apiDirectory, sharedDirectory, moduleType } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const distDir = path.resolve(distDirectory);
+                const apiDir = apiDirectory || path.resolve(appDirectory, API_DIR);
+                const sharedDir = sharedDirectory || path.resolve(appDirectory, SHARED_DIR);
+                const tsconfigPath = resolveServerTsconfig(appDirectory, modernConfig?.server?.tsconfigPath);
+                const sourceDirs = [];
+                if (await fs.pathExists(apiDir)) sourceDirs.push(apiDir);
+                if (await fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
+                const { alias } = modernConfig.source;
+                const { alias: resolveAlias } = modernConfig.resolve;
+                if (sourceDirs.length > 0) {
+                    const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
+                    await compile(appDirectory, {
+                        alias: combinedAlias
+                    }, {
+                        sourceDirs,
+                        distDir,
+                        tsconfigPath,
+                        moduleType,
+                        throwErrorInsteadOfExit: true
+                    });
+                }
+            };
+            const generator = async ()=>{
+                const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
+                const { bff } = modernConfig || {};
+                const prefix = getPrimaryPrefix(bff?.prefix);
+                const httpMethodDecider = bff?.httpMethodDecider;
+                const apiRouter = new ApiRouter({
+                    apiDir: apiDirectory,
+                    appDir: appDirectory,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider,
+                    isBuild: true
+                });
+                const lambdaDir = apiRouter.getLambdaDir();
+                const existLambda = apiRouter.isExistLambda();
+                const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
+                const relativeApiPath = path.relative(appDirectory, apiDirectory);
+                const relativeLambdaPath = path.relative(appDirectory, lambdaDir);
+                await pluginGenerator({
+                    prefix,
+                    appDirectory,
+                    relativeDistPath,
+                    relativeApiPath,
+                    relativeLambdaPath,
+                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect'
+                });
+                await clientGenerator({
+                    prefix,
+                    appDir: appDirectory,
+                    apiDir: apiDirectory,
+                    lambdaDir,
+                    existLambda,
+                    port,
+                    requestCreator: bff?.requestCreator,
+                    httpMethodDecider,
+                    relativeDistPath,
+                    relativeApiPath,
+                    bffRuntimeFramework,
+                    effectEntry: bff?.effect?.entry,
+                    effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                });
+                await runtimeGenerator({
+                    runtime,
+                    appDirectory,
+                    relativeDistPath
+                });
+            };
+            const handleCrossProjectInvocation = async (isBuild = false)=>{
+                const { bff } = api.getNormalizedConfig();
+                if (bff?.crossProject) {
+                    if (!isBuild) await compileApi();
+                    await generator();
+                }
+            };
+            const isHono = ()=>{
+                const { bffRuntimeFramework } = api.getAppContext();
+                return 'hono' === bffRuntimeFramework;
+            };
+            const createCompressConfig = (devServer, prefix)=>{
+                if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+                const { compress } = devServer;
+                if (void 0 === compress || true === compress) {
+                    const prefixes = normalizePrefixList(prefix);
+                    return {
+                        filter: (req)=>!prefixes.some((item)=>req.url?.includes(item))
+                    };
+                }
+                if (false === compress) return false;
+                return compress;
+            };
+            api.config(async ()=>{
+                const devServer = api.getConfig()?.tools?.devServer;
+                const prefix = api.getConfig()?.bff?.prefix || DEFAULT_API_PREFIX;
+                const compress = createCompressConfig(devServer, prefix);
+                return {
+                    tools: {
+                        devServer: {
+                            compress
+                        },
+                        bundlerChain: (chain, { CHAIN_ID, isServer })=>{
+                            const { port, appDirectory, apiDirectory, lambdaDirectory, bffRuntimeFramework } = api.getAppContext();
+                            const modernConfig = api.getNormalizedConfig();
+                            const { bff } = modernConfig || {};
+                            const prefix = getPrimaryPrefix(bff?.prefix);
+                            const httpMethodDecider = bff?.httpMethodDecider;
+                            const apiRouter = new ApiRouter({
+                                apiDir: apiDirectory,
+                                appDir: appDirectory,
+                                lambdaDir: lambdaDirectory,
+                                prefix,
+                                httpMethodDecider,
+                                isBuild: true
+                            });
+                            const lambdaDir = apiRouter.getLambdaDir();
+                            const existLambda = apiRouter.isExistLambda();
+                            const apiRegexp = new RegExp(normalizeOutputPath(`${apiDirectory}${path.sep}.*(.[tj]s)$`));
+                            const name = isServer ? 'server' : 'client';
+                            const sourceExt = 'mjs';
+                            const loaderPath = path.join(cli_dirname, `loader.${sourceExt}`);
+                            chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(apiRegexp);
+                            chain.module.rule('js-bff-api').test(apiRegexp).use('custom-loader').loader(loaderPath.replace(/\\/g, '/')).options({
+                                prefix,
+                                appDir: appDirectory,
+                                apiDir: apiDirectory,
+                                lambdaDir,
+                                existLambda,
+                                port,
+                                target: name,
+                                requestCreator: bff?.requestCreator,
+                                httpMethodDecider,
+                                bffRuntimeFramework,
+                                effectEntry: bff?.effect?.entry,
+                                effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                            });
+                        }
+                    }
+                };
+            });
+            api.modifyServerRoutes(({ routes })=>{
+                const modernConfig = api.getNormalizedConfig();
+                const { bff } = modernConfig || {};
+                const prefix = bff?.prefix || '/api';
+                const prefixList = [];
+                if (Array.isArray(prefix)) prefixList.push(...prefix);
+                else prefixList.push(prefix);
+                const apiServerRoutes = prefixList.map((pre)=>({
+                        urlPath: pre,
+                        isApi: true,
+                        entryPath: '',
+                        isSPA: false,
+                        isSSR: false
+                    }));
+                if (!isHono() && bff?.enableHandleWeb) return {
+                    routes: routes.map((route)=>({
+                            ...route,
+                            isApi: true
+                        })).concat(apiServerRoutes)
+                };
+                return {
+                    routes: routes.concat(apiServerRoutes)
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                plugins.push({
+                    name: '@modern-js/plugin-bff/server-plugin'
+                });
+                return {
+                    plugins
+                };
+            });
+            api.onBeforeDev(async ()=>{
+                await handleCrossProjectInvocation();
+            });
+            api.onAfterBuild(async ()=>{
+                await compileApi();
+                await handleCrossProjectInvocation(true);
+            });
+            api.addWatchFiles(async ()=>{
+                const appContext = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if (config?.bff?.crossProject) return [
+                    appContext.apiDirectory,
+                    appContext.sharedDirectory
+                ].filter(Boolean);
+                return [];
+            });
+            api.onFileChanged(async (e)=>{
+                const { filename, eventType, isPrivate } = e;
+                const { appDirectory, apiDirectory, sharedDirectory } = api.getAppContext();
+                const relativeApiPath = path.relative(appDirectory, apiDirectory);
+                const relativeSharedPath = sharedDirectory ? path.relative(appDirectory, sharedDirectory) : '';
+                const isApiFile = filename.startsWith(`${relativeApiPath}/`);
+                const isSharedFile = relativeSharedPath ? filename.startsWith(`${relativeSharedPath}/`) : false;
+                if (!isPrivate && ('add' === eventType || 'change' === eventType || 'unlink' === eventType) && (isApiFile || isSharedFile) && isWatchableBffFile(filename)) await handleCrossProjectInvocation();
+            });
+        }
+    });
+const cli = bffPlugin;
+export default cli;
+export { bffPlugin };

package/dist/esm-node/constants.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+const API_APP_NAME = '_app';
+const BUILD_FILES = [
+    '**/*.[tj]sx?',
+    '!**/*.test.jsx?',
+    '!**/*.test.tsx?',
+    '!**/*.spec.jsx?',
+    '!**/*.spec.tsx?',
+    '!__tests__/*.tsx?',
+    '!__tests__/*.jsx?'
+];
+export { API_APP_NAME, BUILD_FILES };

package/dist/esm-node/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./constants.mjs";

package/dist/esm-node/loader.mjs

@@ -0,0 +1,64 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { generateClient } from "@modern-js/bff-core";
+import { logger } from "@modern-js/utils";
+import path from "path";
+import { generateEffectClientCode, resolveEffectEntryFile } from "./utils/effectClientGenerator.mjs";
+async function loader(source) {
+    this.cacheable();
+    const { resourcePath } = this;
+    delete require.cache[resourcePath];
+    const callback = this.async();
+    const draftOptions = this.getOptions();
+    const effectEntryFile = resolveEffectEntryFile({
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        effectEntry: draftOptions.effectEntry
+    });
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && path.resolve(effectEntryFile) === path.resolve(resourcePath)) {
+        const code = await generateEffectClientCode({
+            appDir: draftOptions.appDir,
+            apiDir: draftOptions.apiDir,
+            resourcePath,
+            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+            port: Number(draftOptions.port),
+            target: draftOptions.target,
+            requestCreator: draftOptions.requestCreator,
+            httpMethodDecider: draftOptions.httpMethodDecider,
+            dataPlatformBatch: draftOptions.effectDataPlatformBatch
+        });
+        if (code) return void callback(void 0, code);
+        callback(void 0, `throw new Error('Failed to generate Effect client for ${resourcePath}')`);
+        return;
+    }
+    const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
+    if (!draftOptions.existLambda) {
+        logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    const options = {
+        prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        lambdaDir: draftOptions.lambdaDir,
+        target: draftOptions.target,
+        port: Number(draftOptions.port),
+        source,
+        resourcePath,
+        httpMethodDecider: draftOptions.httpMethodDecider
+    };
+    const { lambdaDir } = draftOptions;
+    if (!resourcePath.startsWith(lambdaDir)) {
+        logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    if (draftOptions.fetcher) options.fetcher = draftOptions.fetcher;
+    if (draftOptions.requestCreator) options.requestCreator = draftOptions.requestCreator;
+    options.requireResolve = require.resolve;
+    const result = await generateClient(options);
+    callback(void 0, result.isOk ? result.value : `throw new Error('${result.value}')`);
+}
+const src_loader = loader;
+export default src_loader;

package/dist/esm-node/runtime/create-request/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader } from "@modern-js/create-request";