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

package/dist/esm-node/runtime/effect-client/index.mjs

@@ -5,6 +5,7 @@ import * as __rspack_external_effect_Layer_16f7a8fc from "effect/Layer";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
 import * as __rspack_external_effect_Schema_f8472650 from "effect/Schema";
 import * as __rspack_external_effect_unstable_http_HttpClientError_b9ead235 from "effect/unstable/http/HttpClientError";
 import * as __rspack_external_effect_Data_7c33fca9 from "effect/Data";
@@ -21,7 +22,10 @@ function applySelection(value, selection) {
     if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
     if (!isRecord(value) || !isRecord(selection)) return value;
     const masked = {};
-    for (const key of Object.keys(selection))if (key in value) masked[key] = applySelection(value[key], selection[key]);
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value) masked[key] = applySelection(value[key], selected);
+    }
     return masked;
 }
 function view() {
@@ -35,20 +39,6 @@ function runEffectView(request, selection) {
         request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
     });
 }
-function getRpcSerializationLayer(serialization) {
-    switch(serialization){
-        case 'ndjson':
-            return RpcSerialization.layerNdjson;
-        case 'jsonRpc':
-            return RpcSerialization.layerJsonRpc();
-        case 'ndJsonRpc':
-            return RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return RpcSerialization.layerMsgPack;
-        default:
-            return RpcSerialization.layerJsonRpc();
-    }
-}
 function makeEffectHttpApiClient(api, options) {
     const requestContextHeaders = createRequestContextHeaders(options?.requestContext);
     const transformClient = (client)=>{

package/dist/esm-node/runtime/effect-client/request-context.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!isRecord(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+export { applyRequestContext, createEffectRequestContext };

package/dist/esm-node/runtime/effect-client/request.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!isRecord(request)) return {};
+    const payload = {
+        ...request
+    };
+    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
+    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
+    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!isRecord(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+export { normalizeRequest };

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

@@ -1,187 +1,15 @@
 import "node:module";
-import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, createDataBatchTransport, createRequestEnvelope, encodeRequestEnvelopeHeader } from "../data-platform/index.mjs";
-const METHODS_WITHOUT_BODY = new Set([
-    'GET',
-    'DELETE',
-    'HEAD',
-    'OPTIONS'
-]);
-const DATA_REQUEST_MODES = new Set([
-    'cache-first',
-    'stale-while-revalidate',
-    'network-only'
-]);
-const DATA_MUTATION_MODES = new Set([
-    'optimistic',
-    'pessimistic',
-    'fire-and-forget'
-]);
-const isRecord = (value)=>'object' == typeof value && null !== value;
-const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
-const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
-const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
-const normalizeOrigin = (value)=>{
-    if ('string' != typeof value || 0 === value.length) return;
-    try {
-        return new URL(value).origin;
-    } catch  {
-        return;
-    }
-};
-const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-const resolveOrigin = (defaultOrigin)=>{
-    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
-    const globalLocation = globalThis?.location;
-    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
-    return defaultOrigin;
-};
-const normalizeRequest = (method, request)=>{
-    if (!isRecord(request)) return {};
-    const payload = {
-        ...request
-    };
-    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
-    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
-    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
-    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
-    else if (METHODS_WITHOUT_BODY.has(method)) {
-        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
-            ...payload.query,
-            ...request.payload
-        } : request.payload;
-        else if (!('body' in payload)) payload.body = request.payload;
-    } else if (!isRecord(request.payload) || 'data' in payload) {
-        if (!('body' in payload)) payload.body = request.payload;
-    } else payload.data = request.payload;
-    return payload;
-};
-const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
-    const explicitTargetOrigin = stringOrUndefined(dataPlatform.targetOrigin) || stringOrUndefined(dataPlatform.endpointOrigin);
-    if (explicitTargetOrigin) return explicitTargetOrigin;
-    return defaultOrigin;
-};
-const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
-    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
-    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
-    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
-    if (!currentOrigin || !targetOrigin) return true;
-    return currentOrigin === targetOrigin;
-};
-const toEnvelopeInput = (normalizedRequest)=>{
-    const payload = {};
-    if (isRecord(normalizedRequest.params)) payload.path = normalizedRequest.params;
-    if (isRecord(normalizedRequest.query)) payload.query = normalizedRequest.query;
-    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
-    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
-    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
-            key,
-            String(value)
-        ]);
-    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
-    return payload;
-};
+import { configureGeneratedEffectClientRuntime } from "./batch.mjs";
+import { prepareEffectRequest } from "./envelope.mjs";
+import { createEffectRequestContext as external_request_context_mjs_createEffectRequestContext } from "./request-context.mjs";
 const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
     const createRequest = requestRuntime.createRequest;
     const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
     const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
