@ruiapp/rapid-core 0.3.1 → 0.3.3

package/src/core/request.ts

@@ -1,86 +1,86 @@
-import qs from "qs";
-import { parseFormDataBody } from "./http/formDataParser";
-import { getCookies } from "~/deno-std/http/cookie";
-import { IRpdServer } from "./server";
-import { Logger } from "~/facilities/log/LogFacility";
-
-export const GlobalRequest = global.Request;
-
-export interface RapidRequestBody {
-  type: "form-data" | "json" | "form";
-  value: any;
-}
-
-export class RapidRequest {
-  #logger: Logger;
-  #raw: Request;
-  #bodyParsed: boolean;
-  #body: RapidRequestBody;
-  #headers: Headers;
-  #parsedCookies: Record<string, string>;
-  method: string;
-  url: URL;
-
-  constructor(server: IRpdServer, req: Request) {
-    this.#logger = server.getLogger();
-    this.#raw = req;
-    this.method = req.method;
-    this.url = new URL(req.url);
-    this.#headers = req.headers;
-  }
-
-  async parseBody(): Promise<void> {
-    if (this.#bodyParsed) {
-      this.#logger.warn("Request body has been parsed. 'parseBody()' method should not be called more than once.");
-      return;
-    }
-
-    const requestMethod = this.method;
-    if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
-      const req = this.#raw;
-      const contentType = this.#headers.get("Content-Type") || "application/json";
-      if (contentType.includes("json")) {
-        this.#body = {
-          type: "json",
-          value: await req.json(),
-        };
-      } else if (contentType.startsWith("application/x-www-form-urlencoded")) {
-        const bodyText = await req.text();
-        this.#body = {
-          type: "form",
-          value: qs.parse(bodyText),
-        };
-      } else if (contentType.startsWith("multipart/form-data")) {
-        this.#body = {
-          type: "form-data",
-          value: await parseFormDataBody(req),
-        };
-      }
-    } else {
-      this.#body = null;
-    }
-    this.#bodyParsed = true;
-  }
-
-  get rawRequest(): Request {
-    return this.#raw;
-  }
-
-  get headers(): Headers {
-    return this.#headers;
-  }
-
-  get cookies(): Record<string, string> {
-    if (!this.#parsedCookies) {
-      this.#parsedCookies = getCookies(this.#headers);
-    }
-    return this.#parsedCookies;
-  }
-
-  get body(): RapidRequestBody {
-    if (!this.#bodyParsed) {
-      throw new Error("Request body not parsed, you should call 'parseBody()' method before getting the body.");
-    }
-    return this.#body;
-  }
-}
+import qs from "qs";
+import { parseFormDataBody } from "./http/formDataParser";
+import { getCookies } from "~/deno-std/http/cookie";
+import { IRpdServer } from "./server";
+import { Logger } from "~/facilities/log/LogFacility";
+
+export const GlobalRequest = global.Request;
+
+export interface RapidRequestBody {
+  type: "form-data" | "json" | "form";
+  value: any;
+}
+
+export class RapidRequest {
+  #logger: Logger;
+  #raw: Request;
+  #bodyParsed: boolean;
+  #body: RapidRequestBody;
+  #headers: Headers;
+  #parsedCookies: Record<string, string>;
+  method: string;
+  url: URL;
+
+  constructor(server: IRpdServer, req: Request) {
+    this.#logger = server.getLogger();
+    this.#raw = req;
+    this.method = req.method;
+    this.url = new URL(req.url);
+    this.#headers = req.headers;
+  }
+
+  async parseBody(): Promise<void> {
+    if (this.#bodyParsed) {
+      this.#logger.warn("Request body has been parsed. 'parseBody()' method should not be called more than once.");
+      return;
+    }
+
+    const requestMethod = this.method;
+    if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
+      const req = this.#raw;
+      const contentType = this.#headers.get("Content-Type") || "application/json";
+      if (contentType.includes("json")) {
+        this.#body = {
+          type: "json",
+          value: await req.json(),
+        };
+      } else if (contentType.startsWith("application/x-www-form-urlencoded")) {
+        const bodyText = await req.text();
+        this.#body = {
+          type: "form",
+          value: qs.parse(bodyText),
+        };
+      } else if (contentType.startsWith("multipart/form-data")) {
+        this.#body = {
+          type: "form-data",
+          value: await parseFormDataBody(req),
+        };
+      }
+    } else {
+      this.#body = null;
+    }
+    this.#bodyParsed = true;
+  }
+
+  get rawRequest(): Request {
+    return this.#raw;
+  }
+
+  get headers(): Headers {
+    return this.#headers;
+  }
+
+  get cookies(): Record<string, string> {
+    if (!this.#parsedCookies) {
+      this.#parsedCookies = getCookies(this.#headers);
+    }
+    return this.#parsedCookies;
+  }
+
+  get body(): RapidRequestBody {
+    if (!this.#bodyParsed) {
+      throw new Error("Request body not parsed, you should call 'parseBody()' method before getting the body.");
+    }
+    return this.#body;
+  }
+}

