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

package/dist/esm-node/utils/clientGenerator.mjs

@@ -1,294 +1,3 @@
 import "node:module";
-import { generateClient } from "@modern-js/bff-core";
-import { fs, logger } from "@modern-js/utils";
-import path from "path";
-import { generateEffectClient, resolveEffectEntryFile } from "./effectClientGenerator.mjs";
-const API_DIR = 'api';
-const PLUGIN_DIR = 'plugin';
-const RUNTIME_DIR = 'runtime';
-const CLIENT_DIR = 'client';
-const EXPORT_PREFIX = `./${API_DIR}/`;
-const TYPE_PREFIX = `${API_DIR}/`;
-const GENERATED_RUNTIME_DIRS = [
-    CLIENT_DIR,
-    PLUGIN_DIR,
-    RUNTIME_DIR
-];
-const toPosixPath = (p)=>p.replace(/\\/g, '/');
-const posixJoin = (...args)=>toPosixPath(path.join(...args));
-function getPackageName(appDirectory) {
-    try {
-        const packageJsonPath = path.resolve(appDirectory, './package.json');
-        const packageJson = fs.readJSONSync(packageJsonPath);
-        return packageJson.name;
-    } catch  {
-        return;
-    }
-}
-function createFileDetails(options) {
-    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
-    const relativePath = path.relative(baseDirectory, resourcePath);
-    const parsedPath = path.parse(relativePath);
-    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
-    const absTargetDir = path.resolve(targetDir);
-    const relativePathFromAppDirectory = path.relative(appDirectory, path.dirname(resourcePath));
-    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
-    return {
-        resourcePath,
-        source,
-        targetDir,
-        name: parsedPath.name,
-        absTargetDir,
-        relativeTargetDistDir: `./${typesFilePath}`,
-        exportKey: toPosixPath(path.join(parsedPath.dir, parsedPath.name))
-    };
-}
-async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
-    const filesList = [];
-    async function readFiles(currentPath) {
-        const entries = await fs.readdir(currentPath, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            if ('_app.ts' === entry.name) continue;
-            const resourcePath = path.join(currentPath, entry.name);
-            if (entry.isDirectory()) await readFiles(resourcePath);
-            else {
-                const source = await fs.readFile(resourcePath, 'utf8');
-                filesList.push(createFileDetails({
-                    appDirectory,
-                    baseDirectory: directory,
-                    resourcePath,
-                    source,
-                    relativeDistPath
-                }));
-            }
-        }
-    }
-    await readFiles(directory);
-    return filesList;
-}
-function mergePackageJson(packageJson, files, typesVersion, exports, relativeDistPath) {
-    const distPrefix = toPosixPath(`./${relativeDistPath}/`);
-    const generatedPrefixes = GENERATED_RUNTIME_DIRS.map((dir)=>toPosixPath(`${distPrefix}${dir}/`));
-    const isManagedExportEntry = (value)=>{
-        if (!value) return false;
-        const values = [
-            value.import,
-            value.require,
-            value.types
-        ].filter(Boolean);
-        return values.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
-    };
-    const isManagedTypeEntry = (value)=>Array.isArray(value) && value.length > 0 && value.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
-    const normalizedFiles = [
-        ...new Set(files.map((file)=>toPosixPath(file)))
-    ];
-    const currentFiles = packageJson.files || [];
-    packageJson.files = [
-        ...new Set([
-            ...currentFiles.map((file)=>toPosixPath(file)),
-            ...normalizedFiles
-        ])
-    ];
-    packageJson.typesVersions ??= {};
-    const typesVersions = packageJson.typesVersions;
-    const starTypes = typesVersions['*'] || {};
-    const generatedTypeEntries = typesVersion['*'] || {};
-    const generatedTypeKeys = new Set(Object.keys(generatedTypeEntries));
-    const typeConflicts = Object.entries(starTypes).filter(([key, value])=>{
-        if (!generatedTypeKeys.has(key) && !key.startsWith(TYPE_PREFIX)) return false;
-        const generatedValue = generatedTypeEntries[key];
-        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedTypeEntry(value);
-        return !isManagedTypeEntry(value);
-    }).map(([key])=>key);
-    if (typeConflicts.length > 0) throw new Error(`[plugin-bff] package.json typesVersions conflict on keys: ${typeConflicts.sort().join(', ')}. Rename these keys or move them outside "${TYPE_PREFIX}" namespace.`);
-    Object.keys(starTypes).forEach((key)=>{
-        if (generatedTypeKeys.has(key) || key.startsWith(TYPE_PREFIX)) delete starTypes[key];
-    });
-    typesVersions['*'] = {
-        ...starTypes,
-        ...generatedTypeEntries
-    };
-    packageJson.exports ??= {};
-    const packageExports = packageJson.exports;
-    const generatedExportKeys = new Set(Object.keys(exports));
-    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
-        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
-        const generatedValue = exports[key];
-        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedExportEntry(value);
-        return !isManagedExportEntry(value);
-    }).map(([key])=>key);
-    if (exportConflicts.length > 0) throw new Error(`[plugin-bff] package.json exports conflict on keys: ${exportConflicts.sort().join(', ')}. Rename these exports or move them outside "${EXPORT_PREFIX}" namespace.`);
-    Object.keys(packageExports).forEach((key)=>{
-        if (generatedExportKeys.has(key) || key.startsWith(EXPORT_PREFIX)) delete packageExports[key];
-    });
-    Object.assign(packageExports, exports);
-}
-async function writeTargetFile(absTargetDir, content) {
-    await fs.mkdir(path.dirname(absTargetDir), {
-        recursive: true
-    });
-    await fs.writeFile(absTargetDir, content);
-}
-function getClientPackageName(appDirectory) {
-    const packageName = getPackageName(appDirectory) || path.basename(appDirectory);
-    if (packageName.startsWith('@') && packageName.includes('/')) {
-        const [scope, name] = packageName.split('/');
-        return `${scope}/${name}-bff-client`;
-    }
-    return `${packageName}-bff-client`;
-}
-async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
-    await writeTargetFile(path.resolve(appDirectory, relativeDistPath, CLIENT_DIR, 'package.json'), `${JSON.stringify({
-        private: true,
-        name: getClientPackageName(appDirectory),
-        type: 'module'
-    }, null, 2)}\n`);
-}
-async function setPackage(files, appDirectory, relativeDistPath) {
-    const packagePath = path.resolve(appDirectory, './package.json');
-    const packageContent = await fs.readFile(packagePath, 'utf8');
-    const packageJson = JSON.parse(packageContent);
-    const sortedFiles = [
-        ...files
-    ].sort((a, b)=>a.exportKey.localeCompare(b.exportKey));
-    const addFiles = [
-        posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
-        posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
-        posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
-    ];
-    const typesVersions = {
-        '*': sortedFiles.reduce((acc, file)=>{
-            const typeFilePath = toPosixPath(`./${file.targetDir}`).replace(/\.js$/, '.d.ts');
-            return {
-                ...acc,
-                [toPosixPath(`${TYPE_PREFIX}${file.exportKey}`)]: [
-                    typeFilePath
-                ]
-            };
-        }, {
-            [`${API_DIR}/*`]: [
-                toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
-            ],
-            [RUNTIME_DIR]: [
-                toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
-            ],
-            [PLUGIN_DIR]: [
-                toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
-            ]
-        })
-    };
-    const exports = sortedFiles.reduce((acc, file)=>{
-        const exportKey = `${EXPORT_PREFIX}${file.exportKey}`;
-        const jsFilePath = toPosixPath(`./${file.targetDir}`);
-        return {
-            ...acc,
-            [toPosixPath(exportKey)]: {
-                import: jsFilePath,
-                types: toPosixPath(jsFilePath.replace(/\.js$/, '.d.ts'))
-            }
-        };
-    }, {
-        [toPosixPath(`./${API_DIR}/*`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.js`),
-            types: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
-        },
-        [toPosixPath(`./${PLUGIN_DIR}`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
-            require: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
-            types: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
-        },
-        [toPosixPath(`./${RUNTIME_DIR}`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
-            require: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
-            types: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
-        }
-    });
-    mergePackageJson(packageJson, addFiles, typesVersions, exports, relativeDistPath);
-    await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
-}
-async function copyFiles(from, to) {
-    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
-}
-async function clientGenerator(draftOptions) {
-    const generatedClientDir = path.resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
-    await fs.remove(generatedClientDir);
-    const requestId = getPackageName(draftOptions.appDir) || process.env.npm_package_name;
-    const lambdaSourceList = draftOptions.existLambda ? await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath) : [];
-    const generatedSourceList = [
-        ...lambdaSourceList
-    ];
-    const getClitentCode = async (resourcePath, source)=>{
-        const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
-        if (!draftOptions.existLambda) return void logger.warn(warning);
-        const options = {
-            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-            appDir: draftOptions.appDir,
-            apiDir: draftOptions.apiDir,
-            lambdaDir: draftOptions.lambdaDir,
-            port: Number(draftOptions.port),
-            source,
-            resourcePath,
-            target: 'bundle',
-            httpMethodDecider: draftOptions.httpMethodDecider,
-            requestCreator: draftOptions.requestCreator,
-            requestId
-        };
-        const { lambdaDir } = draftOptions;
-        if (!resourcePath.startsWith(lambdaDir)) return void logger.warn(warning);
-        const result = await generateClient(options);
-        return result;
-    };
-    try {
-        for (const source of lambdaSourceList){
-            const code = await getClitentCode(source.resourcePath, source.source);
-            if (code?.value) {
-                await writeTargetFile(source.absTargetDir, code.value);
-                await copyFiles(source.relativeTargetDistDir, source.targetDir.replace("js", 'd.ts'));
-            }
-        }
-        if ('effect' === draftOptions.bffRuntimeFramework) {
-            const effectEntryFile = resolveEffectEntryFile({
-                appDir: draftOptions.appDir,
-                apiDir: draftOptions.apiDir,
-                effectEntry: draftOptions.effectEntry
-            });
-            if (effectEntryFile) {
-                const effectSource = await fs.readFile(effectEntryFile, 'utf8');
-                const effectFileDetails = createFileDetails({
-                    appDirectory: draftOptions.appDir,
-                    baseDirectory: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    source: effectSource,
-                    relativeDistPath: draftOptions.relativeDistPath
-                });
-                const effectClientArtifacts = await generateEffectClient({
-                    appDir: draftOptions.appDir,
-                    apiDir: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-                    port: Number(draftOptions.port),
-                    target: 'bundle',
-                    requestCreator: draftOptions.requestCreator,
-                    httpMethodDecider: draftOptions.httpMethodDecider,
-                    dataPlatformBatch: draftOptions.effectDataPlatformBatch
-                });
-                if (effectClientArtifacts) {
-                    const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
-                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientArtifacts.code);
-                    await writeTargetFile(path.resolve(targetTypeFile), effectClientArtifacts.declaration);
-                    generatedSourceList.push(effectFileDetails);
-                }
-            }
-        }
-        logger.info("Client bundle generate succeed");
-    } catch (error) {
-        logger.error(`Client bundle generate failed: ${error}`);
-    }
-    if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
-    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
-}
-const utils_clientGenerator = clientGenerator;
-export default utils_clientGenerator;
-export { copyFiles, readDirectoryFiles };
+export * from "./client-generator/index.mjs";
+export { default } from "./client-generator/index.mjs";

package/dist/esm-node/utils/effect-client-generator/generator.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+import { collectEffectEndpoints } from "../../runtime/effect/endpoint-contracts.mjs";
+import { renderEffectClientCode, renderEffectClientDeclaration } from "./rendering.mjs";
+import { getHttpApiRuntime, loadEffectApi } from "./runtime.mjs";
+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;
+}
+export { generateEffectClient, generateEffectClientCode };

package/dist/esm-node/utils/effect-client-generator/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { generateEffectClient, generateEffectClientCode } from "./generator.mjs";
+export { resolveEffectEntryFile } from "./paths.mjs";
+export { renderEffectClientDeclaration } from "./rendering.mjs";

package/dist/esm-node/utils/effect-client-generator/paths.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+import { findExists, fs } from "@modern-js/utils";
+import path from "path";
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+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 { resolveEffectEntryFile };

package/dist/esm-node/utils/effect-client-generator/rendering.mjs

@@ -0,0 +1,181 @@
+import "node:module";
+import { deriveOperationVersion } from "@modern-js/bff-core";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { createEffectEndpointContractHash, ensureLeadingSlash, normalizeEffectPrefix } from "../../runtime/effect/endpoint-contracts.mjs";
+const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
+const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
+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 {};
+    }
+}
+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;
+`;
+}
+export { renderEffectClientCode, renderEffectClientDeclaration };

package/dist/esm-node/utils/effect-client-generator/runtime.mjs

@@ -0,0 +1,35 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { compatibleRequire } from "@modern-js/utils";
+import path from "path";
+import { extractHttpApiFromModule } from "../../runtime/effect/endpoint-contracts.mjs";
+let httpApiRuntimePromise;
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+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);
+}
+export { getHttpApiRuntime, loadEffectApi };

package/dist/esm-node/utils/effect-client-generator/types.mjs

@@ -0,0 +1 @@
+import "node:module";