-    const defaultOrigin = config.defaultOrigin;
     const httpMethodDecider = config.httpMethodDecider || 'functionName';
     const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
-    if (config.requestId && configureRequest) {
-        const configurePayload = {
-            requestId: config.requestId,
-            requireEnvelope: true,
-            identityBinding: {
-                enabled: true,
-                strict: true
-            },
-            operationContract: {
-                enabled: true,
-                strict: true,
-                requireSchemaHash: true,
-                requireOperationVersion: true
-            },
-            setDomain: ()=>resolveOrigin(defaultOrigin)
-        };
-        const runtimeFetch = resolveRuntimeFetch();
-        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = createDataBatchTransport({
-            fetch: runtimeFetch,
-            endpoint: config.batch.endpoint,
-            flushIntervalMs: config.batch.flushIntervalMs,
-            maxBatchSize: config.batch.maxBatchSize,
-            maxBatchBytes: config.batch.maxBatchBytes,
-            requestTimeoutMs: config.batch.requestTimeoutMs,
-            allowedMethods: config.batch.allowedMethods
-        });
-        configureRequest(configurePayload);
-    }
-    const createEffectRequestContext = (requestContext)=>{
-        if (!isRecord(requestContext)) return {};
-        const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
-        return {
-            ...requestContext,
-            headers
-        };
-    };
-    const applyRequestContext = (normalizedRequest, request)=>{
-        if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
-        const requestContext = createEffectRequestContext(request.requestContext);
-        const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
-        if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
-        return {
-            ...normalizedRequest,
-            headers: {
-                ...requestHeaders,
-                ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}
-            }
-        };
-    };
-    const prepareEffectRequest = (endpoint, operation, request)=>{
-        const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request);
-        const dataPlatform = isRecord(request) && isRecord(request.dataPlatform) ? request.dataPlatform : {};
-        const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
-        if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
-        try {
-            const namespace = stringOrUndefined(dataPlatform.appNamespace) || config.appNamespace;
-            const origin = stringOrUndefined(dataPlatform.origin) || resolveOrigin(defaultOrigin);
-            const envelope = createRequestEnvelope({
-                operation: {
-                    ...operation,
-                    appNamespace: namespace
-                },
-                scope: {
-                    appNamespace: namespace,
-                    origin,
-                    tenantId: stringOrUndefined(dataPlatform.tenantId),
-                    userId: stringOrUndefined(dataPlatform.userId),
-                    sessionId: stringOrUndefined(dataPlatform.sessionId)
-                },
-                requestInput: {
-                    method: endpoint.method,
-                    routePath: endpoint.routePath,
-                    payload: toEnvelopeInput(normalizedRequest)
-                },
-                requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
-                mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
-                selectionPlan: isRecord(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
-                traceContext: isRecord(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
-                requireTraceContext: true === dataPlatform.requireTraceContext
-            });
-            const headerName = stringOrUndefined(dataPlatform.envelopeHeader) || DEFAULT_DATA_ENVELOPE_HEADER;
-            const headers = isRecord(normalizedRequest.headers) ? {
-                ...normalizedRequest.headers
-            } : {};
-            if (false === dataPlatform.batch) headers[DEFAULT_DATA_BATCH_HEADER] = 'off';
-            headers[headerName] = encodeRequestEnvelopeHeader(envelope);
-            return {
-                ...normalizedRequest,
-                headers
-            };
-        } catch (error) {
-            if (strictEnvelope) throw error;
-            return normalizedRequest;
-        }
-    };
+    configureGeneratedEffectClientRuntime(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>external_request_context_mjs_createEffectRequestContext(createRequestContextHeaders, requestContext);
     const client = {};
     const operationManifest = {};
     for (const endpoint of manifest.endpoints){
@@ -214,7 +42,13 @@ const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
                 requestId: config.requestId
             } : {}
         });