package/src/core/response.ts

@@ -1,76 +1,76 @@
-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) {
-    let body: string | null = null;
-    if (obj) {
-      body = JSON.stringify(obj);
-    }
-    this.headers.set("Content-Type", "application/json");
-    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;
-  }
-}
+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) {
+    let body: string | null = null;
+    if (obj) {
+      body = JSON.stringify(obj);
+    }
+    this.headers.set("Content-Type", "application/json");
+    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

@@ -1,47 +1,47 @@
-import { isArray, isObject } from "lodash";
-import { RapidRequest } from "./request";
-import { RapidResponse } from "./response";
-import { HttpStatus, ResponseData } from "./http-types";
-import { IRpdServer } from "./server";
-import { Logger } from "~/facilities/log/LogFacility";
-
-export type Next = () => Promise<void>;
-
-export class RouteContext {
-  readonly request: RapidRequest;
-  readonly response: RapidResponse;
-  readonly state: Record<string, any>;
-  method: string;
-  path: string;
-  params: Record<string, string>;
-  routeConfig: any;
-
-  static newSystemOperationContext(server: IRpdServer) {
-    return new RouteContext(server);
-  }
-
-  constructor(server: IRpdServer, request?: RapidRequest) {
-    this.request = request;
-    this.state = {};
-    this.response = new RapidResponse();
-
-    // `method` and `path` are used by `koa-tree-router` to match route
-    if (this.request) {
-      this.method = request.method;
-      this.path = request.url.pathname;
-    }
-  }
-
-  // `koa-tree-router` uses this method to set headers
-  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);
-  }
-}
+import { isArray, isObject } from "lodash";
+import { RapidRequest } from "./request";
+import { RapidResponse } from "./response";
+import { HttpStatus, ResponseData } from "./http-types";
+import { IRpdServer } from "./server";
+import { Logger } from "~/facilities/log/LogFacility";
+
+export type Next = () => Promise<void>;
+
+export class RouteContext {
+  readonly request: RapidRequest;
+  readonly response: RapidResponse;
+  readonly state: Record<string, any>;
+  method: string;
+  path: string;
+  params: Record<string, string>;
+  routeConfig: any;
+
+  static newSystemOperationContext(server: IRpdServer) {
+    return new RouteContext(server);
+  }
+
+  constructor(server: IRpdServer, request?: RapidRequest) {
+    this.request = request;
+    this.state = {};
+    this.response = new RapidResponse();
+
+    // `method` and `path` are used by `koa-tree-router` to match route
+    if (this.request) {
+      this.method = request.method;
+      this.path = request.url.pathname;
+    }
+  }
+
+  // `koa-tree-router` uses this method to set headers
+  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

@@ -1,88 +1,88 @@
-import Router from "koa-tree-router";
-import qs from "qs";
-import { ActionHandlerContext } from "~/core/actionHandler";
-import { IRpdServer } from "~/core/server";
-import { RpdApplicationConfig } from "~/types";
-import { isNullOrUndefined } from "~/utilities/typeUtility";
-import { Next, RouteContext } from "./routeContext";
-import { cloneDeep } from "lodash";
-
-export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
-  const logger = server.getLogger();
-  const router = new Router();
-
-  let baseUrl = server.config.baseUrl;
-  if (baseUrl) {
-    if (baseUrl.endsWith("/")) {
-      baseUrl = baseUrl.substring(0, baseUrl.length - 1);
-    }
-  } else {
-    baseUrl = "";
-  }
-
-  applicationConfig.routes.forEach((routeConfig) => {
-    if (routeConfig.type !== "RESTful") {
-      return;
-    }
-
-    const routePath = baseUrl + routeConfig.endpoint;
-
-    (router as any)[routeConfig.method.toLowerCase()](routePath, async (routerContext: RouteContext, next: Next) => {
-      routerContext.routeConfig = cloneDeep(routeConfig);
-      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") {
-        const body = request.body;
-        if (body) {
-          Object.assign(input, body.value);
-        }
-      }
-
-      // Normalize input value
-
-      logger.debug("Processing rapid request.", {
-        method: requestMethod,
-        url: request.url.toString(),
-        input,
-      });
-
-      let handlerContext: ActionHandlerContext = {
-        logger,
-        routerContext,
-        next,
-        server,
-        applicationConfig,
-        input,
-      };
-
-      await server.beforeRunRouteActions(handlerContext);
-
-      for (const actionConfig of routeConfig.actions) {
-        const actionCode = actionConfig.code;
-        const handler = server.getActionHandlerByCode(actionCode);
-        if (!handler) {
-          throw new Error("Unknown handler: " + actionCode);
-        }
-
-        const result = handler(handlerContext, actionConfig.config);
-        if (result instanceof Promise) {
-          await result;
-        }
-      }
-
-      if (!isNullOrUndefined(handlerContext.output)) {
-        routerContext.json(handlerContext.output, handlerContext.status);
-      }
-    });
-  });
-
-  return router.routes();
-}
+import Router from "koa-tree-router";
+import qs from "qs";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { IRpdServer } from "~/core/server";
+import { RpdApplicationConfig } from "~/types";
+import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { Next, RouteContext } from "./routeContext";
+import { cloneDeep } from "lodash";
+
+export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
+  const logger = server.getLogger();
+  const router = new Router();
+
+  let baseUrl = server.config.baseUrl;
+  if (baseUrl) {
+    if (baseUrl.endsWith("/")) {
+      baseUrl = baseUrl.substring(0, baseUrl.length - 1);
+    }
+  } else {
+    baseUrl = "";
+  }
+
+  applicationConfig.routes.forEach((routeConfig) => {
+    if (routeConfig.type !== "RESTful") {
+      return;
+    }
+
+    const routePath = baseUrl + routeConfig.endpoint;
+
+    (router as any)[routeConfig.method.toLowerCase()](routePath, async (routerContext: RouteContext, next: Next) => {
+      routerContext.routeConfig = cloneDeep(routeConfig);
+      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") {
+        const body = request.body;
+        if (body) {
+          Object.assign(input, body.value);
+        }
+      }
+
+      // Normalize input value
+
+      logger.debug("Processing rapid request.", {
+        method: requestMethod,
+        url: request.url.toString(),
+        input,
+      });
+
+      let handlerContext: ActionHandlerContext = {
+        logger,
+        routerContext,
+        next,
+        server,
+        applicationConfig,
+        input,
+      };
+
+      await server.beforeRunRouteActions(handlerContext);
+
+      for (const actionConfig of routeConfig.actions) {
+        const actionCode = actionConfig.code;
+        const handler = server.getActionHandlerByCode(actionCode);
+        if (!handler) {
+          throw new Error("Unknown handler: " + actionCode);
+        }
+
+        const result = handler(handlerContext, actionConfig.config);
+        if (result instanceof Promise) {
+          await result;
+        }
+      }
+
+      if (!isNullOrUndefined(handlerContext.output)) {
+        routerContext.json(handlerContext.output, handlerContext.status);
+      }
+    });
+  });
+
+  return router.routes();
+}