@bleedingdev/modern-js-bff-core 3.2.0-ultramodern.0

package/dist/esm/utils/alias.mjs

@@ -0,0 +1,57 @@
+import fs from "fs";
+import module_0 from "module";
+import * as __rspack_external_os from "os";
+import * as __rspack_external_path from "path";
+const getRelativeRuntimePath = (appDirectory, serverRuntimePath)=>{
+    let relativeRuntimePath = '';
+    relativeRuntimePath = 'win32' === __rspack_external_os.platform() ? `../${__rspack_external_path.relative(appDirectory, serverRuntimePath)}` : __rspack_external_path.join('../', __rspack_external_path.relative(appDirectory, serverRuntimePath));
+    if ('development' === process.env.NODE_ENV || 'test' === process.env.NODE_ENV) relativeRuntimePath = `./${__rspack_external_path.relative(appDirectory, serverRuntimePath)}`;
+    return relativeRuntimePath;
+};
+const sortByLongestPrefix = (arr)=>arr.concat().sort((a, b)=>b.length - a.length);
+const createMatchPath = (paths)=>{
+    const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+    const sortedPaths = {};
+    sortedKeys.forEach((key)=>{
+        sortedPaths[key] = paths[key];
+    });
+    return (request)=>{
+        const found = Object.keys(sortedPaths).find((key)=>request.startsWith(key));
+        if (found) {
+            let foundPaths = sortedPaths[found];
+            if (!Array.isArray(foundPaths)) foundPaths = [
+                foundPaths
+            ];
+            foundPaths = foundPaths.filter((foundPath)=>__rspack_external_path.isAbsolute(foundPath));
+            for (const p of foundPaths){
+                const foundPath = request.replace(found, p);
+                if (fs.existsSync(foundPath)) return foundPath;
+            }
+            return request.replace(found, foundPaths[0]);
+        }
+        return null;
+    };
+};
+const registerPaths = (paths)=>{
+    const originalResolveFilename = module_0._resolveFilename;
+    const { builtinModules } = module_0;
+    const matchPath = createMatchPath(paths);
+    module_0._resolveFilename = function(request, _parent) {
+        const isCoreModule = builtinModules.includes(request);
+        if (!isCoreModule) {
+            const matched = matchPath(request);
+            if (matched) {
+                const modifiedArguments = [
+                    matched,
+                    ...[].slice.call(arguments, 1)
+                ];
+                return originalResolveFilename.apply(this, modifiedArguments);
+            }
+        }
+        return originalResolveFilename.apply(this, arguments);
+    };
+    return ()=>{
+        module_0._resolveFilename = originalResolveFilename;
+    };
+};
+export { createMatchPath, getRelativeRuntimePath, registerPaths };

package/dist/esm/utils/debug.mjs

@@ -0,0 +1,3 @@
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger('bff');
+export { debug };

package/dist/esm/utils/index.mjs

@@ -0,0 +1,5 @@
+export * from "./alias.mjs";
+export * from "./meta.mjs";
+export * from "./storage.mjs";
+export * from "./validate.mjs";
+export { debug } from "./debug.mjs";

package/dist/esm/utils/meta.mjs

@@ -0,0 +1,5 @@
+const HANDLER_WITH_META = 'HANDLER_WITH_META';
+const INPUT_PARAMS_DECIDER = 'INPUT_PARAMS_DECIDER';
+const isWithMetaHandler = (handler)=>'function' == typeof handler && handler[HANDLER_WITH_META];
+const isInputParamsDeciderHandler = (handler)=>'function' == typeof handler && handler[INPUT_PARAMS_DECIDER];
+export { HANDLER_WITH_META, INPUT_PARAMS_DECIDER, isInputParamsDeciderHandler, isWithMetaHandler };

package/dist/esm/utils/storage.mjs

