@ruiapp/rapid-core 0.1.2 → 0.1.4

package/src/plugins/dataManager/mod.ts

@@ -39,55 +39,55 @@ const routeConfigs: {
 }[] = [
   {
     code: "createBatch",
-    method: "post",
+    method: "POST",
     endpoint: "/operations/create_batch",
     handlerCode: "createCollectionEntitiesBatch",
   },
   {
     code: "find",
-    method: "post",
+    method: "POST",
     endpoint: "/operations/find",
     handlerCode: "findCollectionEntities",
   },
   {
     code: "count",
-    method: "post",
+    method: "POST",
     endpoint: "/operations/count",
     handlerCode: "countCollectionEntities",
   },
   {
     code: "addRelations",
-    method: "post",
+    method: "POST",
     endpoint: "/operations/add_relations",
     handlerCode: "addEntityRelations",
   },
   {
     code: "removeRelations",
-    method: "post",
+    method: "POST",
     endpoint: "/operations/remove_relations",
     handlerCode: "removeEntityRelations",
   },
   {
     code: "getById",
-    method: "get",
+    method: "GET",
     endpoint: "/:id",
     handlerCode: "findCollectionEntityById",
   },
   {
     code: "create",
-    method: "post",
+    method: "POST",
     endpoint: "",
     handlerCode: "createCollectionEntity",
   },
   {
     code: "updateById",
-    method: "patch",
+    method: "PATCH",
     endpoint: "/:id",
     handlerCode: "updateCollectionEntityById",
   },
   {
     code: "deleteById",
-    method: "delete",
+    method: "DELETE",
     endpoint: "/:id",
     handlerCode: "deleteCollectionEntityById",
   },

package/src/plugins/fileManager/httpHandlers/downloadDocument.ts

@@ -0,0 +1,40 @@
+import path from "path";
+import { IPluginInstance } from "~/types";
+import { HttpHandlerContext } from "~/core/httpHandler";
+import { readFile } from "~/utilities/fsUtility";
+
+export const code = "downloadDocument";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, applicationConfig, routerContext, input } = ctx;
+  const { request, response } = routerContext;
+
+  const documentDataAccessor = ctx.server.getDataAccessor({
+    singularCode: "ecm_document",
+  });
+  const storageDataAccessor = ctx.server.getDataAccessor({
+    singularCode: "ecm_storage_object",
+  });
+
+  const document = await documentDataAccessor.findById(input.documentId);
+  if (!document) {
+    ctx.output = { error: new Error("Document not found.") };
+    return;
+  }
+  const storageObject = await storageDataAccessor.findById(document.storage_object_id);
+  if (!storageObject) {
+    ctx.output = { error: new Error("Storage object not found.") };
+    return;
+  }
+
+  const fileKey = storageObject.key;
+  const filePathName = path.join(server.config.localFileStoragePath, fileKey);
+  const attachmentFileName = document.name;
+
+  response.body = await readFile(filePathName);
+  response.headers.set("Content-Disposition", `attachment; filename="${encodeURIComponent(attachmentFileName)}"`)
+}

package/src/plugins/fileManager/httpHandlers/downloadFile.ts

@@ -0,0 +1,32 @@
+import path from "path";
+import { IPluginInstance } from "~/types";
+import { readFile } from "~/utilities/fsUtility";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "downloadFile";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, applicationConfig, routerContext, input } = ctx;
+  const { request, response } = routerContext;
+
+  const dataAccessor = ctx.server.getDataAccessor({
+    singularCode: "ecm_storage_object",
+  });
+
+  const storageObject = await dataAccessor.findById(input.fileId);
+  if (!storageObject) {
+    ctx.output = { error: new Error("Storage object not found.") };
+    return;
+  }
+
+  const fileKey = storageObject.key;
+  const filePathName = path.join(server.config.localFileStoragePath, fileKey);
+  const attachmentFileName = input.fileName || path.basename(fileKey);
+
+  response.body = await readFile(filePathName);
+  response.headers.set("Content-Disposition", `attachment; filename="${encodeURIComponent(attachmentFileName)}"`)
+}

package/src/plugins/fileManager/httpHandlers/uploadFile.ts

@@ -0,0 +1,37 @@
+import { v1 as uuidv1 } from "uuid";
+import { IPluginInstance } from "~/types";
+import { appendFile } from "~/utilities/fsUtility";
+import { HttpHandlerContext } from "~/core/httpHandler";
+import path from "path";
+import { isArray } from "lodash";
+
+export const code = "uploadFile";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, applicationConfig, routerContext, input } = ctx;
+  const { request, response } = routerContext;
+
+  let file: File | File[] | null = input.files;
+  if (isArray(file)) {
+    file = file[0];
+  }
+
+  if (!file) {
+    ctx.status = 400;
+    ctx.output = { error: "File not found in request body."};
+    return;
+  }
+
+  const extName = path.extname(file.name);
+  const fileKey = `${uuidv1()}${extName}`
+  const filePathName = path.join(server.config.localFileStoragePath, fileKey);
+
+  const fileBuffer = await file.arrayBuffer();
+  await appendFile(filePathName, fileBuffer);
+
+  ctx.output = { ok: true, fileKey };
+}

