@modern-js/bff-core 1.0.1-beta.0

package/dist/js/node/router/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireHandlerModule = exports.isHandler = exports.getPathFromFilename = exports.getFiles = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getFiles = (lambdaDir, rules) => _utils.globby.sync(rules, {
+  cwd: lambdaDir,
+  gitignore: true
+}).map(file => _path.default.resolve(lambdaDir, file));
+
+exports.getFiles = getFiles;
+
+const getPathFromFilename = (baseDir, filename) => {
+  const relativeName = filename.substring(baseDir.length);
+  const relativePath = relativeName.split('.').slice(0, -1).join('.');
+  const nameSplit = relativePath.split(_path.default.sep).map(item => {
+    if (item.length > 2) {
+      if (item.startsWith('[') && item.endsWith(']')) {
+        return `:${item.substring(1, item.length - 1)}`;
+      }
+    }
+
+    return item;
+  });
+  const name = nameSplit.join('/');
+  const finalName = name.endsWith(_constants.INDEX_SUFFIX) ? name.substring(0, name.length - _constants.INDEX_SUFFIX.length) : name;
+  return clearRouteName(finalName);
+};
+
+exports.getPathFromFilename = getPathFromFilename;
+
+const clearRouteName = routeName => {
+  let finalRouteName = routeName.trim();
+
+  if (!finalRouteName.startsWith('/')) {
+    finalRouteName = `/${finalRouteName}`;
+  }
+
+  if (finalRouteName.length > 1 && finalRouteName.endsWith('/')) {
+    finalRouteName = finalRouteName.substring(0, finalRouteName.length - 1);
+  }
+
+  return finalRouteName;
+};
+
+const isHandler = input => input && typeof input === 'function';
+
+exports.isHandler = isHandler;
+
+const isFunction = input => input && {}.toString.call(input) === '[object Function]';
+
+const requireHandlerModule = modulePath => {
+  const module = require(modulePath);
+
+  if (isFunction(module)) {
+    return {
+      default: module
+    };
+  }
+
+  return module;
+};
+
+exports.requireHandlerModule = requireHandlerModule;