@@ -0,0 +1,30 @@
+import * as __rspack_external_async_hooks from "async_hooks";
+const createStorage = ()=>{
+    let storage;
+    if (void 0 !== __rspack_external_async_hooks.AsyncLocalStorage) storage = new __rspack_external_async_hooks.AsyncLocalStorage();
+    const run = (context, cb)=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        return new Promise((resolve, reject)=>{
+            storage.run(context, ()=>{
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = ()=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        const context = storage.getStore();
+        if (!context) throw new Error("Can't call useContext out of scope, it should be placed in the bff function");
+        return context;
+    };
+    return {
+        run,
+        useContext
+    };
+};
+export { createStorage };

package/dist/esm/utils/validate.mjs

@@ -0,0 +1,32 @@
+import util from "util";
+const getTypeErrorMessage = (actual)=>{
+    let msg = '';
+    if (null == actual) msg += `. Received ${actual}`;
+    else if ('function' == typeof actual && actual.name) msg += `. Received function ${actual.name}`;
+    else if ('object' == typeof actual) if (actual.constructor?.name) msg += `. Received an instance of ${actual.constructor.name}`;
+    else {
+        const inspected = util.inspect(actual, {
+            depth: -1
+        });
+        msg += `. Received ${inspected}`;
+    }
+    else {
+        let inspected = util.inspect(actual, {
+            colors: false
+        });
+        if (inspected.length > 25) inspected = `${inspected.slice(0, 25)}...`;
+        msg += `. Received type ${typeof actual} (${inspected})`;
+    }
+    return msg;
+};
+class ERR_INVALID_ARG_TYPE extends Error {
+    constructor(funcName, expectedType, actual){
+        const message = `[ERR_INVALID_ARG_TYPE]: The '${funcName}' argument must be of type ${expectedType}${getTypeErrorMessage(actual)}`;
+        super(message);
+    }
+}
+const validateFunction = (maybeFunc, name)=>{
+    if ('function' != typeof maybeFunc) throw new ERR_INVALID_ARG_TYPE(name, 'function', maybeFunc);
+    return true;
+};
+export { ERR_INVALID_ARG_TYPE, getTypeErrorMessage, validateFunction };

package/dist/esm-node/api.mjs

@@ -0,0 +1,45 @@
+import "node:module";
+import "reflect-metadata";
+import koa_compose from "koa-compose";
+import { HANDLER_WITH_META, validateFunction } from "./utils/index.mjs";
+function Api(...args) {
+    const handler = args.pop();
+    validateFunction(handler, 'Apihandler');
+    const operators = args;
+    const metadataHelper = {
+        getMetadata (key) {
+            return Reflect.getMetadata(key, runner);
+        },
+        setMetadata (key, value) {
+            return Reflect.defineMetadata(key, value, runner);
+        }
+    };
+    for (const operator of operators)if (operator.metadata) operator.metadata(metadataHelper);
+    const validateHandlers = operators.filter((operator)=>operator.validate).map((operator)=>operator.validate);
+    const pipeHandlers = operators.filter((operator)=>operator.execute).map((operator)=>operator.execute);
+    async function runner(inputs) {
+        const executeHelper = {
+            result: null,
+            get inputs () {
+                return inputs;
+            },
+            set inputs (val){
+                inputs = val;
+            }
+        };
+        const stack = [
+            ...validateHandlers,
+            ...pipeHandlers
+        ];
+        stack.push(async (helper, next)=>{
+            const res = await handler(helper.inputs);
+            helper.result = res;
+            return next();
+        });
+        await koa_compose(stack)(executeHelper);
+        return executeHelper.result;
+    }
+    runner[HANDLER_WITH_META] = true;
+    return runner;
+}
+export { Api };

package/dist/esm-node/client/generateClient.mjs

@@ -0,0 +1,101 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import "path";
+import { ApiRouter } from "../router/index.mjs";
+import { createOperationEntries, createOperationSchemaHash } from "../security/operationContracts.mjs";
+import { Err, Ok } from "./result.mjs";
+const INNER_CLIENT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
+const generateClient = async ({ appDir, resourcePath, apiDir, lambdaDir, prefix, port, target, requestCreator, fetcher, requireResolve = require.resolve, httpMethodDecider, domain, requestId })=>{
+    requestCreator = requestCreator || INNER_CLIENT_REQUEST_CREATOR;
+    const apiRouter = new ApiRouter({
+        appDir,
+        apiDir,
+        lambdaDir,
+        prefix,
+        httpMethodDecider
+    });
+    const handlerInfos = await apiRouter.getSingleModuleHandlers(resourcePath);
+    if (!handlerInfos) return Err(`generate client error: Cannot require module ${resourcePath}`);
+    const operationEntries = createOperationEntries(handlerInfos);
+    const operationVersion = 1;
+    const schemaHash = createOperationSchemaHash(operationEntries, requestId || 'default');
+    let handlersCode = '';
+    for (const handlerInfo of handlerInfos){
+        const { name, httpMethod, routePath, action } = handlerInfo;
+        let exportStatement = `var ${name} =`;
+        if ('default' === name.toLowerCase()) exportStatement = 'default';
+        const upperHttpMethod = httpMethod.toUpperCase();
+        const serializedRouteName = JSON.stringify(routePath);
+        const serializedMethod = JSON.stringify(upperHttpMethod);
+        const serializedMethodDecider = JSON.stringify(httpMethodDecider ? httpMethodDecider : 'functionName');
+        const serializedOperationContext = JSON.stringify({
+            operationId: name,
+            routePath,
+            method: upperHttpMethod,
+            schemaHash,
+            operationVersion
+        });
+        const tailArgs = `, ${fetcher ? 'fetch' : 'undefined'}, ${requestId ? JSON.stringify(requestId) : 'undefined'}, ${serializedOperationContext}`;
+        if ('server' === target) handlersCode += `export ${exportStatement} createRequest(${serializedRouteName}, ${serializedMethod}, process.env.PORT || ${String(port)}, ${serializedMethodDecider}${tailArgs});
+      `;
+        else handlersCode += `export ${exportStatement} createRequest(${serializedRouteName}, ${serializedMethod}, ${String(port)}, ${serializedMethodDecider}${tailArgs});
+      `;
+    }
+    const serializedRequestCreator = JSON.stringify(requestCreator);
+    const serializedFetcher = fetcher ? JSON.stringify(fetcher) : void 0;
+    const importCode = requestId ? `import * as requestRuntime from ${serializedRequestCreator};
+const { createRequest } = requestRuntime;
+${serializedFetcher ? `import { fetch } from ${serializedFetcher};\n` : ''}` : `import { createRequest } from ${serializedRequestCreator};
+${serializedFetcher ? `import { fetch } from ${serializedFetcher};\n` : ''}`;
+    const bootstrapCode = requestId ? `export const initProducerClient = (options = {}) => {
+  const configure = requestRuntime.configure;
+  if (typeof configure !== 'function') {
+    console.warn('[modernjs] Compatibility request creator path does not expose configure(); use default @modern-js/create-request or migrate the compatibility path.');
+    return undefined;
+  }
+  const defaultSecureOptions = {
+    requestId: ${JSON.stringify(requestId)},
+    requireEnvelope: true,
+    identityBinding: {
+      enabled: true,
+      strict: true,
+    },
+    operationContract: {
+      enabled: true,
+      strict: true,
+      requireSchemaHash: true,
+      requireOperationVersion: true,
+    },
+  };
+  return configure({
+    ...defaultSecureOptions,
+    ...options,
+    identityBinding: {
+      ...defaultSecureOptions.identityBinding,
+      ...(options && options.identityBinding ? options.identityBinding : {}),
+    },
+    operationContract: {
+      ...defaultSecureOptions.operationContract,
+      ...(options && options.operationContract ? options.operationContract : {}),
+    },
+  });
+};
+` : '';
+    const manifestCode = `export const operationVersion = ${String(operationVersion)};
+export const operationSchemaHash = '${schemaHash}';
+export const operationManifest = ${JSON.stringify({
+        operationVersion,
+        schemaHash,
+        operations: operationEntries
+    }, null, 2)};
+`;
+    const generatedParts = [
+        importCode.trimEnd(),
+        bootstrapCode.trimEnd(),
+        manifestCode.trimEnd(),
+        handlersCode.trimEnd()
+    ].filter(Boolean);
+    return Ok(`${generatedParts.join('\n\n')}
+`);
+};
+export { INNER_CLIENT_REQUEST_CREATOR, generateClient };

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

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./generateClient.mjs";

package/dist/esm-node/client/result.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+const Err = (value)=>{
+    const err = {
+        kind: 'Err',
+        value,
+        isErr: true,
+        isOk: false
+    };
+    return err;
+};
+const Ok = (value)=>{
+    const ok = {
+        kind: 'Ok',
+        value,
+        isErr: false,
+        isOk: true
+    };
+    return ok;
+};
+export { Err, Ok };

package/dist/esm-node/compatible.mjs

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

package/dist/esm-node/contracts/eventContracts.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+const defineEventContract = (input)=>{
+    const normalizedName = input.name.trim();
+    if (!normalizedName) throw new Error('Event contract name must be non-empty');
+    if (!Number.isFinite(input.version) || input.version <= 0) throw new Error('Event contract version must be a positive number');
+    if (!input.schemaHash || !input.schemaHash.trim()) throw new Error('Event contract schemaHash must be non-empty');
+    return {
+        name: normalizedName,
+        version: Math.floor(input.version),
+        schemaHash: input.schemaHash.trim(),
+        description: input.description
+    };
+};
+const createEventEnvelope = (contract, payload, meta)=>({
+        name: contract.name,
+        version: contract.version,
+        schemaHash: contract.schemaHash,
+        timestamp: Date.now(),
+        payload,
+        ...meta ? {
+            meta
+        } : {}
+    });
+const isEventEnvelope = (value)=>{
+    if (!value || 'object' != typeof value || Array.isArray(value)) return false;
+    const candidate = value;
+    return 'string' == typeof candidate.name && candidate.name.length > 0 && 'number' == typeof candidate.version && candidate.version > 0 && 'string' == typeof candidate.schemaHash && candidate.schemaHash.length > 0 && 'number' == typeof candidate.timestamp && Number.isFinite(candidate.timestamp) && 'payload' in candidate;
+};
+export { createEventEnvelope, defineEventContract, isEventEnvelope };

package/dist/esm-node/errors/http.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+class HttpError extends Error {
+    constructor(status, message){
+        super(message);
+        this.status = status;
+    }
+}
+class ValidationError extends HttpError {
+    constructor(status, message){
+        super(status, message);
+        this.code = 'VALIDATION_ERROR';
+    }
+}
+export { HttpError, ValidationError };

package/dist/esm-node/index.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+export * from "./client/index.mjs";
+export * from "./contracts/eventContracts.mjs";
+export * from "./operators/http.mjs";
+export * from "./router/index.mjs";
+export * from "./security/crossProjectPolicy.mjs";
+export * from "./security/operationContracts.mjs";
+export * from "./types.mjs";
+export { Api } from "./api.mjs";
+export { HttpError, ValidationError } from "./errors/http.mjs";
+export { HANDLER_WITH_META, INPUT_PARAMS_DECIDER, createStorage, getRelativeRuntimePath, isInputParamsDeciderHandler, isWithMetaHandler, registerPaths } from "./utils/index.mjs";

package/dist/esm-node/operators/http.mjs

@@ -0,0 +1,136 @@
+import "node:module";
+import { ValidationError } from "../errors/http.mjs";
+import { HttpMetadata, HttpMethod, OperatorType, ResponseMetaType, TriggerType } from "../types.mjs";
+const validateInput = async (schema, input)=>{
+    try {
+        return await schema.parseAsync(input);
+    } catch (error) {
+        if ('name' in error && 'ZodError' === error.name) throw new ValidationError(400, error.message);
+        throw error;
+    }
+};
+const createHttpOperator = (method)=>(urlPath)=>({
+            name: method,
+            metadata ({ setMetadata }) {
+                setMetadata(OperatorType.Trigger, {
+                    type: TriggerType.Http,
+                    path: urlPath,
+                    method
+                });
+            }
+        });
+const Get = createHttpOperator(HttpMethod.Get);
+const Post = createHttpOperator(HttpMethod.Post);
+const Put = createHttpOperator(HttpMethod.Put);
+const Delete = createHttpOperator(HttpMethod.Delete);
+const Connect = createHttpOperator(HttpMethod.Connect);
+const Trace = createHttpOperator(HttpMethod.Trace);
+const Patch = createHttpOperator(HttpMethod.Patch);
+const Options = createHttpOperator(HttpMethod.Options);
+const Head = createHttpOperator(HttpMethod.Head);
+const Data = (schema)=>({
+        name: HttpMetadata.Data,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Data, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { data } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                data: await validateInput(schema, data)
+            };
+            return next();
+        }
+    });
+const Query = (schema)=>({
+        name: HttpMetadata.Query,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Query, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { query } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                query: await validateInput(schema, query)
+            };
+            return next();
+        }
+    });
+const Params = (schema)=>({
+        name: HttpMetadata.Params,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Params, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { params } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                params: await validateInput(schema, params)
+            };
+            return next();
+        }
+    });
+const Headers = (schema)=>({
+        name: HttpMetadata.Headers,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Headers, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { headers } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                headers: await validateInput(schema, headers)
+            };
+            return next();
+        }
+    });
+const setResponseMeta = (helper, type, value)=>{
+    const responseMetaData = helper.getMetadata(HttpMetadata.Response) || [];
+    helper.setMetadata(HttpMetadata.Response, [
+        ...responseMetaData,
+        {
+            type,
+            value
+        }
+    ]);
+};
+const HttpCode = (statusCode)=>({
+        name: 'HttpCode',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.StatusCode, statusCode);
+        }
+    });
+const SetHeaders = (headers)=>({
+        name: 'SetHeaders',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.Headers, headers);
+        }
+    });
+const Redirect = (url)=>({
+        name: 'Redirect',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.Redirect, url);
+        }
+    });
+const Upload = (urlPath, schema)=>({
+        name: 'Upload',
+        metadata ({ setMetadata }) {
+            setMetadata(OperatorType.Trigger, {
+                type: TriggerType.Http,
+                path: urlPath,
+                method: HttpMethod.Post,
+                action: 'upload'
+            });
+            setMetadata(HttpMetadata.Files, schema);
+        },
+        async validate (helper, next) {
+            if (!schema) return next();
+            const { inputs: { formData: files } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                files: await validateInput(schema, files)
+            };
+            return next();
+        }
+    });
+export { Connect, Data, Delete, Get, Head, Headers, HttpCode, Options, Params, Patch, Post, Put, Query, Redirect, SetHeaders, Trace, Upload, createHttpOperator };

package/dist/esm-node/router/constants.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+import { HttpMethod } from "../types.mjs";
+const AllHttpMethods = Object.values(HttpMethod);
+const FRAMEWORK_MODE_LAMBDA_DIR = 'lambda';
+const FRAMEWORK_MODE_APP_DIR = 'app';
+const INDEX_SUFFIX = 'index';
+const API_DIR = 'api';
+const API_FILE_RULES = [
+    '**/*.[tj]s',
+    '!**/_*',
+    '!**/_*/**/*.[tj]s',
+    '!**/*.test.js',
+    '!**/*.test.ts',
+    '!**/*.d.ts',
+    '!__test__/*.ts',
+    '!__tests__/*.ts',
+    '!node_modules/**',
+    '!bootstrap.jsx'
+];
+export { API_DIR, API_FILE_RULES, AllHttpMethods, FRAMEWORK_MODE_APP_DIR, FRAMEWORK_MODE_LAMBDA_DIR, INDEX_SUFFIX };