@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/cjs/runtime/effect-client/request-context.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyRequestContext: ()=>applyRequestContext,
+    createEffectRequestContext: ()=>createEffectRequestContext
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request) || !(0, external_guards_js_namespaceObject.isRecord)(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = (0, external_guards_js_namespaceObject.isRecord)(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...(0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+exports.applyRequestContext = __webpack_exports__.applyRequestContext;
+exports.createEffectRequestContext = __webpack_exports__.createEffectRequestContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRequestContext",
+    "createEffectRequestContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect-client/request.js

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeRequest: ()=>normalizeRequest
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request)) return {};
+    const payload = {
+        ...request
+    };
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.path) && !(0, external_guards_js_namespaceObject.isRecord)(payload.params)) payload.params = request.path;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.urlParams) && !(0, external_guards_js_namespaceObject.isRecord)(payload.query)) payload.query = request.urlParams;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.headers) && !(0, external_guards_js_namespaceObject.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 ((0, external_guards_js_namespaceObject.isRecord)(request.payload)) payload.query = (0, external_guards_js_namespaceObject.isRecord)(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!(0, external_guards_js_namespaceObject.isRecord)(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+exports.normalizeRequest = __webpack_exports__.normalizeRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect-client/runtime.js

@@ -30,189 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createGeneratedEffectClient: ()=>createGeneratedEffectClient
 });
-const index_js_namespaceObject = require("../data-platform/index.js");
-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;
-};
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_request_context_js_namespaceObject = require("./request-context.js");
 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 = (0, index_js_namespaceObject.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 = (0, index_js_namespaceObject.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) || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
-            const headers = isRecord(normalizedRequest.headers) ? {
-                ...normalizedRequest.headers
-            } : {};
-            if (false === dataPlatform.batch) headers[index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER] = 'off';
-            headers[headerName] = (0, index_js_namespaceObject.encodeRequestEnvelopeHeader)(envelope);
-            return {
-                ...normalizedRequest,
-                headers
-            };
-        } catch (error) {
-            if (strictEnvelope) throw error;
-            return normalizedRequest;
-        }
-    };
+    (0, external_batch_js_namespaceObject.configureGeneratedEffectClientRuntime)(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>(0, external_request_context_js_namespaceObject.createEffectRequestContext)(createRequestContextHeaders, requestContext);
     const client = {};
     const operationManifest = {};
     for (const endpoint of manifest.endpoints){
@@ -245,7 +73,13 @@ const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
                 requestId: config.requestId
             } : {}
         });
