@ruiapp/rapid-core 0.1.3 → 0.1.4

package/dist/core/http/formDataParser.d.ts

@@ -0,0 +1,22 @@
+export type BodyData = Record<string, string | File | (string | File)[]>;
+export type ParseBodyOptions = {
+    /**
+     * Parse all fields with multiple values should be parsed as an array.
+     * @default false
+     * @example
+     * ```ts
+     * const data = new FormData()
+     * data.append('file', 'aaa')
+     * data.append('file', 'bbb')
+     * data.append('message', 'hello')
+     * ```
+     *
+     * If `all` is `false`:
+     * parseBody should return `{ file: 'bbb', message: 'hello' }`
+     *
+     * If `all` is `true`:
+     * parseBody should return `{ file: ['aaa', 'bbb'], message: 'hello' }`
+     */
+    all?: boolean;
+};
+export declare const parseFormDataBody: <T extends BodyData = BodyData>(request: Request, options?: ParseBodyOptions) => Promise<T>;

package/dist/core/providers/runtimeProvider.d.ts

@@ -0,0 +1,4 @@
+export interface IRuntimeProvider {
+    copyFile(fromPath: string, toPath: string): Promise<void>;
+    removeFile(path: string): Promise<void>;
+}

package/dist/core/routeContext.d.ts

