@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/esm/utils/effectClientGenerator.mjs

@@ -1,249 +1 @@
-import { deriveOperationVersion } from "@modern-js/bff-core";
-import { compatibleRequire, findExists, fs, logger } from "@modern-js/utils";
-import path from "path";
-import { collectEffectEndpoints, createEffectEndpointContractHash, ensureLeadingSlash, extractHttpApiFromModule, normalizeEffectPrefix } from "../runtime/effect/endpoint-contracts.mjs";
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
-const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
-let httpApiRuntimePromise;
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function resolveBatchEndpoint(prefix, endpoint) {
-    const value = endpoint || '/_data/batch';
-    if (isAbsoluteUrl(value)) return value;
-    const normalizedPrefix = normalizeEffectPrefix(prefix);
-    const normalizedEndpoint = ensureLeadingSlash(value);
-    if (!normalizedPrefix) return normalizedEndpoint;
-    if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
-    return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
-}
-function getPackageInfo(appDir) {
-    try {
-        const packageJsonPath = path.resolve(appDir, './package.json');
-        const packageJson = fs.readJSONSync(packageJsonPath);
-        return {
-            name: packageJson.name,
-            version: packageJson.version
-        };
-    } catch  {
-        return {};
-    }
-}
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await compatibleRequire('effect/unstable/httpapi', false);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
-            const effectPackageJson = require.resolve('effect/package.json');
-            const effectHttpApiRuntimePath = path.join(path.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await compatibleRequire(effectHttpApiRuntimePath, false);
-        }
-        if (isRecord(mod) && isRecord(mod.HttpApi)) {
-            const maybeHttpApi = mod.HttpApi;
-            if ('function' == typeof maybeHttpApi.isHttpApi && 'function' == typeof maybeHttpApi.reflect) return maybeHttpApi;
-        }
-        throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
-    })();
-    return httpApiRuntimePromise;
-}
-async function loadEffectApi(resourcePath) {
-    const httpApiRuntime = await getHttpApiRuntime();
-    const mod = await compatibleRequire(resourcePath, false);
-    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
-}
-function renderEffectClientCode(endpoints, options) {
-    const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
-    const httpMethodDecider = options.httpMethodDecider || 'functionName';
-    const packageInfo = getPackageInfo(options.appDir);
-    const packageName = packageInfo.name;
-    const dataPlatformAppNamespace = packageName || 'unknown-app';
-    const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
-    const normalizedRequestId = requestId || 'default';
-    const operationVersion = deriveOperationVersion(packageInfo.version);
-    const batchConfig = options.dataPlatformBatch;
-    const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
-    const manifest = {
-        endpoints: endpoints.map((endpoint)=>({
-                apiId: endpoint.apiId,
-                group: endpoint.groupName,
-                endpoint: endpoint.endpointName,
-                method: endpoint.method,
-                routePath: endpoint.routePath,
-                schemaHash: createEffectEndpointContractHash(endpoint, normalizedRequestId),
-                operationVersion
-            }))
-    };
-    const config = {
-        appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
-            requestId
-        } : {},
-        port: options.port,
-        useEnvPort: 'server' === options.target,
-        defaultOrigin: `http://localhost:${String(options.port)}`,
-        httpMethodDecider,
-        batch: {
-            enabled: batchConfig?.enabled ?? true,
-            endpoint: batchEndpoint,
-            flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
-            maxBatchSize: batchConfig?.maxBatchSize ?? 16,
-            maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
-            requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
-                'GET'
-            ]
-        }
-    };
-    return `import * as __requestRuntime from ${JSON.stringify(requestCreator)};
-import { createGeneratedEffectClient } from ${JSON.stringify(EFFECT_CLIENT_RUNTIME_IMPORT)};
-
-const __manifest = ${JSON.stringify(manifest, null, 2)};
-
-const __config = ${JSON.stringify(config, null, 2)};
-
-const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
-
-const client = __generated.client;
-const operationManifest = __generated.operationManifest;
-const createEffectRequestContext = __generated.createEffectRequestContext;
-const apiModule = {
-  client,
-  operationManifest,
-  createEffectRequestContext,
-};
-
-export { client, createEffectRequestContext, operationManifest };
-export default apiModule;
-`;
-}
-function renderClientShape(endpoints, valueType) {
-    if (0 === endpoints.length) return `Record<string, Record<string, ${valueType}>>`;
-    const groups = new Map();
-    for (const endpoint of endpoints){
-        const group = groups.get(endpoint.groupName) || [];
-        group.push(endpoint.endpointName);
-        groups.set(endpoint.groupName, group);
-    }
-    const groupEntries = [
-        ...groups.entries()
-    ].map(([groupName, names])=>{
-        const endpointEntries = names.map((name)=>`    ${JSON.stringify(name)}: ${valueType};`).join('\n');
-        return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
-    });
-    return `{\n${groupEntries.join('\n')}\n}`;
-}
-function renderEffectClientDeclaration(endpoints = []) {
-    return `export type EffectClientOperation = (
-  request?: unknown,
-) => Promise<unknown>;
-export type EffectClientGroup = Record<string, EffectClientOperation>;
-export type EffectClient = Record<string, EffectClientGroup>;
-export type EffectOperationDescriptor = {
-  appNamespace: string;
-  apiId: string;
-  group: string;
-  endpoint: string;
-  operationId: string;
-  routePath: string;
-  method: string;
-  operationVersion: number;
-  schemaHash: string;
-  version: number;
-};
-export type EffectOperationManifest = Record<
-  string,
-  Record<string, EffectOperationDescriptor>
->;
-export type EffectOperationContext = {
-  requestId?: string;
-  operationId?: string;
-  routePath?: string;
-  method?: string;
-  schemaHash?: string;
-  operationVersion?: number;
-  locale?: string;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-  source?: string;
-  scope?: Record<string, unknown>;
-  sessionClaims?: Record<string, unknown>;
-  attributes?: Record<string, unknown>;
-};
-export type EffectRequestContext = {
-  headers?: Record<string, string>;
-  locale?: string;
-  operationContext?: EffectOperationContext;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-};
-export type GeneratedEffectClient = ${renderClientShape(endpoints, 'EffectClientOperation')};
-export type GeneratedEffectOperationManifest = ${renderClientShape(endpoints, "EffectOperationDescriptor")};
-
-export declare const client: GeneratedEffectClient;
-export declare const createEffectRequestContext: (
-  requestContext: Record<string, unknown>,
-) => EffectRequestContext;
-export declare const operationManifest: GeneratedEffectOperationManifest;
-declare const apiModule: {
-  client: GeneratedEffectClient;
-  createEffectRequestContext: typeof createEffectRequestContext;
-  operationManifest: GeneratedEffectOperationManifest;
-};
-
-export default apiModule;
-`;
-}
-async function generateEffectClient(options) {
-    const api = await loadEffectApi(options.resourcePath);
-    if (!api) {
-        logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-        return null;
-    }
-    const httpApiRuntime = await getHttpApiRuntime();
-    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
-    return {
-        code: renderEffectClientCode(endpoints, options),
-        declaration: renderEffectClientDeclaration(endpoints),
-        endpoints
-    };
-}
-async function generateEffectClientCode(options) {
-    const artifacts = await generateEffectClient(options);
-    return artifacts ? artifacts.code : null;
-}
-function resolveEffectEntryFile(options) {
-    const { appDir, apiDir, effectEntry } = options;
-    const resolveEntry = (entryWithoutExt)=>{
-        if (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
-        return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
-    };
-    if (effectEntry) {
-        const entryWithoutExt = path.isAbsolute(effectEntry) ? effectEntry : path.resolve(appDir, effectEntry);
-        return resolveEntry(entryWithoutExt);
-    }
-    return resolveEntry(path.resolve(apiDir, 'index'));
-}
-export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile };
+export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile } from "./effect-client-generator/index.mjs";