-        const call = (request = {})=>sender(prepareEffectRequest(endpoint, operation, request));
+        const call = (request = {})=>sender((0, external_envelope_js_namespaceObject.prepareEffectRequest)({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
         client[endpoint.group] ??= {};
         client[endpoint.group][endpoint.endpoint] = call;
         operationManifest[endpoint.group] ??= {};

package/dist/cjs/runtime/effect-client/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/safe-failure.js

@@ -35,6 +35,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];
@@ -47,7 +48,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/cjs/utils/client-generator/files.js

@@ -0,0 +1,152 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    API_DIR: ()=>API_DIR,
+    CLIENT_DIR: ()=>CLIENT_DIR,
+    EXPORT_PREFIX: ()=>EXPORT_PREFIX,
+    GENERATED_RUNTIME_DIRS: ()=>GENERATED_RUNTIME_DIRS,
+    PLUGIN_DIR: ()=>PLUGIN_DIR,
+    RUNTIME_DIR: ()=>RUNTIME_DIR,
+    TYPE_PREFIX: ()=>TYPE_PREFIX,
+    copyFiles: ()=>copyFiles,
+    createFileDetails: ()=>createFileDetails,
+    posixJoin: ()=>posixJoin,
+    readDirectoryFiles: ()=>readDirectoryFiles,
+    toPosixPath: ()=>toPosixPath,
+    writeTargetFile: ()=>writeTargetFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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(external_path_default().join(...args));
+function createFileDetails(options) {
+    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
+    const relativePath = external_path_default().relative(baseDirectory, resourcePath);
+    const parsedPath = external_path_default().parse(relativePath);
+    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+    const absTargetDir = external_path_default().resolve(targetDir);
+    const relativePathFromAppDirectory = external_path_default().relative(appDirectory, external_path_default().dirname(resourcePath));
+    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
+    return {
+        resourcePath,
+        source,
+        targetDir,
+        name: parsedPath.name,
+        absTargetDir,
+        relativeTargetDistDir: `./${typesFilePath}`,
+        exportKey: toPosixPath(external_path_default().join(parsedPath.dir, parsedPath.name))
+    };
+}
+async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
+    const filesList = [];
+    async function readFiles(currentPath) {
+        const entries = await utils_namespaceObject.fs.readdir(currentPath, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if ('_app.ts' === entry.name) continue;
+            const resourcePath = external_path_default().join(currentPath, entry.name);
+            if (entry.isDirectory()) await readFiles(resourcePath);
+            else {
+                const source = await utils_namespaceObject.fs.readFile(resourcePath, 'utf8');
+                filesList.push(createFileDetails({
+                    appDirectory,
+                    baseDirectory: directory,
+                    resourcePath,
+                    source,
+                    relativeDistPath
+                }));
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+async function writeTargetFile(absTargetDir, content) {
+    await utils_namespaceObject.fs.mkdir(external_path_default().dirname(absTargetDir), {
+        recursive: true
+    });
+    await utils_namespaceObject.fs.writeFile(absTargetDir, content);
+}
+async function copyFiles(from, to) {
+    if (await utils_namespaceObject.fs.pathExists(from)) await utils_namespaceObject.fs.copy(toPosixPath(from), toPosixPath(to));
+}
+exports.API_DIR = __webpack_exports__.API_DIR;
+exports.CLIENT_DIR = __webpack_exports__.CLIENT_DIR;
+exports.EXPORT_PREFIX = __webpack_exports__.EXPORT_PREFIX;
+exports.GENERATED_RUNTIME_DIRS = __webpack_exports__.GENERATED_RUNTIME_DIRS;
+exports.PLUGIN_DIR = __webpack_exports__.PLUGIN_DIR;
+exports.RUNTIME_DIR = __webpack_exports__.RUNTIME_DIR;
+exports.TYPE_PREFIX = __webpack_exports__.TYPE_PREFIX;
+exports.copyFiles = __webpack_exports__.copyFiles;
+exports.createFileDetails = __webpack_exports__.createFileDetails;
+exports.posixJoin = __webpack_exports__.posixJoin;
+exports.readDirectoryFiles = __webpack_exports__.readDirectoryFiles;
+exports.toPosixPath = __webpack_exports__.toPosixPath;
+exports.writeTargetFile = __webpack_exports__.writeTargetFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_DIR",
+    "CLIENT_DIR",
+    "EXPORT_PREFIX",
+    "GENERATED_RUNTIME_DIRS",
+    "PLUGIN_DIR",
+    "RUNTIME_DIR",
+    "TYPE_PREFIX",
+    "copyFiles",
+    "createFileDetails",
+    "posixJoin",
+    "readDirectoryFiles",
+    "toPosixPath",
+    "writeTargetFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/client-generator/generate.js

@@ -0,0 +1,138 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    clientGenerator: ()=>clientGenerator,
+    default: ()=>generate
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_effectClientGenerator_js_namespaceObject = require("../effectClientGenerator.js");
+const external_files_js_namespaceObject = require("./files.js");
+const external_package_json_js_namespaceObject = require("./package-json.js");
+const external_write_package_js_namespaceObject = require("./write-package.js");
+async function clientGenerator(draftOptions) {
+    const generatedClientDir = external_path_default().resolve(draftOptions.appDir, draftOptions.relativeDistPath, external_files_js_namespaceObject.CLIENT_DIR);
+    await utils_namespaceObject.fs.remove(generatedClientDir);
+    const requestId = (0, external_package_json_js_namespaceObject.getPackageName)(draftOptions.appDir) || process.env.npm_package_name;
+    const lambdaSourceList = draftOptions.existLambda ? await (0, external_files_js_namespaceObject.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 utils_namespaceObject.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 utils_namespaceObject.logger.warn(warning);
+        const result = await (0, bff_core_namespaceObject.generateClient)(options);
+        return result;
+    };
+    try {
+        for (const source of lambdaSourceList){
+            const code = await getClitentCode(source.resourcePath, source.source);
+            if (code?.value) {
+                await (0, external_files_js_namespaceObject.writeTargetFile)(source.absTargetDir, code.value);
+                await (0, external_files_js_namespaceObject.copyFiles)(source.relativeTargetDistDir, source.targetDir.replace("js", 'd.ts'));
+            }
+        }
+        if ('effect' === draftOptions.bffRuntimeFramework) {
+            const effectEntryFile = (0, external_effectClientGenerator_js_namespaceObject.resolveEffectEntryFile)({
+                appDir: draftOptions.appDir,
+                apiDir: draftOptions.apiDir,
+                effectEntry: draftOptions.effectEntry
+            });
+            if (effectEntryFile) {
+                const effectSource = await utils_namespaceObject.fs.readFile(effectEntryFile, 'utf8');
+                const effectFileDetails = (0, external_files_js_namespaceObject.createFileDetails)({
+                    appDirectory: draftOptions.appDir,
+                    baseDirectory: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    source: effectSource,
+                    relativeDistPath: draftOptions.relativeDistPath
+                });
+                const effectClientArtifacts = await (0, external_effectClientGenerator_js_namespaceObject.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 (0, external_files_js_namespaceObject.writeTargetFile)(effectFileDetails.absTargetDir, effectClientArtifacts.code);
+                    await (0, external_files_js_namespaceObject.writeTargetFile)(external_path_default().resolve(targetTypeFile), effectClientArtifacts.declaration);
+                    generatedSourceList.push(effectFileDetails);
+                }
+            }
+        }
+        utils_namespaceObject.logger.info("Client bundle generate succeed");
+    } catch (error) {
+        utils_namespaceObject.logger.error(`Client bundle generate failed: ${error}`);
+    }
+    if (generatedSourceList.length > 0) await (0, external_write_package_js_namespaceObject.writeClientModuleBoundary)(draftOptions.appDir, draftOptions.relativeDistPath);
+    await (0, external_write_package_js_namespaceObject.setPackage)(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+}
+const generate = clientGenerator;
+exports.clientGenerator = __webpack_exports__.clientGenerator;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clientGenerator",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});