@@ -8,7 +8,6 @@ export declare class RouteContext {
     readonly state: Record<string, any>;
     method: string;
     path: string;
-    status: HttpStatus;
     params: Record<string, string>;
     constructor(request: RapidRequest);
     set(headerName: string, headerValue: string): void;

package/dist/index.js

@@ -3,6 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _ = require('lodash');
+var path = require('path');
+var fs = require('fs');
+var uuid = require('uuid');
 var Router = require('koa-tree-router');
 var qs = require('qs');
 var jsonwebtoken = require('jsonwebtoken');
@@ -30,6 +33,8 @@ function _interopNamespace(e) {
 }
 
 var ___namespace = /*#__PURE__*/_interopNamespace(_);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
@@ -1034,20 +1039,20 @@ async function updateEntityById(server, dataAccessor, options) {
     return updatedEntity;
 }
 
-const code$l = "listMetaModels";
-async function handler$g(plugin, ctx, options) {
+const code$p = "listMetaModels";
+async function handler$j(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$g
+  code: code$p,
+  handler: handler$j
 });
 
-const code$k = "getMetaModelDetail";
-async function handler$f(plugin, ctx, options) {
+const code$o = "getMetaModelDetail";
+async function handler$i(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -1055,33 +1060,33 @@ async function handler$f(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$f
+  code: code$o,
+  handler: handler$i
 });
 
 /**
  * Meta manager plugin
  */
-const code$j = "metaManager";
-const description$4 = "metaManager";
-const extendingAbilities$4 = [];
-const configurableTargets$4 = [];
-const configurations$4 = [];
-let _plugin$4;
-async function initPlugin$4(plugin, server) {
-    _plugin$4 = plugin;
-}
-async function registerHttpHandlers$4(server) {
-    server.registerHttpHandler(_plugin$4, listMetaModels);
-    server.registerHttpHandler(_plugin$4, getMetaModelDetail);
-}
-async function registerEventHandlers$3(server) {
+const code$n = "metaManager";
+const description$5 = "metaManager";
+const extendingAbilities$5 = [];
+const configurableTargets$5 = [];
+const configurations$5 = [];
+let _plugin$5;
+async function initPlugin$5(plugin, server) {
+    _plugin$5 = plugin;
+}
+async function registerHttpHandlers$5(server) {
+    server.registerHttpHandler(_plugin$5, listMetaModels);
+    server.registerHttpHandler(_plugin$5, getMetaModelDetail);
+}
+async function registerEventHandlers$4(server) {
     server.registerEventHandler("entity.create", handleEntityCreateEvent.bind(null, server));
     server.registerEventHandler("entity.update", handleEntityUpdateEvent.bind(null, server));
     server.registerEventHandler("entity.delete", handleEntityDeleteEvent.bind(null, server));
 }
 async function handleEntityCreateEvent(server, sender, payload) {
-    if (sender === _plugin$4) {
+    if (sender === _plugin$5) {
         return;
     }
     if (payload.namespace === "meta" && payload.modelSingularCode === "model") {
@@ -1089,7 +1094,7 @@ async function handleEntityCreateEvent(server, sender, payload) {
     }
 }
 async function handleEntityUpdateEvent(server, sender, payload) {
-    if (sender === _plugin$4) {
+    if (sender === _plugin$5) {
         return;
     }
     if (payload.namespace === "meta" && payload.modelSingularCode === "model") {
@@ -1097,7 +1102,7 @@ async function handleEntityUpdateEvent(server, sender, payload) {
     }
 }
 async function handleEntityDeleteEvent(server, sender, payload) {
-    if (sender === _plugin$4) {
+    if (sender === _plugin$5) {
         return;
     }
     if (payload.namespace !== "meta") {
@@ -1130,7 +1135,7 @@ async function handleEntityDeleteEvent(server, sender, payload) {
         }
     }
 }
-async function configureModels$3(server, applicationConfig) {
+async function configureModels$4(server, applicationConfig) {
     try {
         const models = await listCollections(server, applicationConfig);
         server.appendApplicationConfig({ models });
@@ -1149,7 +1154,7 @@ function listCollections(server, applicationConfig) {
         properties: model.properties.map((item) => item.code),
     });
 }
-async function onApplicationLoaded$5(server, applicationConfig) {
+async function onApplicationLoaded$6(server, applicationConfig) {
     console.log("metaManager.onApplicationLoaded");
     await syncDatabaseSchema(server, applicationConfig);
 }
@@ -1341,16 +1346,16 @@ const pgPropertyTypeColumnMap = {
 
 var metaManager = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  description: description$4,
-  extendingAbilities: extendingAbilities$4,
-  configurableTargets: configurableTargets$4,
-  configurations: configurations$4,
-  initPlugin: initPlugin$4,
-  registerHttpHandlers: registerHttpHandlers$4,
-  registerEventHandlers: registerEventHandlers$3,
-  configureModels: configureModels$3,
-  onApplicationLoaded: onApplicationLoaded$5
+  code: code$n,
+  description: description$5,
+  extendingAbilities: extendingAbilities$5,
+  configurableTargets: configurableTargets$5,
+  configurations: configurations$5,
+  initPlugin: initPlugin$5,
+  registerHttpHandlers: registerHttpHandlers$5,
+  registerEventHandlers: registerEventHandlers$4,
+  configureModels: configureModels$4,
+  onApplicationLoaded: onApplicationLoaded$6
 });
 
 function mergeInput(defaultInput, input, fixedInput) {
@@ -1418,9 +1423,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$i = "findCollectionEntities";
-async function handler$e(plugin, ctx, options) {
-    await runCollectionEntityHttpHandler(ctx, options, code$i, async (dataAccessor, input) => {
+const code$m = "findCollectionEntities";
+async function handler$h(plugin, ctx, options) {
+    await runCollectionEntityHttpHandler(ctx, options, code$m, async (dataAccessor, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         const entities = await findEntities(ctx.server, dataAccessor, input);
         const result = { list: entities };
@@ -1435,13 +1440,13 @@ async function handler$e(plugin, ctx, options) {
 
 var findCollectionEntitiesHttpHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$e
+  code: code$m,
+  handler: handler$h
 });
 
-const code$h = "findCollectionEntityById";
-async function handler$d(plugin, ctx, options) {
-    console.debug(`Running ${code$h} handler...`);
+const code$l = "findCollectionEntityById";
+async function handler$g(plugin, ctx, options) {
+    console.debug(`Running ${code$l} handler...`);
     const { server, input } = ctx;
     const { id } = input;
     const dataAccessor = server.getDataAccessor(options);
@@ -1462,13 +1467,13 @@ async function handler$d(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$d
+  code: code$l,
+  handler: handler$g
 });
 
-const code$g = "countCollectionEntities";
-async function handler$c(plugin, ctx, options) {
-    await runCollectionEntityHttpHandler(ctx, options, code$g, (dataAccessor, input) => {
+const code$k = "countCollectionEntities";
+async function handler$f(plugin, ctx, options) {
+    await runCollectionEntityHttpHandler(ctx, options, code$k, (dataAccessor, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         return dataAccessor.count(input);
     });
@@ -1476,15 +1481,15 @@ async function handler$c(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$c
+  code: code$k,
+  handler: handler$f
 });
 
-const code$f = "createCollectionEntity";
-async function handler$b(plugin, ctx, options) {
+const code$j = "createCollectionEntity";
+async function handler$e(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$f} handler...`);
+    console.debug(`Running ${code$j} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -1507,15 +1512,15 @@ async function handler$b(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$b
+  code: code$j,
+  handler: handler$e
 });
 
-const code$e = "createCollectionEntitiesBatch";
-async function handler$a(plugin, ctx, options) {
+const code$i = "createCollectionEntitiesBatch";
+async function handler$d(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$e} handler...`);
+    console.debug(`Running ${code$i} handler...`);
     const { entities } = input;
     if (!_.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -1546,8 +1551,8 @@ async function handler$a(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$a
+  code: code$i,
+  handler: handler$d
 });
 
 function getEntityPartChanges(before, after) {
@@ -1571,11 +1576,11 @@ function getEntityPartChanges(before, after) {
     return changed;
 }
 
-const code$d = "updateCollectionEntityById";
-async function handler$9(plugin, ctx, options) {
+const code$h = "updateCollectionEntityById";
+async function handler$c(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$d} handler...`);
+    console.debug(`Running ${code$h} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -1605,13 +1610,13 @@ async function handler$9(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$9
+  code: code$h,
+  handler: handler$c
 });
 
-const code$c = "deleteCollectionEntityById";
-async function handler$8(plugin, ctx, options) {
-    console.debug(`Running ${code$c} handler...`);
+const code$g = "deleteCollectionEntityById";
+async function handler$b(plugin, ctx, options) {
+    console.debug(`Running ${code$g} handler...`);
     const { server, input } = ctx;
     const dataAccessor = server.getDataAccessor(options);
     const id = input.id;
@@ -1632,16 +1637,16 @@ async function handler$8(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$8
+  code: code$g,
+  handler: handler$b
 });
 
-const code$b = "addEntityRelations";
-async function handler$7(plugin, ctx, options) {
+const code$f = "addEntityRelations";
+async function handler$a(plugin, ctx, options) {
     const { server, input } = ctx;
     const { queryBuilder } = server;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$b} handler...`);
+    console.debug(`Running ${code$f} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -1684,16 +1689,16 @@ async function handler$7(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$7
+  code: code$f,
+  handler: handler$a
 });
 
-const code$a = "removeEntityRelations";
-async function handler$6(plugin, ctx, options) {
+const code$e = "removeEntityRelations";
+async function handler$9(plugin, ctx, options) {
     const { server, input } = ctx;
     const { queryBuilder } = server;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$a} handler...`);
+    console.debug(`Running ${code$e} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -1733,15 +1738,15 @@ async function handler$6(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$6
+  code: code$e,
+  handler: handler$9
 });
 
-const code$9 = "queryDatabase";
-async function handler$5(plugin, ctx, options) {
+const code$d = "queryDatabase";
+async function handler$8(plugin, ctx, options) {
     const { server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$9} handler...`);
+    console.debug(`Running ${code$d} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -1757,8 +1762,8 @@ async function handler$5(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$5
+  code: code$d,
+  handler: handler$8
 });
 
 /**
@@ -1766,11 +1771,11 @@ var queryDatabase = /*#__PURE__*/Object.freeze({
  * This plugin provide:
  * - routes for manage data in database.
  */
-const code$8 = "dataManager";
-const description$3 = "对数据进行管理，提供增删改查等接口。";
-const extendingAbilities$3 = [];
-const configurableTargets$3 = [];
-const configurations$3 = [];
+const code$c = "dataManager";
+const description$4 = "对数据进行管理，提供增删改查等接口。";
+const extendingAbilities$4 = [];
+const configurableTargets$4 = [];
+const configurations$4 = [];
 const routeConfigs = [
     {
         code: "createBatch",
@@ -1827,21 +1832,21 @@ const routeConfigs = [
         handlerCode: "deleteCollectionEntityById",
     },
 ];
-let _plugin$3;
-async function initPlugin$3(plugin, server) {
-    _plugin$3 = plugin;
+let _plugin$4;
+async function initPlugin$4(plugin, server) {
+    _plugin$4 = plugin;
 }
-async function registerHttpHandlers$3(server) {
-    server.registerHttpHandler(_plugin$3, findCollectionEntitiesHttpHandler);
-    server.registerHttpHandler(_plugin$3, findCollectionEntityById);
-    server.registerHttpHandler(_plugin$3, countCollectionEntities);
-    server.registerHttpHandler(_plugin$3, createCollectionEntity);
-    server.registerHttpHandler(_plugin$3, createCollectionEntitiesBatch);
-    server.registerHttpHandler(_plugin$3, updateCollectionEntityById);
-    server.registerHttpHandler(_plugin$3, addEntityRelations);
-    server.registerHttpHandler(_plugin$3, removeEntityRelations);
-    server.registerHttpHandler(_plugin$3, deleteCollectionEntityById);
-    server.registerHttpHandler(_plugin$3, queryDatabase);
+async function registerHttpHandlers$4(server) {
+    server.registerHttpHandler(_plugin$4, findCollectionEntitiesHttpHandler);
+    server.registerHttpHandler(_plugin$4, findCollectionEntityById);
+    server.registerHttpHandler(_plugin$4, countCollectionEntities);
+    server.registerHttpHandler(_plugin$4, createCollectionEntity);
+    server.registerHttpHandler(_plugin$4, createCollectionEntitiesBatch);
+    server.registerHttpHandler(_plugin$4, updateCollectionEntityById);
+    server.registerHttpHandler(_plugin$4, addEntityRelations);
+    server.registerHttpHandler(_plugin$4, removeEntityRelations);
+    server.registerHttpHandler(_plugin$4, deleteCollectionEntityById);
+    server.registerHttpHandler(_plugin$4, queryDatabase);
 }
 async function configureRoutes$3(server, applicationConfig) {
     const { models } = applicationConfig;
@@ -1870,11 +1875,158 @@ async function configureRoutes$3(server, applicationConfig) {
     });
     server.appendApplicationConfig({ routes });
 }
-async function onApplicationLoaded$4(server, application) {
+async function onApplicationLoaded$5(server, application) {
     console.log("[dataManager.onApplicationLoaded]");
 }
 
 var dataManager = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$c,
+  description: description$4,
+  extendingAbilities: extendingAbilities$4,
+  configurableTargets: configurableTargets$4,
+  configurations: configurations$4,
+  initPlugin: initPlugin$4,
+  registerHttpHandlers: registerHttpHandlers$4,
+  configureRoutes: configureRoutes$3,
+  onApplicationLoaded: onApplicationLoaded$5
+});
+
+async function readFile(path) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].readFile(path, null, (err, data) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(data);
+            }
+        });
+    });
+}
+async function appendFile(path, data) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].appendFile(path, Buffer.from(data), (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+
+const code$b = "downloadDocument";
+async function handler$7(plugin, ctx, options) {
+    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__default["default"].join(server.config.localFileStoragePath, fileKey);
+    const attachmentFileName = document.name;
+    response.body = await readFile(filePathName);
+    response.headers.set("Content-Disposition", `attachment; filename="${encodeURIComponent(attachmentFileName)}"`);
+}
+
+var downloadDocumentHttpHandler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$b,
+  handler: handler$7
+});
+
+const code$a = "downloadFile";
+async function handler$6(plugin, ctx, options) {
+    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__default["default"].join(server.config.localFileStoragePath, fileKey);
+    const attachmentFileName = input.fileName || path__default["default"].basename(fileKey);
+    response.body = await readFile(filePathName);
+    response.headers.set("Content-Disposition", `attachment; filename="${encodeURIComponent(attachmentFileName)}"`);
+}
+
+var downloadFileHttpHandler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$a,
+  handler: handler$6
+});
+
+const code$9 = "uploadFile";
+async function handler$5(plugin, ctx, options) {
+    const { server, applicationConfig, routerContext, input } = ctx;
+    let file = 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__default["default"].extname(file.name);
+    const fileKey = `${uuid.v1()}${extName}`;
+    const filePathName = path__default["default"].join(server.config.localFileStoragePath, fileKey);
+    const fileBuffer = await file.arrayBuffer();
+    await appendFile(filePathName, fileBuffer);
+    ctx.output = { ok: true, fileKey };
+}
+
+var uploadFileHttpHandler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$9,
+  handler: handler$5
+});
+
+/**
+ * File manager plugin
+ */
+const code$8 = "fileManager";
+const description$3 = "fileManager";
+const extendingAbilities$3 = [];
+const configurableTargets$3 = [];
+const configurations$3 = [];
+let _plugin$3;
+async function initPlugin$3(plugin, server) {
+    _plugin$3 = plugin;
+}
+async function registerHttpHandlers$3(server) {
+    server.registerHttpHandler(_plugin$3, downloadDocumentHttpHandler);
+    server.registerHttpHandler(_plugin$3, downloadFileHttpHandler);
+    server.registerHttpHandler(_plugin$3, uploadFileHttpHandler);
+}
+async function registerEventHandlers$3(server) {
+}
+async function configureModels$3(server, applicationConfig) {
+}
+async function onApplicationLoaded$4(server, applicationConfig) {
+    console.log("fileManager.onApplicationLoaded");
+}
+
+var fileManager = /*#__PURE__*/Object.freeze({
   __proto__: null,
   code: code$8,
   description: description$3,
@@ -1883,7 +2035,8 @@ var dataManager = /*#__PURE__*/Object.freeze({
   configurations: configurations$3,
   initPlugin: initPlugin$3,
   registerHttpHandlers: registerHttpHandlers$3,
-  configureRoutes: configureRoutes$3,
+  registerEventHandlers: registerEventHandlers$3,
+  configureModels: configureModels$3,
   onApplicationLoaded: onApplicationLoaded$4
 });
 
@@ -1990,16 +2143,7 @@ async function buildRoutes(server, applicationConfig) {
                 requestMethod === "PATCH")) {
                 const body = request.body;
                 if (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, body.value);
-                    }
+                    Object.assign(input, body.value);
                 }
             }
             // Normalize input value
@@ -2022,11 +2166,8 @@ async function buildRoutes(server, applicationConfig) {
                     await result;
                 }
             }
-            if (handlerContext.status) {
-                routerContext.status = handlerContext.status;
-            }
             if (!isNullOrUndefined(handlerContext.output)) {
-                routerContext.json(handlerContext.output);
+                routerContext.json(handlerContext.output, handlerContext.status);
             }
         });
     });
@@ -2887,6 +3028,7 @@ const plugins = [];
 async function loadPlugins() {
     plugins.push(metaManager);
     plugins.push(dataManager);
+    plugins.push(fileManager);
     plugins.push(routeManager);
     plugins.push(webhooks$1);
     plugins.push(authManager);
@@ -3064,7 +3206,6 @@ class RouteContext {
     state;
     method;
     path;
-    status;
     params;
     constructor(request) {
         this.request = request;
@@ -3086,6 +3227,61 @@ class RouteContext {
     }
 }
 
+const parseFormDataBody = async (request, options = { all: false }) => {
+    const contentType = request.headers.get('Content-Type');
+    if (isFormDataContent(contentType)) {
+        return parseFormData(request, options);
+    }
+    return {};
+};
+function isFormDataContent(contentType) {
+    if (contentType === null) {
+        return false;
+    }
+    return (contentType.startsWith('multipart/form-data') ||
+        contentType.startsWith('application/x-www-form-urlencoded'));
+}
+async function parseFormData(request, options) {
+    const formData = await request.formData();
+    if (formData) {
+        return convertFormDataToBodyData(formData, options);
+    }
+    return {};
+}
+function convertFormDataToBodyData(formData, options) {
+    const form = {};
+    formData.forEach((value, key) => {
+        const shouldParseAllValues = options.all || key.endsWith('[]');
+        if (!shouldParseAllValues) {
+            form[key] = value;
+        }
+        else {
+            handleParsingAllValues(form, key, value);
+        }
+    });
+    return form;
+}
+const handleParsingAllValues = (form, key, value) => {
+    if (form[key] && isArrayField(form[key])) {
+        appendToExistingArray(form[key], value);
+    }
+    else if (form[key]) {
+        convertToNewArray(form, key, value);
+    }
+    else {
+        form[key] = value;
+    }
+};
+function isArrayField(field) {
+    return Array.isArray(field);
+}
+const appendToExistingArray = (arr, value) => {
+    arr.push(value);
+};
+const convertToNewArray = (form, key, value) => {
+    form[key] = [form[key], value];
+};
+
 const GlobalRequest = global.Request;
 class RapidRequest {
     #raw;
@@ -3125,7 +3321,7 @@ class RapidRequest {
             else if (contentType.startsWith("multipart/form-data")) {
                 this.#body = {
                     type: "form-data",
-                    value: await req.formData(),
+                    value: await parseFormDataBody(req),
                 };
             }
         }

package/dist/plugins/fileManager/httpHandlers/downloadDocument.d.ts

@@ -0,0 +1,4 @@
+import { IPluginInstance } from "~/types";
+import { HttpHandlerContext } from "~/core/httpHandler";
+export declare const code = "downloadDocument";
+export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/httpHandlers/downloadFile.d.ts

@@ -0,0 +1,4 @@
+import { IPluginInstance } from "~/types";
+import { HttpHandlerContext } from "~/core/httpHandler";
+export declare const code = "downloadFile";
+export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/httpHandlers/uploadFile.d.ts

@@ -0,0 +1,4 @@
+import { IPluginInstance } from "~/types";
+import { HttpHandlerContext } from "~/core/httpHandler";
+export declare const code = "uploadFile";
+export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/mod.d.ts

@@ -0,0 +1,15 @@
+/**
+ * File manager plugin
+ */
+import { IPluginInstance, RpdApplicationConfig } from "~/types";
+import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+export declare const code = "fileManager";
+export declare const description = "fileManager";
+export declare const extendingAbilities: RpdServerPluginExtendingAbilities[];
+export declare const configurableTargets: RpdServerPluginConfigurableTargetOptions[];
+export declare const configurations: RpdConfigurationItemOptions[];
+export declare function initPlugin(plugin: IPluginInstance, server: IRpdServer): Promise<void>;
+export declare function registerHttpHandlers(server: IRpdServer): Promise<void>;
+export declare function registerEventHandlers(server: IRpdServer): Promise<void>;
+export declare function configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
+export declare function onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;

package/dist/utilities/fsUtility.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare function readFile(path: string): Promise<Buffer>;
+export declare function copyFile(fromPath: string, toPath: string): Promise<void>;
+export declare function removeFile(path: string): Promise<void>;
+export declare function moveFile(fromPath: string, toPath: string): Promise<void>;
+export declare function appendFile(path: string, data: ArrayBuffer): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "",
   "main": "dist/index.js",
   "keywords": [],
@@ -20,7 +20,8 @@
     "jsonwebtoken": "^9.0.2",
     "koa-tree-router": "^0.12.1",
     "lodash": "^4.17.21",
-    "qs": "^6.11.0"
+    "qs": "^6.11.0",
+    "uuid": "^9.0.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup --config",

package/src/core/http/formDataParser.ts

@@ -0,0 +1,101 @@
+import type { RapidRequest } from '../request'
+
+export type BodyData = Record<string, string | File | (string | File)[]>
+export type ParseBodyOptions = {
+  /**
+   * Parse all fields with multiple values should be parsed as an array.
+   * @default false
+   * @example
+   * ```ts
+   * const data = new FormData()
+   * data.append('file', 'aaa')
+   * data.append('file', 'bbb')
+   * data.append('message', 'hello')
+   * ```
+   *
+   * If `all` is `false`:
+   * parseBody should return `{ file: 'bbb', message: 'hello' }`
+   *
+   * If `all` is `true`:
+   * parseBody should return `{ file: ['aaa', 'bbb'], message: 'hello' }`
+   */
+  all?: boolean
+}
+
+export const parseFormDataBody = async <T extends BodyData = BodyData>(
+  request: Request,
+  options: ParseBodyOptions = { all: false }
+): Promise<T> => {
+  const contentType = request.headers.get('Content-Type')
+
+  if (isFormDataContent(contentType)) {
+    return parseFormData<T>(request, options)
+  }
+
+  return {} as T
+}
+
+function isFormDataContent(contentType: string | null): boolean {
+  if (contentType === null) {
+    return false
+  }
+
+  return (
+    contentType.startsWith('multipart/form-data') ||
+    contentType.startsWith('application/x-www-form-urlencoded')
+  )
+}
+
+async function parseFormData<T extends BodyData = BodyData>(
+  request: Request,
+  options: ParseBodyOptions
+): Promise<T> {
+  const formData = await (request as Request).formData()
+
+  if (formData) {
+    return convertFormDataToBodyData<T>(formData, options)
+  }
+
+  return {} as T
+}
+
+function convertFormDataToBodyData<T extends BodyData = BodyData>(
+  formData: FormData,
+  options: ParseBodyOptions
+): T {
+  const form: BodyData = {}
+
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith('[]')
+
+    if (!shouldParseAllValues) {
+      form[key] = value
+    } else {
+      handleParsingAllValues(form, key, value)
+    }
+  })
+
+  return form as T
+}
+
+const handleParsingAllValues = (form: BodyData, key: string, value: FormDataEntryValue): void => {
+  if (form[key] && isArrayField(form[key])) {
+    appendToExistingArray(form[key] as (string | File)[], value)
+  } else if (form[key]) {
+    convertToNewArray(form, key, value)
+  } else {
+    form[key] = value
+  }
+}
+
+function isArrayField(field: unknown): field is (string | File)[] {
+  return Array.isArray(field)
+}
+
+const appendToExistingArray = (arr: (string | File)[], value: FormDataEntryValue): void => {
+  arr.push(value)
+}
+
+const convertToNewArray = (form: BodyData, key: string, value: FormDataEntryValue): void => {
+  form[key] = [form[key] as string | File, value]
+}

package/src/core/pluginManager.ts

@@ -2,6 +2,7 @@ import { RpdApplicationConfig } from "~/types";
 import Plugin from "./plugin";
 import * as metaManager from "~/plugins/metaManager/mod";
 import * as dataManager from "~/plugins/dataManager/mod";
+import * as fileManager from "~/plugins/fileManager/mod";
 import * as routeManager from "~/plugins/routeManager/mod";
 import * as webhooks from "~/plugins/webhooks/mod";
 import * as authManager from "~/plugins/authManager/mod";
@@ -12,6 +13,7 @@ const plugins: IRpdServerPlugin[] = [];
 export async function loadPlugins() {
   plugins.push(metaManager);
   plugins.push(dataManager);
+  plugins.push(fileManager);
   plugins.push(routeManager);
   plugins.push(webhooks);
   plugins.push(authManager);

package/src/core/providers/runtimeProvider.ts

@@ -0,0 +1,5 @@
+export interface IRuntimeProvider {
+  copyFile(fromPath: string, toPath: string): Promise<void>;
+
+  removeFile(path: string): Promise<void>;
+}

package/src/core/request.ts

@@ -1,4 +1,5 @@
 import qs from "qs";
+import { parseFormDataBody } from "./http/formDataParser";
 
 export const GlobalRequest = global.Request;
 
@@ -46,7 +47,7 @@ export class RapidRequest {
       } else if (contentType.startsWith("multipart/form-data")) {
         this.#body = {
           type: "form-data",
-          value: await req.formData(),
+          value: await parseFormDataBody(req),
         }
       }
     } else {

package/src/core/routeContext.ts

@@ -11,7 +11,6 @@ export class RouteContext {
   readonly state: Record<string, any>;
   method: string;
   path: string;
-  status: HttpStatus;
   params: Record<string, string>;
 
   constructor(request: RapidRequest) {

package/src/core/routesBuilder.ts

@@ -47,15 +47,7 @@ export async function buildRoutes(
         ) {
           const body = request.body;
           if (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, body.value);
-            }
+            Object.assign(input, body.value);
           }
         }
 
@@ -84,12 +76,8 @@ export async function buildRoutes(
           }
         }
 
-        if (handlerContext.status) {
-          routerContext.status = handlerContext.status;
-        }
-
         if (!isNullOrUndefined(handlerContext.output)) {
-          routerContext.json(handlerContext.output);
+          routerContext.json(handlerContext.output, handlerContext.status);
         }
       },
     );

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/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();
+      }
+    })
+  })
+
+}