@ruiapp/rapid-core 0.0.1

package/src/server.ts

@@ -0,0 +1,192 @@
+import * as _ from "lodash";
+import DataAccessor from "./dataAccess/dataAccessor";
+import {
+  GetDataAccessorOptions,
+  GetModelOptions,
+  IDatabaseAccessor,
+  IDatabaseConfig,
+  IPluginInstance,
+  IQueryBuilder,
+  IRpdDataAccessor,
+  RpdApplicationConfig,
+  RpdDataModel,
+  RpdServerEventTypes,
+  RapidServerConfig,
+} from "./types";
+
+import QueryBuilder from "./queryBuilder/queryBuilder";
+import * as pluginManager from "./core/pluginManager";
+import EventManager from "./core/eventManager";
+import { HttpRequestHandler, IPluginHttpHandler } from "./core/httpHandler";
+import { IRpdServer } from "./core/server";
+import { buildRoutes } from "./core/routesBuilder";
+import { Next, RouteContext } from "./core/routeContext";
+import { RapidRequest } from "./core/request";
+
+
+export interface InitServerOptions {
+  databaseAccessor: IDatabaseAccessor;
+  databaseConfig: IDatabaseConfig;
+  serverConfig: RapidServerConfig;
+  applicationConfig: RpdApplicationConfig;
+}
+
+export default class RpdServer implements IRpdServer {
+  #eventManager: EventManager;
+  #middlewares: any[];
+  #bootstrapApplicationConfig: RpdApplicationConfig;
+  #applicationConfig: RpdApplicationConfig;
+  #httpHandlersMapByCode: Map<string, HttpRequestHandler>;
+  #databaseAccessor: IDatabaseAccessor;
+  queryBuilder: IQueryBuilder;
+  config: RapidServerConfig;
+  databaseConfig: IDatabaseConfig;
+  #buildedRoutes: (ctx: any, next: any) => any;
+
+  constructor(options: InitServerOptions) {
+    this.#eventManager = new EventManager();
+    this.#middlewares = [];
+    this.#bootstrapApplicationConfig = options.applicationConfig;
+
+    this.#applicationConfig = {} as RpdApplicationConfig;
+    this.#httpHandlersMapByCode = new Map();
+    this.#databaseAccessor = options.databaseAccessor;
+
+    this.queryBuilder = new QueryBuilder({
+      dbDefaultSchema: options.databaseConfig.dbDefaultSchema,
+    });
+    this.databaseConfig = options.databaseConfig;
+    this.config = options.serverConfig;
+  }
+
+  getApplicationConfig() {
+    return this.#applicationConfig;
+  }
+
+  registerHttpHandler(
+    plugin: IPluginInstance,
+    options: IPluginHttpHandler,
+  ) {
+    const handler = _.bind(options.handler, null, plugin);
+    this.#httpHandlersMapByCode.set(options.code, handler);
+  }
+
+  getHttpHandlerByCode(code: string) {
+    return this.#httpHandlersMapByCode.get(code);
+  }
+
+  registerMiddleware(middleware: any) {
+    this.#middlewares.push(middleware);
+  }
+
+  getDataAccessor<T = any>(
+    options: GetDataAccessorOptions,
+  ): IRpdDataAccessor<T> {
+    const { namespace, singularCode } = options;
+    // TODO: Should reuse the and DataAccessor instance
+    const model = this.getModel(options);
+    if (!model) {
+      throw new Error(`Data model ${namespace}.${singularCode} not found.`);
+    }
+
+    const dataAccessor = new DataAccessor<T>({
+      model,
+      queryBuilder: this.queryBuilder as QueryBuilder,
+    });
+    return dataAccessor;
+  }
+
+  getModel(options: GetModelOptions): RpdDataModel | undefined {
+    if (options.namespace) {
+      return this.#applicationConfig?.models.find((e) => e.namespace === options.namespace && e.singularCode === options.singularCode);
+    }
+
+    return this.#applicationConfig?.models.find((e) => e.singularCode === options.singularCode);
+  }
+
+  registerEventHandler<K extends keyof RpdServerEventTypes>(
+    eventName: K,
+    listener: (...args: RpdServerEventTypes[K]) => void,
+  ): this {
+    this.#eventManager.on(eventName, listener);
+    return this;
+  }
+
+  async emitEvent<K extends keyof RpdServerEventTypes>(
+    eventName: K,
+    sender: IPluginInstance,
+    payload: RpdServerEventTypes[K][1],
+  ) {
+    console.log(`Emit event "${eventName}"`, payload);
+    await this.#eventManager.emit<K>(eventName, sender, payload as any);
+
+    // TODO: should move this logic into metaManager
+    // if (
+    //   (eventName === "entity.create" || eventName === "entity.update" ||
+    //     eventName === "entity.delete") &&
+    //   payload.namespace === "meta"
+    // ) {
+    //   await this.configureApplication();
+    // }
+  }
+
+  async start() {
+    console.log("Starting rapid server...");
+    await pluginManager.loadPlugins();
+
+    await pluginManager.initPlugins(this);
+
+    await pluginManager.registerMiddlewares(this);
+    await pluginManager.registerHttpHandlers(this);
+    await pluginManager.registerEventHandlers(this);
+    await pluginManager.registerMessageHandlers(this);
+    await pluginManager.registerTaskProcessors(this);
+
+    await this.configureApplication();
+
+    console.log(`Application ready.`);
+    await pluginManager.onApplicationReady(this, this.#applicationConfig);
+  }
+
+  async configureApplication() {
+    this.#applicationConfig = _.merge(
+      {},
+      this.#bootstrapApplicationConfig,
+    ) as RpdApplicationConfig;
+
+    await pluginManager.onLoadingApplication(this, this.#applicationConfig);
+    await pluginManager.configureModels(this, this.#applicationConfig);
+    await pluginManager.configureModelProperties(this, this.#applicationConfig);
+    await pluginManager.configureRoutes(this, this.#applicationConfig);
+
+    // TODO: check application configuration.
+
+    await pluginManager.onApplicationLoaded(this, this.#applicationConfig);
+
+    this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
+  }
+
+  async queryDatabaseObject(sql: string, params?: unknown[] | Record<string,unknown>) : Promise<any[]> {
+    return await this.#databaseAccessor.queryDatabaseObject(sql, params);
+  }
+
+  async tryQueryDatabaseObject(sql: string, params?: unknown[] | Record<string,unknown>) : Promise<any[]> {
+    try {
+      return await this.queryDatabaseObject(sql, params);
+    } catch (err) {
+      console.error(err.message);
+    }
+
+    return [];
+  }
+
+  get middlewares() {
+    return this.#middlewares;
+  }
+
+  async handleRequest(request: Request, next: Next) {
+    const routeContext = new RouteContext(new RapidRequest(request));
+    await this.#buildedRoutes(routeContext, next);
+    return routeContext.response.getResponse();
+  }
+}

package/src/types.ts

@@ -0,0 +1,438 @@
+export type RapidServerConfig = {
+  sessionCookieName: string;
+  jwtKey: string;
+  localFileStoragePath: string;
+};
+
+export interface IDatabaseConfig {
+  dbHost?: string;
+  dbPort?: number;
+  dbName?: string;
+  dbUser?: string;
+  dbPassword?: string;
+  dbDefaultSchema?: string;
+  dbPoolConnections?: number;
+}
+
+export interface IDatabaseAccessor {
+  queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
+}
+
+
+export interface RunEntityHttpHandlerOptions {
+  /** 模型所在的命名空间 */
+  namespace: string;
+  /** 模型Code的单数表示 */
+  singularCode: string;
+  /** 默认输入 */
+  defaultInput: Record<string, any>;
+  /** 固定输入 */
+  fixedInput: Record<string, any>;
+}
+
+export interface RunQueryDatabaseHandlerOptions {
+  sql: string;
+
+  querySingle?: boolean;
+
+  /** 默认输入 */
+  defaultInput: Record<string, any>;
+  /** 固定输入 */
+  fixedInput: Record<string, any>;
+}
+
+export interface RunProxyHandlerOptions {
+  /** Timeout milli seconds, default as 60000 */
+  timeout?: number;
+  /** Target url to proxy */
+  target: string;
+}
+
+export interface GetDataAccessorOptions {
+  namespace?: string;
+  singularCode: string;
+}
+
+export interface GetModelOptions {
+  namespace?: string;
+  singularCode: string;
+}
+
+export type RpdServerEventTypes = {
+  "entity.create": [IPluginInstance, RpdEntityCreateEventPayload];
+  "entity.update": [IPluginInstance, RpdEntityUpdateEventPayload];
+  "entity.delete": [IPluginInstance, RpdEntityDeleteEventPayload];
+  "entity.addRelations": [IPluginInstance, RpdEntityAddRelationsEventPayload];
+  "entity.removeRelations": [IPluginInstance, RpdEntityRemoveRelationsEventPayload];
+};
+
+export interface RpdEntityCreateEventPayload {
+  namespace: string;
+  modelSingularCode: string;
+  after: any;
+}
+
+export interface RpdEntityUpdateEventPayload {
+  namespace: string;
+  modelSingularCode: string;
+  before: any;
+  after: any;
+  changes: any;
+}
+
+export interface RpdEntityDeleteEventPayload {
+  namespace: string;
+  modelSingularCode: string;
+  before: any;
+}
+
+export interface RpdEntityAddRelationsEventPayload {
+  namespace: string;
+  modelSingularCode: string;
+  entity: any;
+  property: string;
+  relations: any[];
+}
+
+export interface RpdEntityRemoveRelationsEventPayload {
+  namespace: string;
+  modelSingularCode: string;
+  entity: any;
+  property: string;
+  relations: any[];
+}
+
+export interface QuoteTableOptions {
+  schema?: string;
+  tableName: string;
+}
+
+export interface IQueryBuilder {
+  quoteTable: (options: QuoteTableOptions) => string;
+  quoteObject: (name: string) => string;
+}
+
+
+export interface RpdApplicationConfig {
+  code?: string;
+  name?: string;
+  models: RpdDataModel[];
+  routes: RpdRoute[];
+}
+
+export interface RpdDataModel {
+  maintainedBy?: string;
+  name: string;
+  namespace: string;
+  singularCode: string;
+  pluralCode: string;
+  schema?: string;
+  tableName: string;
+  properties: RpdDataModelProperty[];
+  extensions?: RpdDataModelExtension[];
+}
+
+export interface RpdDataModelProperty {
+  /**
+   * 表示此属性由谁来维护
+   */
+  maintainedBy?: string;
+  /**
+   * 字段名称。可以包含中文。
+   */
+  name: string;
+  /**
+   * 字段代码。会用于数据表列名和 API 的字段名。
+   */
+  code: string;
+  /**
+   * 数据表列名。如果没有设置则使用 code。
+   */
+  columnName?: string;
+  /**
+   * 字段类型。
+   */
+  type: RpdDataPropertyTypes;
+  /**
+   * 是否必须有值。默认为 false。
+   */
+  required?: boolean;
+  /**
+   * 默认值。使用默认值的 SQL 表达式表示。
+   */
+  defaultValue?: string;
+  /**
+   * 属性配置。
+   */
+  // deno-lint-ignore no-explicit-any
+  config?: Record<string, any>;
+  /**
+   * 是否自增长。
+   */
+  autoIncrement?: boolean;
+  /**
+   * 字段值的最小长度。
+   */
+  minLength?: number;
+  /**
+   * 字段值的最大长度。
+   */
+  maxLength?: number;
+  /**
+   * 当 type 为 relation 时，设置关联实体为一个还是多个。
+   */
+  relation?: "one" | "many";
+  /**
+   * 关联实体的singular code，不管 relation 为 one 或者 many 都需要设置。
+   */
+  targetSingularCode?: string;
+  /**
+   * 当 relation 为 one 时，设置当前模型表中表示关联实体 id 的列名。
+   * 当 relation 为 many，并且使用关联关系表保存关联信息时，设置关联关系表中表示关联实体 id 的列名。
+   * 当 relation 为 many，并且不使用关联关系表保存关联信息时，关联实体 id 的列名默认为`id`，此时可以不设置 targetIdColumnName。
+   */
+  targetIdColumnName?: string;
+  /**
+   * 当 relation 为 many 时，设置目标模型表或关联关系表中表示自身实体 id 的列名。
+   */
+  selfIdColumnName?: string;
+  /**
+   * 当 relation 为 many 时，可以使用关联关系表保存关联信息，此时需要设置关联关系表的名称。
+   */
+  linkTableName?: string;
+  /**
+   * 当设置了 linkTableName 时，可以设置关联关系表所在的 Schema。
+   */
+  linkSchema?: string;
+}
+
+export type RpdDataPropertyTypes =
+  | "integer"
+  | "long"
+  | "float"
+  | "double"
+  | "decimal"
+  | "text"
+  | "boolean"
+  | "date"
+  | "datetime"
+  | "json"
+  | "relation"
+  | "relation[]"
+  | "option";
+
+
+/**
+ * 数据字典
+ */
+export type RpdDataDictionary = {
+  /**
+   * 字典编码
+   */
+  code: string;
+
+  /**
+   * 字典名称
+   */
+  description?: string;
+
+  /**
+   * 字典项值类型
+   */
+  type: 'string' | 'integer';
+
+  /**
+   * 字典项
+   */
+  entries: RpdDataDictionaryEntry[];
+};
+
+/**
+ * 数据字典项
+ */
+export type RpdDataDictionaryEntry = {
+  /**
+   * 名称
+   */
+  name: string;
+
+  /**
+   * 值
+   */
+  value: string;
+
+  /**
+   * 描述
+   */
+  description?: string;
+
+  /**
+   * 排序号
+   */
+  orderNum: number;
+
+  /**
+   * 是否禁用
+   */
+  disabled: boolean;
+};
+
+
+export interface RpdDataModelExtension {
+  code: string;
+  config: any;
+}
+
+
+export interface IPluginInstance {
+  getName(): string;
+}
+
+export type EventHandler<T = any> = (
+  sender: IPluginInstance,
+  payload: T,
+) => void;
+
+export interface RpdRoute {
+  name: string;
+  namespace: string;
+  code: string;
+  type: "RESTful";
+  method: RpdHttpMethod;
+  endpoint: string;
+  handlers: RpdHttpHandler[];
+}
+
+export type RpdHttpMethod = "get" | "post" | "put" | "delete";
+
+export interface RpdHttpHandler {
+  code: string;
+  config: any;
+}
+
+export interface IRpdDataAccessor<T = any> {
+  getModel(): RpdDataModel;
+  create(entity: any): Promise<any>;
+  updateById(id: any, entity: any): Promise<any>;
+  find(options: FindEntityOptions): Promise<T[]>;
+  findOne(options: FindEntityOptions): Promise<T | null>;
+  findById(id: any): Promise<T | null>;
+  count(options: CountEntityOptions): Promise<any>;
+  deleteById(id: any): Promise<void>;
+}
+
+export type EntityFilterRelationalOperators =
+  | "eq"
+  | "ne"
+  | "lt"
+  | "lte"
+  | "gt"
+  | "gte"
+  | "contains"
+  | "notContains"
+  | "containsCS"
+  | "notContainsCS"
+  | "startsWith"
+  | "notStartsWith"
+  | "endsWith"
+  | "notEndsWith";
+
+export type EntityFilterSetOperators =
+  | "in"
+  | "notIn";
+
+export type EntityFilterLogicalOperators =
+  | "or"
+  | "and";
+
+export type EntityFilterUnaryOperators =
+  | "null"
+  | "notNull";
+
+export type EntityFilterExistenceOperators =
+  | "exists"
+  | "notExists";
+
+export type EntityFilterOperators =
+  | EntityFilterRelationalOperators
+  | EntityFilterSetOperators
+  | EntityFilterLogicalOperators
+  | EntityFilterUnaryOperators
+  | EntityFilterExistenceOperators;
+
+export type EntityFilterOptions =
+  | FindEntityRelationalFilterOptions
+  | FindEntitySetFilterOptions
+  | FindEntityLogicalFilterOptions
+  | FindEntityUnaryFilterOptions
+  | FindEntityExistenceFilterOptions;
+
+export interface FindEntityOptions {
+  filters?: EntityFilterOptions[];
+  orderBy?: FindEntityOrderByOptions[];
+  pagination?: FindEntityPaginationOptions;
+  properties?: string[] | Record<string, any>;
+}
+
+export interface FindEntityRelationalFilterOptions {
+  field: string;
+  operator: EntityFilterRelationalOperators;
+  value: any;
+}
+
+export interface FindEntitySetFilterOptions {
+  field: string;
+  operator: EntityFilterSetOperators;
+  value: any[];
+  itemType?: string;
+}
+
+export interface FindEntityLogicalFilterOptions {
+  operator: EntityFilterLogicalOperators;
+  filters: EntityFilterOptions[];
+}
+
+export interface FindEntityUnaryFilterOptions {
+  field: string;
+  operator: EntityFilterUnaryOperators;
+}
+
+export interface FindEntityExistenceFilterOptions {
+  field: string;
+  operator: EntityFilterExistenceOperators;
+  filters: EntityFilterOptions[];
+}
+
+export interface FindEntityPaginationOptions {
+  offset: number;
+  limit: number;
+  withoutTotal?: boolean;
+}
+
+export interface FindEntityOrderByOptions {
+  field: string;
+  desc?: boolean;
+}
+
+export interface CountEntityOptions {
+  filters?: EntityFilterOptions[];
+}
+
+export interface CreateEntityOptions {
+  entity: any;
+}
+
+export interface UpdateEntityOptions {
+  filters?: EntityFilterOptions[];
+  entity: any;
+}
+
+export interface UpdateEntityByIdOptions {
+  id: any;
+  entity: any;
+  changes: any;
+}
+
+export interface DeleteEntityOptions {
+  filters?: EntityFilterOptions[];
+}

package/src/utilities/httpUtility.ts

@@ -0,0 +1,23 @@
+export async function fetchWithTimeout(
+  url: string,
+  reqInit: RequestInit,
+  timeout?: number,
+) : Promise<Response> {
+  if (!timeout) {
+    return await fetch(url, reqInit);
+  }
+
+  let timer: any;
+  const [res] = await Promise.all([
+    fetch(url, reqInit).then((res) => {
+      clearTimeout(timer);
+      return res;
+    }),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`Request to "${url}" was timeout.`));
+      }, timeout);
+    }),
+  ]);
+  return res;
+}

package/src/utilities/jwtUtility.ts

@@ -0,0 +1,16 @@
+
+export function getJWTKey() {
+  return "";
+}
+
+export async function createJWT(payload: Record<string, any>) {
+  return "";
+}
+
+export async function verifyJWT(jwt: string) {
+  return {};
+}
+
+export async function decodeJWT(jwt: string) {
+  return { header: {}, payload: {}, signature: {} };
+}

package/src/utilities/rapidUtility.ts

@@ -0,0 +1,5 @@
+import { RpdDataModelProperty } from "../types";
+
+export function isRelationProperty(property: RpdDataModelProperty) {
+  return property.type === "relation" || property.type === "relation[]";
+}

package/src/utilities/typeUtility.ts

@@ -0,0 +1,11 @@
+export function isUndefined(val: any) {
+  return typeof val === "undefined";
+}
+
+export function isNull(val: any) {
+  return val === null;
+}
+
+export function isNullOrUndefined(val: any) {
+  return isNull(val) || isUndefined(val);
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowJs": true,
+    "sourceMap": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "paths": {
+      "~/*": ["./src/*"]
+    }
+  },
+  "exclude": ["src/**/*.spec.ts", "src/**/*.spec.tsx", "node_modules"],
+  "include": ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"]
+}