@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

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

@@ -1,179 +0,0 @@
-import { deriveOperationVersion } from "@modern-js/bff-core";
-import { fs, upath } from "@modern-js/utils";
-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 = void 0 === endpoint || '' === endpoint ? '/_data/batch' : endpoint;
-    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 = upath.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 = void 0 === packageName || '' === packageName ? 'unknown-app' : packageName;
-    const requestId = 'bundle' === options.target ? void 0 !== packageName && '' !== packageName ? packageName : void 0 : void 0;
-    const normalizedRequestId = void 0 === requestId || '' === requestId ? 'default' : requestId;
-    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,
-        ...void 0 !== requestId && '' !== 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 !== void 0 && 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/utils/effect-client-generator/runtime.mjs

@@ -1,27 +0,0 @@
-import { compatibleRequire, upath } from "@modern-js/utils";
-import { extractHttpApiFromModule } from "../../runtime/effect/endpoint-contracts.mjs";
-import { loadEffectSourceModule } from "../effectSourceLoader.mjs";
-let httpApiRuntimePromise;
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function isHttpApiRuntime(value) {
-    return isRecord(value) && 'function' == typeof value.isHttpApi && 'function' == typeof value.reflect;
-}
-function getHttpApiRuntime() {
-    if (void 0 === httpApiRuntimePromise) httpApiRuntimePromise = 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 = upath.join(upath.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-        return compatibleRequire(effectHttpApiRuntimePath, false);
-    }).then((mod)=>{
-        if (isRecord(mod) && isHttpApiRuntime(mod.HttpApi)) return mod.HttpApi;
-        throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
-    });
-    return httpApiRuntimePromise;
-}
-function loadEffectApi(options) {
-    return getHttpApiRuntime().then((httpApiRuntime)=>loadEffectSourceModule(options).then((mod)=>extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi)));
-}
-export { getHttpApiRuntime, loadEffectApi };

package/dist/esm/utils/effectClientGenerator.mjs

@@ -1 +0,0 @@
-export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile } from "./effect-client-generator/index.mjs";

package/dist/esm/utils/effectSourceLoader.mjs

