@ruiapp/rapid-core 0.0.1

package/src/core/pluginManager.ts

@@ -0,0 +1,143 @@
+import { RpdApplicationConfig } from "~/types";
+import Plugin from "./plugin";
+import * as metaManager from "~/plugins/metaManager/mod";
+import * as dataManager from "~/plugins/dataManager/mod";
+import * as routeManager from "~/plugins/routeManager/mod";
+import * as webhooks from "~/plugins/webhooks/mod";
+import * as authManager from "~/plugins/authManager/mod";
+import { IRpdServer, IRpdServerPlugin } from "./server";
+
+const plugins: IRpdServerPlugin[] = [];
+
+export async function loadPlugins() {
+  plugins.push(metaManager);
+  plugins.push(dataManager);
+  plugins.push(routeManager);
+  plugins.push(webhooks);
+  plugins.push(authManager);
+}
+
+/** 初始化插件时调用。 */
+export async function initPlugins(server: IRpdServer) {
+  for (const plugin of plugins) {
+    const pluginInstance = new Plugin(plugin.code);
+    await plugin.initPlugin(pluginInstance, server);
+  }
+}
+
+/** 注册中间件 */
+export async function registerMiddlewares(server: IRpdServer) {
+  for (const plugin of plugins) {
+    if (plugin.registerMiddlewares) {
+      await plugin.registerMiddlewares(server);
+    }
+  }
+}
+
+/** 注册接口动作处理程序 */
+export async function registerHttpHandlers(server: IRpdServer) {
+  for (const plugin of plugins) {
+    if (plugin.registerHttpHandlers) {
+      await plugin.registerHttpHandlers(server);
+    }
+  }
+}
+
+/** 注册事件处理程序 */
+export async function registerEventHandlers(server: IRpdServer) {
+  for (const plugin of plugins) {
+    if (plugin.registerEventHandlers) {
+      await plugin.registerEventHandlers(server);
+    }
+  }
+}
+
+/** 注册消息处理程序 */
+export async function registerMessageHandlers(server: IRpdServer) {
+  for (const plugin of plugins) {
+    if (plugin.registerMessageHandlers) {
+      await plugin.registerMessageHandlers(server);
+    }
+  }
+}
+
+/** 注册任务处理程序 */
+export async function registerTaskProcessors(server: IRpdServer) {
+  for (const plugin of plugins) {
+    if (plugin.registerTaskProcessors) {
+      await plugin.registerTaskProcessors(server);
+    }
+  }
+}
+
+/** 在加载应用前调用。 */
+export async function onLoadingApplication(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.onLoadingApplication) {
+      await plugin.onLoadingApplication(server, applicationConfig);
+    }
+  }
+}
+
+/** 配置数据模型 */
+export async function configureModels(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.configureModels) {
+      await plugin.configureModels(server, applicationConfig);
+    }
+  }
+}
+
+/** 配置模型属性 */
+export async function configureModelProperties(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.configureModelProperties) {
+      await plugin.configureModelProperties(server, applicationConfig);
+    }
+  }
+}
+
+/** 配置路由 */
+export async function configureRoutes(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.configureRoutes) {
+      await plugin.configureRoutes(server, applicationConfig);
+    }
+  }
+}
+
+/** 在应用配置加载完成后调用。此时插件可以进行一些数据的初始化工作。 */
+export async function onApplicationLoaded(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.onApplicationLoaded) {
+      await plugin.onApplicationLoaded(server, applicationConfig);
+    }
+  }
+}
+
+/** 在应用准备完成后调用。此时服务器已经可以处理网络请求。 */
+export async function onApplicationReady(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  for (const plugin of plugins) {
+    if (plugin.onApplicationReady) {
+      await plugin.onApplicationReady(server, applicationConfig);
+    }
+  }
+}

package/src/core/request.ts

@@ -0,0 +1,23 @@
+export const GlobalRequest = global.Request;
+
+
+export interface RapidRequestBody {
+  type: string;
+  value: any;
+}
+
+export class RapidRequest {
+  method: string;
+  url: URL;
+  hasBody: boolean;
+
+  constructor(init: RequestInit) {
+  }
+
+  body(): RapidRequestBody {
+    return {
+      type: "",
+      value: {}
+    }
+  }
+}

package/src/core/response.ts