-        const call = (request = {})=>sender(prepareEffectRequest(endpoint, operation, request));
+        const call = (request = {})=>sender(prepareEffectRequest({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
         client[endpoint.group] ??= {};
         client[endpoint.group][endpoint.endpoint] = call;
         operationManifest[endpoint.group] ??= {};

package/dist/esm-node/runtime/effect-client/types.mjs

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

package/dist/esm-node/runtime/safe-failure.mjs

@@ -7,6 +7,7 @@ const SAFE_FAILURE_CODES = {
     500: 'INTERNAL_SERVER_ERROR',
     503: 'SERVICE_UNAVAILABLE'
 };
+const INVALID_HTTP_HEADER_VALUE = /[\0-\x08\x0a-\x1f\x7f]/u;
 const readErrorProperty = (error, key)=>{
     if ('object' != typeof error || null === error || !(key in error)) return;
     return error[key];
@@ -19,7 +20,7 @@ const normalizeRetryAfter = (value)=>{
     if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
     if ('string' == typeof value) {
         const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
+        return trimmed.length > 0 && !INVALID_HTTP_HEADER_VALUE.test(trimmed) ? trimmed : void 0;
     }
     if (value instanceof Date) return value.toUTCString();
 };

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

@@ -0,0 +1,69 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+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 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;
+}
+async function writeTargetFile(absTargetDir, content) {
+    await fs.mkdir(path.dirname(absTargetDir), {
+        recursive: true
+    });
+    await fs.writeFile(absTargetDir, content);
+}
+async function copyFiles(from, to) {
+    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
+}
+export { API_DIR, CLIENT_DIR, EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, copyFiles, createFileDetails, posixJoin, readDirectoryFiles, toPosixPath, writeTargetFile };

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

@@ -0,0 +1,89 @@
+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";
+import { CLIENT_DIR, copyFiles, createFileDetails, readDirectoryFiles, writeTargetFile } from "./files.mjs";
+import { getPackageName } from "./package-json.mjs";
+import { setPackage, writeClientModuleBoundary } from "./write-package.mjs";
+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 generate = clientGenerator;
+export default generate;
+export { clientGenerator };

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

@@ -0,0 +1,5 @@
+import "node:module";
+export { copyFiles, createFileDetails, readDirectoryFiles, writeTargetFile } from "./files.mjs";
+export { clientGenerator, default } from "./generate.mjs";
+export { getClientPackageName, getPackageName, mergePackageJson } from "./package-json.mjs";
+export { setPackage, writeClientModuleBoundary } from "./write-package.mjs";

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

@@ -0,0 +1,79 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, TYPE_PREFIX, toPosixPath } from "./files.mjs";
+function getPackageName(appDirectory) {
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = fs.readJSONSync(packageJsonPath);
+        return packageJson.name;
+    } catch  {
+        return;
+    }
+}
+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);
+}
+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`;
+}
+export { getClientPackageName, getPackageName, mergePackageJson };

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

@@ -0,0 +1,75 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { API_DIR, CLIENT_DIR, EXPORT_PREFIX, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, posixJoin, toPosixPath, writeTargetFile } from "./files.mjs";
+import { getClientPackageName, mergePackageJson } from "./package-json.mjs";
+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));
+}
+export { setPackage, writeClientModuleBoundary };