@@ -1,256 +0,0 @@
-import node_crypto from "node:crypto";
-import node_fs from "node:fs";
-import { builtinModules, createRequire } from "node:module";
-import node_path from "node:path";
-import { pathToFileURL } from "node:url";
-import { build, transform } from "esbuild";
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-const SOURCE_LOADERS = new Map([
-    [
-        '.js',
-        'js'
-    ],
-    [
-        '.jsx',
-        'jsx'
-    ],
-    [
-        '.mjs',
-        'js'
-    ],
-    [
-        '.cjs',
-        'js'
-    ],
-    [
-        '.ts',
-        'ts'
-    ],
-    [
-        '.tsx',
-        'tsx'
-    ],
-    [
-        '.mts',
-        'ts'
-    ],
-    [
-        '.cts',
-        'ts'
-    ]
-]);
-function sourceLoader(args) {
-    return SOURCE_LOADERS.get(node_path.extname(args.path).toLowerCase());
-}
-function preserveSourceModuleSemantics() {
-    return {
-        name: 'modern-js-effect-source-semantics',
-        setup (buildApi) {
-            buildApi.onLoad({
-                filter: /\.[cm]?[jt]sx?$/
-            }, async (args)=>{
-                const loader = sourceLoader(args);
-                if (!loader) return;
-                const source = await node_fs.promises.readFile(args.path, 'utf8');
-                const compiled = await transform(source, {
-                    define: {
-                        'import.meta.url': JSON.stringify(pathToFileURL(args.path).href)
-                    },
-                    jsx: 'automatic',
-                    loader,
-                    sourcefile: args.path,
-                    target: 'node20'
-                });
-                return {
-                    contents: compiled.code,
-                    loader: 'js',
-                    resolveDir: node_path.dirname(args.path)
-                };
-            });
-        }
-    };
-}
-const nodeBuiltins = new Set([
-    ...builtinModules,
-    ...builtinModules.map((name)=>`node:${name}`)
-]);
-const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
-async function isEsmOnlyFile(filename) {
-    const extension = node_path.extname(filename).toLowerCase();
-    if ('.mjs' === extension || '.mts' === extension) return true;
-    if ('.cjs' === extension || '.cts' === extension) return false;
-    let directory = node_path.dirname(filename);
-    while(true){
-        const packagePath = node_path.join(directory, 'package.json');
-        try {
-            const packageJson = JSON.parse(await node_fs.promises.readFile(packagePath, 'utf8'));
-            return 'module' === packageJson.type;
-        } catch (error) {
-            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
-        }
-        const parent = node_path.dirname(directory);
-        if (parent === directory) return false;
-        directory = parent;
-    }
-}
-function isBareSpecifier(specifier) {
-    return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
-}
-function externalizeInstalledDependencies(options) {
-    const runtimeRequire = createRequire(node_path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
-    return {
-        name: 'modern-js-effect-installed-dependencies',
-        setup (buildApi) {
-            buildApi.onResolve({
-                filter: /.*/
-            }, async (args)=>{
-                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
-                    external: true,
-                    path: args.path
-                } : void 0;
-                const resolution = await buildApi.resolve(args.path, {
-                    importer: args.importer,
-                    kind: args.kind,
-                    namespace: args.namespace,
-                    pluginData: {
-                        ...args.pluginData,
-                        [dependencyResolutionMarker]: true
-                    },
-                    resolveDir: args.resolveDir
-                });
-                if (resolution.errors.length > 0) return {
-                    external: true,
-                    path: args.path
-                };
-                if (resolution.external || !resolution.path) return {
-                    external: true,
-                    path: args.path
-                };
-                const realPath = await node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) {
-                    const runtimeResolution = await buildApi.resolve(args.path, {
-                        importer: '',
-                        kind: args.kind,
-                        namespace: 'file',
-                        pluginData: {
-                            [dependencyResolutionMarker]: true
-                        },
-                        resolveDir: options.runtimeResolveDir
-                    });
-                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
-                        if ('cjs' === options.format) {
-                            let requiredPath;
-                            try {
-                                requiredPath = runtimeRequire.resolve(args.path);
-                            } catch  {
-                                requiredPath = runtimeResolution.path;
-                            }
-                            if (await isEsmOnlyFile(requiredPath)) return {
-                                namespace: resolution.namespace,
-                                path: resolution.path,
-                                pluginData: resolution.pluginData,
-                                sideEffects: resolution.sideEffects,
-                                suffix: resolution.suffix,
-                                warnings: resolution.warnings
-                            };
-                        }
-                        return {
-                            external: true,
-                            path: args.path
-                        };
-                    }
-                }
-                return {
-                    namespace: resolution.namespace,
-                    path: resolution.path,
-                    pluginData: resolution.pluginData,
-                    sideEffects: resolution.sideEffects,
-                    suffix: resolution.suffix,
-                    warnings: resolution.warnings
-                };
-            });
-        }
-    };
-}
-async function bundleEffectEntryForNode(options) {
-    await build({
-        absWorkingDir: options.appDir,
-        allowOverwrite: true,
-        bundle: true,
-        entryPoints: [
-            options.entryPath
-        ],
-        format: options.format,
-        logLevel: 'silent',
-        outfile: options.entryPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: options.format,
-                runtimeResolveDir: options.appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        target: 'node20'
-    });
-}
-function isWatchableInput(filename) {
-    return !filename.includes(`${node_path.sep}node_modules${node_path.sep}`) && (SOURCE_LOADERS.has(node_path.extname(filename).toLowerCase()) || '.json' === node_path.extname(filename).toLowerCase());
-}
-function normalizeImportedModule(module) {
-    if (!module || 'object' != typeof module) return module;
-    const namespace = module;
-    const commonJsModule = namespace.default;
-    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
-    return module;
-}
-async function loadEffectBuiltModule(resourcePath) {
-    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
-    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
-    return normalizeImportedModule(await dynamicImport(pathToFileURL(canonicalPath).href));
-}
-async function loadEffectSourceModule(options) {
-    const resourcePath = node_path.resolve(options.resourcePath);
-    const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
-    const tsconfigPath = node_path.join(appDir, 'tsconfig.json');
-    const cacheDirectory = node_path.join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
-    const outputName = node_crypto.createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
-    const outputPath = node_path.join(cacheDirectory, `${outputName}.mjs`);
-    await node_fs.promises.mkdir(cacheDirectory, {
-        recursive: true
-    });
-    const result = await build({
-        absWorkingDir: appDir,
-        banner: {
-            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`
-        },
-        bundle: true,
-        entryPoints: [
-            resourcePath
-        ],
-        format: 'esm',
-        jsx: 'automatic',
-        logLevel: 'silent',
-        metafile: true,
-        outfile: outputPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: 'esm',
-                runtimeResolveDir: appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        sourcemap: 'inline',
-        target: 'node20',
-        tsconfig: node_fs.existsSync(tsconfigPath) ? tsconfigPath : void 0
-    });
-    for (const input of Object.keys(result.metafile.inputs)){
-        const dependency = node_path.isAbsolute(input) ? node_path.normalize(input) : node_path.resolve(appDir, input);
-        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
-    }
-    const output = await node_fs.promises.readFile(outputPath);
-    const revision = node_crypto.createHash('sha256').update(output).digest('hex');
-    return normalizeImportedModule(await dynamicImport(`${pathToFileURL(outputPath).href}?v=${revision}`));
-}
-export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

package/dist/esm/utils/headers.mjs

@@ -1,8 +0,0 @@
-function toHeaderRecord(headers) {
-    const record = {};
-    headers.forEach((value, key)=>{
-        record[key] = value;
-    });
-    return record;
-}
-export { toHeaderRecord };