@@ -0,0 +1,77 @@
+import { isArray, isObject } from "lodash";
+import { HttpStatus, ResponseData } from "./http-types";
+
+export const GlobalResponse = global.Response;
+
+
+function mergeHeaders(target: Headers, source: HeadersInit) {
+  if (source instanceof Headers) {
+    for (const keyValuePair of source.entries()) {
+      target.set(keyValuePair[0], keyValuePair[1]);
+    }
+  } else if (isArray(source)) {
+    for (const keyValuePair of source) {
+      target.set(keyValuePair[0], keyValuePair[1]);
+    }
+  } else if (isObject(source)) {
+    Object.entries(source).forEach(([key, value]) => target.set(key, value));
+  }
+  return target;
+}
+
+interface NewResponseOptions {
+  body?: ResponseData;
+  status?: HttpStatus;
+  headers?: HeadersInit;
+}
+
+function newResponse(options: NewResponseOptions) {
+  return new Response(options.body, {
+    headers: options.headers,
+    status: options.status || 200,
+  });
+}
+
+export class RapidResponse {
+  #response: Response;
+  status: number;
+  body: BodyInit;
+  headers: Headers;
+
+  constructor(body?: BodyInit, init?: ResponseInit) {
+    this.body = body;
+    this.headers = new Headers(init.headers);
+    this.status = init.status;
+  }
+
+  json(
+    obj: any,
+    status?: HttpStatus,
+    headers?: HeadersInit,
+  ) {
+    const body = JSON.stringify(obj);
+    const responseHeaders = new Headers(this.headers);
+    if (headers) {
+      mergeHeaders(responseHeaders, headers);
+    }
+    this.#response = newResponse({body, status: status || 200, headers: responseHeaders});
+  }
+
+  redirect(location: string, status?: HttpStatus) {
+    this.headers.set("Location", location);
+    this.#response = newResponse({
+      headers: this.headers,
+      status: status || 302,
+    });
+  }
+
+  getResponse() {
+    if (!this.#response) {
+      this.#response = new Response(this.body, {
+        status: this.status || (this.body ? 200 : 404),
+        headers: this.headers,
+      });
+    }
+    return this.#response;
+  }
+}

package/src/core/routeContext.ts

@@ -0,0 +1,38 @@
+import { isArray, isObject } from "lodash";
+import { RapidRequest } from "./request";
+import { RapidResponse } from "./response";
+import { HttpStatus, ResponseData } from "./http-types";
+
+export type Next = () => Promise<void>;
+
+export class RouteContext {
+  readonly request: RapidRequest;
+  readonly response: RapidResponse;
+  readonly state: Record<string, any>;
+  method: string;
+  path: string;
+  status: HttpStatus;
+  params: Record<string, string>;
+
+  constructor(request: RapidRequest) {
+    this.request = request;
+    this.state = {};
+    this.response = new RapidResponse();
+  }
+
+  set(headerName: string, headerValue: string) {
+    this.response.headers.set(headerName, headerValue);
+  }
+
+  json(
+    obj: any,
+    status?: HttpStatus,
+    headers?: HeadersInit,
+  ) {
+    this.response.json(obj, status, headers);
+  }
+
+  redirect(url: string, status?: HttpStatus) {
+    this.response.redirect(url, status);
+  }
+}

package/src/core/routesBuilder.ts

@@ -0,0 +1,86 @@
+import Router from "koa-tree-router";
+import qs from "qs";
+import { HttpHandlerContext } from "~/core/httpHandler";
+import { IRpdServer } from "~/core/server";
+import { RpdApplicationConfig } from "~/types";
+import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { Next, RouteContext } from "./routeContext";
+
+export async function buildRoutes(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  const router = new Router();
+
+  applicationConfig.routes.forEach((routeConfig) => {
+    if (routeConfig.type !== "RESTful") {
+      return;
+    }
+
+    (router as any)[routeConfig.method](
+      routeConfig.endpoint,
+      async (routerContext: RouteContext, next: Next) => {
+        const { request, params } = routerContext;
+
+        let search = request.url.search;
+        if (search && search.startsWith("?")) {
+          search = search.substring(1);
+        }
+        const query = qs.parse(search);
+        const input = Object.assign({}, params, query);
+
+        const requestMethod = request.method;
+        if (
+          (requestMethod === "POST" || requestMethod === "PUT" ||
+            requestMethod === "PATCH") && request.hasBody
+        ) {
+          const body = request.body();
+          if (body.type === "form-data") {
+            const formDataReader = body.value;
+            const formDataBody = await formDataReader.read({ maxFileSize: 1073741824 /* 1GB */});
+            Object.assign(input, {
+              formData: formDataBody
+            });
+          } else {
+            Object.assign(input, await body.value);
+          }
+        }
+
+        // Normalize input value
+
+        console.debug(`${requestMethod} ${request.url.toString()}`);
+        console.debug(`input: ${JSON.stringify(input)}`);
+
+        let handlerContext: HttpHandlerContext = {
+          routerContext,
+          next,
+          server,
+          applicationConfig,
+          input,
+        };
+
+        for (const handlerConfig of routeConfig.handlers) {
+          const handler = server.getHttpHandlerByCode(handlerConfig.code);
+          if (!handler) {
+            throw new Error("Unknown handler: " + handlerConfig.code);
+          }
+
+          const result = handler(handlerContext, handlerConfig.config);
+          if (result instanceof Promise) {
+            await result;
+          }
+        }
+
+        if (handlerContext.status) {
+          routerContext.status = handlerContext.status;
+        }
+
+        if (!isNullOrUndefined(handlerContext.output)) {
+          routerContext.json(handlerContext.output);
+        }
+      },
+    );
+  });
+
+  return router.routes();
+}