package/dist/esm-node/cli/compress.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { normalizePrefixList } from "./prefix.mjs";
+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;
+};
+export { createCompressConfig };

package/dist/esm-node/cli/generator.mjs

@@ -0,0 +1,99 @@
+import "node:module";
+import { ApiRouter } from "@modern-js/bff-core";
+import { compile } from "@modern-js/server-utils";
+import { API_DIR, SHARED_DIR, fs, 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 { getPrimaryPrefix } from "./prefix.mjs";
+const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
+const createBffGenerator = (api)=>{
+    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 generate = 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 generate();
+        }
+    };
+    return {
+        compileApi,
+        generate,
+        handleCrossProjectInvocation
+    };
+};
+export { createBffGenerator };

package/dist/esm-node/cli/prefix.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { DEFAULT_API_PREFIX } from "@modern-js/utils";
+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;
+export { getPrimaryPrefix, normalizePrefixList };

package/dist/esm-node/cli/watch.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+const WATCHABLE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.cts',
+    '.mjs',
+    '.cjs',
+    '.json'
+];
+const isWatchableBffFile = (filename)=>WATCHABLE_EXTENSIONS.some((ext)=>filename.endsWith(ext));
+export { isWatchableBffFile };

package/dist/esm-node/cli.mjs

@@ -1,34 +1,14 @@
 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 { normalizeOutputPath } 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 { createCompressConfig } from "./cli/compress.mjs";
+import { createBffGenerator } from "./cli/generator.mjs";
+import { getPrimaryPrefix } from "./cli/prefix.mjs";
+import { isWatchableBffFile } from "./cli/watch.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_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)=>{
@@ -40,106 +20,14 @@ const bffPlugin = ()=>({
                     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 { compileApi, handleCrossProjectInvocation } = createBffGenerator(api);
             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 prefix = api.getConfig()?.bff?.prefix;
                 const compress = createCompressConfig(devServer, prefix);
                 return {
                     tools: {
@@ -244,6 +132,4 @@ const bffPlugin = ()=>({
             });
         }
     });
-const cli = bffPlugin;
-export default cli;
 export { bffPlugin };