package/src/plugins/fileManager/mod.ts

@@ -0,0 +1,48 @@
+/**
+ * File manager plugin
+ */
+
+import * as _ from "lodash";
+import {
+  IPluginInstance,
+  RpdApplicationConfig,
+} from "~/types";
+
+import * as downloadDocumentHttpHandler from "./httpHandlers/downloadDocument";
+import * as downloadFileHttpHandler from "./httpHandlers/downloadFile";
+import * as uploadFileHttpHandler from "./httpHandlers/uploadFile";
+import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+
+export const code = "fileManager";
+export const description = "fileManager";
+export const extendingAbilities: RpdServerPluginExtendingAbilities[] = [];
+export const configurableTargets: RpdServerPluginConfigurableTargetOptions[] = [];
+export const configurations: RpdConfigurationItemOptions[] = [];
+
+let _plugin: IPluginInstance;
+
+export async function initPlugin(plugin: IPluginInstance, server: IRpdServer) {
+  _plugin = plugin;
+}
+
+export async function registerHttpHandlers(server: IRpdServer) {
+  server.registerHttpHandler(_plugin, downloadDocumentHttpHandler);
+  server.registerHttpHandler(_plugin, downloadFileHttpHandler);
+  server.registerHttpHandler(_plugin, uploadFileHttpHandler);
+}
+
+export async function registerEventHandlers(server: IRpdServer) {
+}
+
+export async function configureModels(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+}
+
+export async function onApplicationLoaded(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  console.log("fileManager.onApplicationLoaded");
+}

package/src/server.ts

@@ -223,7 +223,6 @@ export class RapidServer implements IRpdServer {
     const rapidRequest = new RapidRequest(request);
     await rapidRequest.parseBody();
     const routeContext = new RouteContext(rapidRequest);
-    console.log('routeContext', routeContext)
     await this.#buildedRoutes(routeContext, next);
     return routeContext.response.getResponse();
   }

package/src/types.ts

@@ -304,11 +304,11 @@ export interface RpdRoute {
   handlers: RpdHttpHandler[];
 }
 
-export type RpdHttpMethod = "get" | "post" | "put" | "delete" | "patch";
+export type RpdHttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
 
 export interface RpdHttpHandler {
   code: string;
-  config: any;
+  config?: any;
 }
 
 export interface IRpdDataAccessor<T = any> {

package/src/utilities/fsUtility.ts

@@ -0,0 +1,62 @@
+import fs from 'fs';
+
+export async function readFile(path: string): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, null, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data);
+      }
+    })
+  })
+}
+
+export async function copyFile(fromPath: string, toPath: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.copyFile(fromPath, toPath, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    })
+  })
+}
+
+export async function removeFile(path: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.rm(path, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    })
+  })
+}
+
+export async function moveFile(fromPath: string, toPath: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.rename(fromPath, toPath, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    })
+  })
+}
+
+export async function appendFile(path: string, data: ArrayBuffer): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.appendFile(path, Buffer.from(data), (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    })
+  })
+
+}

package/src/utilities/jwtUtility.ts

@@ -1,16 +1,30 @@
+import { sign, verify, decode, Secret } from "jsonwebtoken";
+import { encode as base64Encode } from "~/deno-std/encoding/base64";
+import crypto from "crypto";
 
-export function getJWTKey() {
-  return "";
+export function createJwt(payload: Record<string, any>, secret: Secret) {
+  return sign(payload, secret, {
+    algorithm: 'HS512',
+  });
 }
 
-export async function createJWT(payload: Record<string, any>) {
-  return "";
+export function verifyJwt(token: string, secret: Secret) {
+  return verify(token, secret, {
+    algorithms: ['HS512'],
+  });
 }
 
-export async function verifyJWT(jwt: string) {
-  return {};
+export function decodeJwt(token: string) {
+  return decode(token, { complete: true});
 }
 
-export async function decodeJWT(jwt: string) {
-  return { header: {}, payload: {}, signature: {} };
+export async function generateJwtSecretKey() {
+  const key = await crypto.subtle.generateKey(
+    { name: "HMAC", hash: "SHA-512" },
+    true,
+    ["sign", "verify"],
+  );
+  
+  const exportedKey = await crypto.subtle.exportKey("raw", key);
+  return base64Encode(exportedKey);
 }