package/src/core/server.ts

@@ -0,0 +1,144 @@
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IPluginInstance, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes } from "~/types";
+import { IPluginHttpHandler, HttpRequestHandler } from "./httpHandler";
+import { Next } from "./routeContext";
+
+export interface IRpdServer {
+  config: RapidServerConfig;
+  databaseConfig: IDatabaseConfig;
+  queryBuilder: IQueryBuilder;
+  queryDatabaseObject: (
+    sql: string,
+    params?: unknown[] | Record<string, unknown>,
+  ) => Promise<any[]>;
+  tryQueryDatabaseObject: (
+    sql: string,
+    params?: unknown[] | Record<string, unknown>,
+  ) => Promise<any[]>;
+  registerMiddleware(middleware: any): void;
+  registerHttpHandler(
+    plugin: IPluginInstance,
+    options: IPluginHttpHandler,
+  ): void;
+  getHttpHandlerByCode(code: string): HttpRequestHandler | undefined;
+  getDataAccessor<T = any>(
+    options: GetDataAccessorOptions,
+  ): IRpdDataAccessor<T>;
+  getApplicationConfig(): RpdApplicationConfig;
+  getModel(options: GetModelOptions): RpdDataModel | undefined;
+  registerEventHandler<K extends keyof RpdServerEventTypes>(
+    eventName: K,
+    listener: (...args: RpdServerEventTypes[K]) => void,
+  ): this;
+  emitEvent<K extends keyof RpdServerEventTypes>(
+    eventName: K,
+    sender: IPluginInstance,
+    payload: RpdServerEventTypes[K][1],
+  ): void;
+  handleRequest(request: Request, next: Next): Promise<Response>;
+}
+
+
+
+export type RpdConfigurationItemTypes =
+  | "integer"
+  | "text"
+  | "boolean"
+  | "date"
+  | "datetime"
+  | "json";
+
+export interface RpdConfigurationItemOptions {
+  /**
+   * 配置项名称。可以包含中文。
+   */
+  name: string;
+  /**
+   * 配置项代码。
+   */
+  code: string;
+  /**
+   * 配置项类型。
+   */
+  type: RpdConfigurationItemTypes;
+  /**
+   * 是否必须有值。默认为 false。
+   */
+  required?: boolean;
+  /**
+   * 默认值。使用默认值的 JavaScript 字面量表示。
+   */
+  defaultValue?: string;
+}
+
+export type RpdServerPluginExtendingAbilities =
+  | /** 是指提供处理网络请求的middleware的能力。 */ "extendMiddleware"
+  | /** 是指增加系统中的集合的能力。 */ "extendModel"
+  | /** 是指可以对模型增加属性的能力。 */ "extendProperty"
+  | /** 是指增加接口动作的能力。 */ "extendHttpHandler"
+  | /** 是指增加或者修改接口定义的能力。 */ "extendRoute"
+  | /** 是指对实体数据进行标准化的能力。 */ "normalizeEntity"
+  | /** 处理事件总线发送过来的事件的能力。 */ "handleEvent"
+  | /** 处理消息队列发送过来的消息的能力。 */ "handleMessage"
+  | /** 对特定任务进行处理的能力。 */ "processTask";
+
+export interface RpdServerPluginConfigurableTargetOptions {
+  targetCode: string;
+
+  configurations: RpdConfigurationItemOptions[];
+}
+
+export interface IRpdServerPlugin {
+  /** 插件代码 */
+  code: string;
+  /** 插件描述 */
+  description: string;
+  /** 插件可以提供哪些扩展能力 */
+  extendingAbilities: RpdServerPluginExtendingAbilities[];
+  /** 插件可以配置的目标实体，以及和配置目标相关的配置项 */
+  configurableTargets?: RpdServerPluginConfigurableTargetOptions[];
+  /** 插件的全局配置项 */
+  configurations?: RpdConfigurationItemOptions[];
+  /** 初始化插件时调用。插件可以在此时进行一些内部对象的初始化工作。 */
+  initPlugin: (plugin: IPluginInstance, server: IRpdServer) => Promise<any>;
+  /** 注册中间件 */
+  registerMiddlewares?: (server: IRpdServer) => Promise<any>;
+  /** 注册接口动作处理程序 */
+  registerHttpHandlers?: (server: IRpdServer) => Promise<any>;
+  /** 注册事件处理程序 */
+  registerEventHandlers?: (server: IRpdServer) => Promise<any>;
+  /** 注册消息处理程序 */
+  registerMessageHandlers?: (server: IRpdServer) => Promise<any>;
+  /** 注册任务处理程序 */
+  registerTaskProcessors?: (server: IRpdServer) => Promise<any>;
+  /** 在加载应用前调用。 */
+  onLoadingApplication?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+  /** 配置数据集合 */
+  configureModels?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+  /** 配置模型属性 */
+  configureModelProperties?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+  /** 配置路由 */
+  configureRoutes?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+  /** 在应用配置加载完成后调用。此时插件可以进行一些数据的初始化工作。 */
+  onApplicationLoaded?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+  /** 在应用准备完成后调用。此时服务器已经可以处理网络请求，可以对外广播消息。 */
+  onApplicationReady?: (
+    server: IRpdServer,
+    applicationConfig: RpdApplicationConfig,
+  ) => Promise<any>;
+}
+