package/dist/js/node/types.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpMethods = exports.TriggerType = exports.OperatorType = exports.HttpMethod = exports.HttpMetadata = void 0;
+let OperatorType;
+exports.OperatorType = OperatorType;
+
+(function (OperatorType) {
+  OperatorType[OperatorType["Trigger"] = 0] = "Trigger";
+  OperatorType[OperatorType["Middleware"] = 1] = "Middleware";
+})(OperatorType || (exports.OperatorType = OperatorType = {}));
+
+let TriggerType;
+exports.TriggerType = TriggerType;
+
+(function (TriggerType) {
+  TriggerType[TriggerType["Http"] = 0] = "Http";
+})(TriggerType || (exports.TriggerType = TriggerType = {}));
+
+let HttpMetadata;
+exports.HttpMetadata = HttpMetadata;
+
+(function (HttpMetadata) {
+  HttpMetadata["Method"] = "METHOD";
+  HttpMetadata["Data"] = "DATA";
+  HttpMetadata["Query"] = "QUERY";
+  HttpMetadata["Params"] = "PARAMS";
+  HttpMetadata["Headers"] = "HEADERS";
+  HttpMetadata["Response"] = "RESPONSE";
+  HttpMetadata["StatusCode"] = "STATUS_CODE";
+  HttpMetadata["Redirect"] = "REDIRECT";
+  HttpMetadata["ResponseHeaders"] = "RESPONSE_HEADERS";
+})(HttpMetadata || (exports.HttpMetadata = HttpMetadata = {}));
+
+let HttpMethod;
+exports.HttpMethod = HttpMethod;
+
+(function (HttpMethod) {
+  HttpMethod["Get"] = "GET";
+  HttpMethod["Post"] = "POST";
+  HttpMethod["Put"] = "PUT";
+  HttpMethod["Delete"] = "DELETE";
+  HttpMethod["Connect"] = "CONNECT";
+  HttpMethod["Trace"] = "TRACE";
+  HttpMethod["Patch"] = "PATCH";
+  HttpMethod["Option"] = "OPTION";
+  HttpMethod["Head"] = "HEAD";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+
+const httpMethods = Object.values(HttpMethod);
+exports.httpMethods = httpMethods;

package/dist/js/node/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateFunction = exports.isWithMetaHandler = exports.getTypeErrorMessage = exports.HANDLER_WITH_META = exports.ERR_INVALID_ARG_TYPE = void 0;
+
+var _util = _interopRequireDefault(require("util"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const HANDLER_WITH_META = 'HANDLER_WITH_SCHEMA'; // export const pick = <T extends Record<string, unknown>, K extends keyof T>(
+//   obj: T,
+//   keys: readonly K[],
+// ) => {
+//   Object.entries(obj).filter(([key]) => {
+//     return (keys as readonly string[]).includes(key);
+//   });
+// };
+// fork from https://github.com/nodejs/node/blob/master/lib/internal/errors.js
+
+exports.HANDLER_WITH_META = HANDLER_WITH_META;
+
+const getTypeErrorMessage = actual => {
+  let msg = '';
+
+  if (actual == null) {
+    msg += `. Received ${actual}`;
+  } else if (typeof actual === 'function' && actual.name) {
+    msg += `. Received function ${actual.name}`;
+  } else if (typeof actual === 'object') {
+    var _actual$constructor;
+
+    if ((_actual$constructor = actual.constructor) !== null && _actual$constructor !== void 0 && _actual$constructor.name) {
+      msg += `. Received an instance of ${actual.constructor.name}`;
+    } else {
+      const inspected = _util.default.inspect(actual, {
+        depth: -1
+      });
+
+      msg += `. Received ${inspected}`;
+    }
+  } else {
+    let inspected = _util.default.inspect(actual, {
+      colors: false
+    });
+
+    if (inspected.length > 25) {
+      inspected = `${inspected.slice(0, 25)}...`;
+    }
+
+    msg += `. Received type ${typeof actual} (${inspected})`;
+  }
+
+  return msg;
+}; // eslint-disable-next-line @typescript-eslint/naming-convention
+
+
+exports.getTypeErrorMessage = getTypeErrorMessage;
+
+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);
+  }
+
+}
+
+exports.ERR_INVALID_ARG_TYPE = ERR_INVALID_ARG_TYPE;
+
+const validateFunction = (maybeFunc, name) => {
+  if (typeof maybeFunc !== 'function') {
+    throw new ERR_INVALID_ARG_TYPE(name, 'function', maybeFunc);
+  }
+
+  return true;
+};
+
+exports.validateFunction = validateFunction;
+
+const isWithMetaHandler = handler => {
+  return typeof handler === 'function' && handler[HANDLER_WITH_META];
+};
+
+exports.isWithMetaHandler = isWithMetaHandler;

package/dist/types/api.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import type { ApiRunner, ArrayToObject, ExtractInputType, Operator, MaybeAsync } from './types';
+export declare function Api<Operators extends Operator<any>[], Res extends MaybeAsync<any>>(...args: [...operators: Operators, handler: (arg: ArrayToObject<ExtractInputType<Operators>>) => Res]): ApiRunner<ExtractInputType<Operators> extends void[] ? void : ArrayToObject<ExtractInputType<Operators>>, Res>;

package/dist/types/client/generate-client.d.ts

@@ -0,0 +1,24 @@
+import { Result } from './result';
+export declare type GenClientResult = Result<string>;
+export declare type GenClientOptions = {
+  resourcePath: string;
+  source: string;
+  apiDir: string;
+  prefix: string;
+  port: number;
+  requestCreator?: string;
+  fetcher?: string;
+  target?: string;
+  requireResolve?: typeof require.resolve;
+};
+export declare const DEFAULT_CLIENT_REQUEST_CREATOR = "@modern-js/create-request";
+export declare const generateClient: ({
+  resourcePath,
+  apiDir,
+  prefix,
+  port,
+  target,
+  requestCreator,
+  fetcher,
+  requireResolve
+}: GenClientOptions) => Promise<GenClientResult>;

package/dist/types/client/index.d.ts

@@ -0,0 +1 @@
+export * from './generate-client';

package/dist/types/client/result.d.ts

@@ -0,0 +1,15 @@
+export declare type Err<T = any> = {
+  kind: 'Err';
+  value: T;
+  isErr: true;
+  isOk: false;
+};
+export declare type Ok<T = any> = {
+  kind: 'Ok';
+  value: T;
+  isErr: false;
+  isOk: true;
+};
+export declare type Result<T = any, E = string> = Err<E> | Ok<T>;
+export declare const Err: <E = string>(value: E) => Err<E>;
+export declare const Ok: <T, E = string>(value: T) => Result<T, E>;

package/dist/types/errors/http.d.ts

@@ -0,0 +1,5 @@
+export declare class HttpError extends Error {
+  status: number;
+  constructor(status: number, message: string);
+}
+export declare class ValidationError extends HttpError {}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { Api } from './api';
+export { HttpError, ValidationError } from './errors/http';
+export * from './router';
+export * from './types';
+export * from './utils';
+export * from './client';
+export * from './operators/http';

package/dist/types/operators/http.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { Operator, HttpMethod, ApiMiddleware } from '../types';
+export declare const createHttpOperator: (method: HttpMethod) => (urlPath: string) => Operator<void>;
+export declare const Get: (urlPath: string) => Operator<void>;
+export declare const Post: (urlPath: string) => Operator<void>;
+export declare const Put: (urlPath: string) => Operator<void>;
+export declare const Delete: (urlPath: string) => Operator<void>;
+export declare const Connect: (urlPath: string) => Operator<void>;
+export declare const Trace: (urlPath: string) => Operator<void>;
+export declare const Patch: (urlPath: string) => Operator<void>;
+export declare const Option: (urlPath: string) => Operator<void>;
+export declare const Head: (urlPath: string) => Operator<void>;
+export declare const Data: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => Operator<{
+  data: T;
+}>;
+export declare const Query: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => Operator<{
+  query: T;
+}>;
+export declare const Params: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => Operator<{
+  params: T;
+}>;
+export declare const Headers: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => Operator<{
+  headers: T;
+}>;
+export declare const HttpCode: (statusCode: number) => Operator<void>;
+export declare const SetHeaders: (headers: Record<string, string>) => Operator<void>;
+export declare const Redirect: (url: string) => Operator<void>;
+export declare const Middleware: (middleware: ApiMiddleware) => Operator<void>;

package/dist/types/router/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const AllHttpMethods: string[];
+export declare enum APIMode {
+  /**
+   * 框架模式
+   */
+  FARMEWORK = "FARMEWORK",
+
+  /**
+   * 函数模式
+   */
+  FUNCTION = "FUNCTION",
+}
+export declare const FRAMEWORK_MODE_LAMBDA_DIR = "lambda";
+export declare const INDEX_SUFFIX = "index";
+export declare const API_DIR = "api";
+export declare const API_FILE_RULES: string[];

package/dist/types/router/index.d.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import 'esbuild-register';
+import { HttpMethod } from '../types';
+import { ApiHandler, APIHandlerInfo } from './types';
+export * from './types';
+export * from './constants';
+export declare class ApiRouter {
+  private apiDir;
+  private lambdaDir;
+  private prefix;
+  private apiFiles;
+  constructor({
+    apiDir,
+    lambdaDir,
+    prefix
+  }: {
+    apiDir: string;
+    lambdaDir?: string;
+    prefix?: string;
+  });
+  /**
+   * 如果用户未传入或传入空串，默认为 /api
+   * 如果传入 /，则 prefix 为 /
+   */
+
+  private initPrefix;
+  private validateAbsolute;
+  private getAPIMode;
+  private createExistChecker;
+  private getLambdaDir;
+  private getModuleInfos;
+  private getModuleInfo;
+  private getHandlerInfos;
+  private getModuleHandlerInfos;
+  private validateValidApifile;
+  private getRoutePath;
+  isApiFile(filename: string): boolean;
+  getSingleModuleHandlers(filename: string): APIHandlerInfo[] | null;
+  getHandlerInfo(filename: string, originFuncName: string, handler: ApiHandler): APIHandlerInfo | null;
+  getSafeRoutePath(filename: string, handler?: ApiHandler): string;
+  getRouteName(filename: string, handler?: ApiHandler): string;
+  getHttpMethod(originHandlerName: string, handler?: ApiHandler): HttpMethod | null;
+  loadApiFiles(): string[];
+  getApiFiles(): string[];
+  getApiHandlers(): APIHandlerInfo[];
+}

package/dist/types/router/types.d.ts

@@ -0,0 +1,17 @@
+import { HttpMethod } from '../types';
+export declare type ModuleInfo = {
+  filename: string;
+  module: HandlerModule;
+};
+declare type Handler = (...args: any) => any | Promise<any>;
+export declare type ApiHandler = Handler;
+export declare type HandlerModule = Record<string, ApiHandler>;
+export declare type APIHandlerInfo = {
+  handler: ApiHandler;
+  name: string;
+  httpMethod: HttpMethod;
+  filename: string;
+  routeName: string;
+  routePath: string;
+};
+export {};

package/dist/types/router/utils.d.ts

@@ -0,0 +1,7 @@
+import { MaybeAsync } from '@modern-js/bff-runtime';
+export declare type NormalHandler = (...args: any[]) => any;
+export declare type Handler<I, O> = (input: I) => MaybeAsync<O>;
+export declare const getFiles: (lambdaDir: string, rules: string | string[]) => string[];
+export declare const getPathFromFilename: (baseDir: string, filename: string) => string;
+export declare const isHandler: (input: any) => input is Handler<any, any>;
+export declare const requireHandlerModule: (modulePath: string) => any;

package/dist/types/types.d.ts

@@ -0,0 +1,54 @@
+import { Merge } from 'type-fest';
+export declare enum OperatorType {
+  Trigger = 0,
+  Middleware = 1,
+}
+export declare enum TriggerType {
+  Http = 0,
+}
+export declare enum HttpMetadata {
+  Method = "METHOD",
+  Data = "DATA",
+  Query = "QUERY",
+  Params = "PARAMS",
+  Headers = "HEADERS",
+  Response = "RESPONSE",
+  StatusCode = "STATUS_CODE",
+  Redirect = "REDIRECT",
+  ResponseHeaders = "RESPONSE_HEADERS",
+}
+export declare enum HttpMethod {
+  Get = "GET",
+  Post = "POST",
+  Put = "PUT",
+  Delete = "DELETE",
+  Connect = "CONNECT",
+  Trace = "TRACE",
+  Patch = "PATCH",
+  Option = "OPTION",
+  Head = "HEAD",
+}
+export declare type InputSchemaMeata = Extract<HttpMetadata, HttpMetadata.Data | HttpMetadata.Query | HttpMetadata.Headers | HttpMetadata.Params>;
+export declare type ValidateFunc = (helper: ExecuteHelper, next: () => Promise<any>) => Promise<any>;
+export declare type ExecuteHelper = {
+  result?: any;
+  readonly inputs: any;
+};
+export declare type MetadataHelper = {
+  setMetadata: <T = any>(key: any, value: T) => void;
+  getMetadata: <T = any>(key: any) => T;
+};
+export declare type Operator<Input> = {
+  name: string;
+  inputType?: Input;
+  metadata?: (helper: MetadataHelper) => void;
+  validate?: ValidateFunc;
+};
+export declare type MaybeAsync<T> = Promise<T> | T;
+export declare type ApiRunner<Input extends object | void | unknown, Output extends MaybeAsync<any>> = (...args: Input extends void ? never : [input: Input]) => Output;
+export declare type NonNullable<T> = Exclude<T, null | undefined>;
+export declare type ExtractInputType<T> = { [key in keyof T]: T[key] extends Operator<any> ? NonNullable<T[key]['inputType']> : void };
+export declare type ArrayToObject<T, R = {}> = T extends [infer First, ...infer Rest] ? First extends PromiseLike<infer PromiseValue> ? PromiseValue : First extends object ? Merge<First, ArrayToObject<Rest, R>> : ArrayToObject<Rest, R> : R;
+export declare type AsyncFunction = (...args: any[]) => Promise<any>;
+export declare const httpMethods: HttpMethod[];
+export declare type ApiMiddleware = (next: () => any | Promise<any>) => any;

package/dist/types/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const HANDLER_WITH_META = "HANDLER_WITH_SCHEMA";
+export declare const getTypeErrorMessage: (actual: unknown) => string;
+export declare class ERR_INVALID_ARG_TYPE extends Error {
+  constructor(funcName: string, expectedType: string, actual: unknown);
+}
+export declare const validateFunction: (maybeFunc: unknown, name: string) => boolean;
+export declare const isWithMetaHandler: (handler: any) => any;

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@modern-js/bff-core",
+  "description": "The meta-framework suite designed from scratch for frontend-focused modern web development.",
+  "homepage": "https://modernjs.dev",
+  "bugs": "https://github.com/modern-js-dev/modern.js/issues",
+  "repository": "modern-js-dev/modern.js",
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "1.0.1-beta.0",
+  "jsnext:source": "./src/index.ts",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/js/node/index.js",
+  "module": "./dist/js/treeshaking/index.js",
+  "jsnext:modern": "./dist/js/modern/index.js",
+  "exports": {
+    ".": {
+      "jsnext:source": "./src/index.ts",
+      "default": "./dist/js/node/index.js"
+    }
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.15.4",
+    "@modern-js/bff-runtime": "^1.2.3",
+    "@modern-js/utils": "^1.7.6",
+    "esbuild": "^0.14.38",
+    "esbuild-register": "^3.3.3",
+    "http-errors": "^2.0.0",
+    "koa-compose": "^4.1.0",
+    "reflect-metadata": "^0.1.13"
+  },
+  "devDependencies": {
+    "@scripts/build": "0.0.0",
+    "@scripts/jest-config": "0.0.0",
+    "@types/jest": "^27",
+    "@types/koa-compose": "^3.2.5",
+    "@types/node": "^14",
+    "jest": "^27",
+    "type-fest": "^2.13.0",
+    "typescript": "^4",
+    "zod": "^3.17.3"
+  },
+  "peerDependencies": {
+    "zod": "^3.17.3"
+  },
+  "modernConfig": {
+    "output": {
+      "packageMode": "node-js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "types": "./dist/types/index.d.ts"
+  },
+  "wireit": {
+    "build": {
+      "command": "modern build",
+      "files": [
+        "src/**/*",
+        "tsconfig.json",
+        "package.json"
+      ],
+      "output": [
+        "dist/**/*"
+      ]
+    },
+    "test": {
+      "command": "jest --passWithNoTests",
+      "files": [
+        "src/**/*",
+        "tsconfig.json",
+        "package.json",
+        "tests/**/*"
+      ],
+      "output": []
+    }
+  },
+  "scripts": {
+    "new": "modern new",
+    "build": "wireit",
+    "test": "wireit"
+  },
+  "readme": "\n<p align=\"center\">\n  <a href=\"https://modernjs.dev\" target=\"blank\"><img src=\"https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png\" width=\"300\" alt=\"Modern.js Logo\" /></a>\n</p>\n<p align=\"center\">\n现代 Web 工程体系\n  <br/>\n  <a href=\"https://modernjs.dev\" target=\"blank\">\n    modernjs.dev\n  </a>\n</p>\n<p align=\"center\">\n  The meta-framework suite designed from scratch for frontend-focused modern web development\n</p>\n\n# Introduction\n\n> The doc site ([modernjs.dev](https://modernjs.dev)) and articles are only available in Chinese for now, we are planning to add English versions soon.\n\n- [Modern.js: Hello, World!](https://zhuanlan.zhihu.com/p/426707646)\n\n## Getting Started\n\n- [Quick Start](https://modernjs.dev/docs/start)\n- [Guides](https://modernjs.dev/docs/guides)\n- [API References](https://modernjs.dev/docs/apis)\n\n## Contributing\n\n- [Contributing Guide](https://github.com/modern-js-dev/modern.js/blob/main/CONTRIBUTING.md)\n"
+}