package/src/dataAccess/dataAccessor.ts

@@ -0,0 +1,110 @@
+import * as _ from "lodash";
+import {
+  CountEntityOptions,
+  FindEntityOptions,
+  CreateEntityOptions,
+  IRpdDataAccessor,
+  RpdDataModel,
+  UpdateEntityOptions,
+  IDatabaseAccessor,
+} from "~/types";
+import QueryBuilder from "~/queryBuilder/queryBuilder";
+
+export interface IDataAccessorOptions {
+  model: RpdDataModel;
+  queryBuilder: QueryBuilder;
+}
+
+export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
+  #model: RpdDataModel;
+  #queryBuilder: QueryBuilder;
+  #databaseAccessor: IDatabaseAccessor;
+
+  constructor(options: IDataAccessorOptions) {
+    this.#queryBuilder = options.queryBuilder;
+    this.#model = options.model;
+  }
+
+  getModel() {
+    return this.#model;
+  }
+
+  async create(entity: Partial<T>): Promise<T> {
+    const options: CreateEntityOptions = {
+      entity,
+    };
+    const query = this.#queryBuilder.insert(this.#model, options);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    return _.first(result);
+  }
+
+  async updateById(id: any, entity: Partial<T>): Promise<{ count: number }> {
+    const options: UpdateEntityOptions = {
+      entity,
+      filters: [
+        {
+          field: "id",
+          operator: "eq",
+          value: id,
+        },
+      ],
+    };
+    const query = this.#queryBuilder.update(this.#model, options);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    return _.first(result);
+  }
+
+  async find(options: FindEntityOptions): Promise<T[]> {
+    console.debug("DataAccessor.find() with options:", options);
+    const query = this.#queryBuilder.select(this.#model, options);
+    return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+  }
+
+  async findOne(options: FindEntityOptions): Promise<T> {
+    _.set(options, "pagination.limit", 1);
+    const list = await this.find(options);
+    return _.first(list);
+  }
+
+  async findById(id: any): Promise<T | null> {
+    const options: FindEntityOptions = {
+      filters: [
+        {
+          field: "id",
+          operator: "eq",
+          value: id,
+        },
+      ],
+    };
+    const query = this.#queryBuilder.select(this.#model, options);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    return _.first(result);
+  }
+
+  async count(options: CountEntityOptions): Promise<any> {
+    const query = this.#queryBuilder.count(this.#model, options);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+
+    const row = _.first(result);
+    if (row) {
+      return row;
+    }
+    return {
+      count: 0,
+    };
+  }
+
+  async deleteById(id: any) {
+    const options: FindEntityOptions = {
+      filters: [
+        {
+          field: "id",
+          operator: "eq",
+          value: id,
+        },
+      ],
+    };
+    const query = this.#queryBuilder.delete(this.#model, options);
+    await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+  }
+}