@ruiapp/rapid-core 0.1.19 → 0.1.21

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _ = require('lodash');
+var lodash = require('lodash');
 var events = require('events');
 var Router = require('koa-tree-router');
 var qs = require('qs');
@@ -14,25 +14,6 @@ var uuid = require('uuid');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var ___namespace = /*#__PURE__*/_interopNamespace(_);
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
@@ -46,10 +27,12 @@ function fixBigIntJSONSerialize() {
 }
 
 class DataAccessor {
+    #logger;
     #model;
     #queryBuilder;
     #databaseAccessor;
-    constructor(databaseAccessor, options) {
+    constructor(server, databaseAccessor, options) {
+        this.#logger = server.getLogger();
         this.#databaseAccessor = databaseAccessor;
         this.#queryBuilder = options.queryBuilder;
         this.#model = options.model;
@@ -63,7 +46,7 @@ class DataAccessor {
         };
         const query = this.#queryBuilder.insert(this.#model, options);
         const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
-        return ___namespace.first(result);
+        return lodash.first(result);
     }
     async updateById(id, entity) {
         const options = {
@@ -78,17 +61,17 @@ class DataAccessor {
         };
         const query = this.#queryBuilder.update(this.#model, options);
         const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
-        return ___namespace.first(result);
+        return lodash.first(result);
     }
     async find(options) {
-        console.debug(`DataAccessor '${this.#model.singularCode}' find with options:`, options);
+        this.#logger.debug(`Finding '${this.#model.singularCode}' entity.`, { options });
         const query = this.#queryBuilder.select(this.#model, options);
         return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
     }
     async findOne(options) {
-        ___namespace.set(options, "pagination.limit", 1);
+        lodash.set(options, "pagination.limit", 1);
         const list = await this.find(options);
-        return ___namespace.first(list);
+        return lodash.first(list);
     }
     async findById(id) {
         const options = {
@@ -102,12 +85,12 @@ class DataAccessor {
         };
         const query = this.#queryBuilder.select(this.#model, options);
         const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
-        return ___namespace.first(result);
+        return lodash.first(result);
     }
     async count(options) {
         const query = this.#queryBuilder.count(this.#model, options);
         const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
-        const row = ___namespace.first(result);
+        const row = lodash.first(result);
         if (row) {
             return row;
         }
@@ -233,7 +216,7 @@ class QueryBuilder {
             }
             let property = null;
             if (model) {
-                property = ___namespace.find(model.properties, (e) => e.code === propertyName);
+                property = lodash.find(model.properties, (e) => e.code === propertyName);
             }
             if (property && property.type === "json") {
                 params.push(JSON.stringify(entity[propertyName]));
@@ -268,7 +251,7 @@ class QueryBuilder {
             }
             let property = null;
             if (model) {
-                property = ___namespace.find(model.properties, (e) => (e.columnName || e.code) === propertyName);
+                property = lodash.find(model.properties, (e) => (e.columnName || e.code) === propertyName);
             }
             if (property && property.type === "json") {
                 params.push(JSON.stringify(entity[propertyName]));
@@ -554,6 +537,14 @@ class PluginManager {
             }
         }
     }
+    /** 在接收到HTTP请求，执行 actions 前调用。 */
+    async beforeRunRouteActions(handlerContext) {
+        for (const plugin of this.#plugins) {
+            if (plugin.beforeRunRouteActions) {
+                await plugin.beforeRunRouteActions(this.#server, handlerContext);
+            }
+        }
+    }
 }
 
 class EventManager {
@@ -580,6 +571,7 @@ function isNullOrUndefined(val) {
 }
 
 async function buildRoutes(server, applicationConfig) {
+    const logger = server.getLogger();
     const router = new Router__default["default"]();
     let baseUrl = server.config.baseUrl;
     if (baseUrl) {
@@ -596,6 +588,7 @@ async function buildRoutes(server, applicationConfig) {
         }
         const routePath = baseUrl + routeConfig.endpoint;
         router[routeConfig.method.toLowerCase()](routePath, async (routerContext, next) => {
+            routerContext.routeConfig = lodash.cloneDeep(routeConfig);
             const { request, params } = routerContext;
             let search = request.url.search;
             if (search && search.startsWith("?")) {
@@ -612,21 +605,27 @@ async function buildRoutes(server, applicationConfig) {
                 }
             }
             // Normalize input value
-            console.debug(`${requestMethod} ${request.url.toString()}`);
-            console.debug(`input: ${JSON.stringify(input)}`);
+            logger.debug("Processing rapid request.", {
+                method: requestMethod,
+                url: request.url.toString(),
+                input
+            });
             let handlerContext = {
+                logger,
                 routerContext,
                 next,
                 server,
                 applicationConfig,
                 input,
             };
-            for (const handlerConfig of routeConfig.actions) {
-                const handler = server.getActionHandlerByCode(handlerConfig.code);
+            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: " + handlerConfig.code);
+                    throw new Error("Unknown handler: " + actionCode);
                 }
-                const result = handler(handlerContext, handlerConfig.config);
+                const result = handler(handlerContext, actionConfig.config);
                 if (result instanceof Promise) {
                     await result;
                 }
@@ -645,12 +644,12 @@ function mergeHeaders(target, source) {
             target.set(keyValuePair[0], keyValuePair[1]);
         }
     }
-    else if (_.isArray(source)) {
+    else if (lodash.isArray(source)) {
         for (const keyValuePair of source) {
             target.set(keyValuePair[0], keyValuePair[1]);
         }
     }
-    else if (_.isObject(source)) {
+    else if (lodash.isObject(source)) {
         Object.entries(source).forEach(([key, value]) => target.set(key, value));
     }
     return target;
@@ -698,13 +697,16 @@ class RapidResponse {
 }
 
 class RouteContext {
+    #logger;
     request;
     response;
     state;
     method;
     path;
     params;
-    constructor(request) {
+    routeConfig;
+    constructor(server, request) {
+        this.#logger = server.getLogger();
         this.request = request;
         this.state = {};
         this.response = new RapidResponse();
@@ -1016,6 +1018,7 @@ function setCookie(headers, cookie) {
 
 const GlobalRequest = global.Request;
 class RapidRequest {
+    #logger;
     #raw;
     #bodyParsed;
     #body;
@@ -1023,7 +1026,8 @@ class RapidRequest {
     #parsedCookies;
     method;
     url;
-    constructor(req) {
+    constructor(server, req) {
+        this.#logger = server.getLogger();
         this.#raw = req;
         this.method = req.method;
         this.url = new URL(req.url);
@@ -1031,7 +1035,7 @@ class RapidRequest {
     }
     async parseBody() {
         if (this.#bodyParsed) {
-            console.warn("Request body has been parsed. 'parseBody()' method should not be called more than once.");
+            this.#logger.warn("Request body has been parsed. 'parseBody()' method should not be called more than once.");
             return;
         }
         const requestMethod = this.method;
@@ -1739,7 +1743,7 @@ async function findEntities(server, dataAccessor, options) {
     const fieldsToSelect = [];
     const relationPropertiesToSelect = [];
     if (options.properties) {
-        ___namespace.forEach(options.properties, (propertyCode) => {
+        lodash.forEach(options.properties, (propertyCode) => {
             const property = model.properties.find((e) => e.code === propertyCode);
             if (!property) {
                 throw new Error(`Collection '${model.namespace}.${model.singularCode}' does not have a property '${propertyCode}'.`);
@@ -1780,8 +1784,8 @@ async function findEntities(server, dataAccessor, options) {
                 }
                 if (isManyRelation) {
                     const relationLinks = await findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds);
-                    ___namespace.forEach(entities, (entity) => {
-                        entity[relationProperty.code] = ___namespace.filter(relationLinks, (link) => {
+                    lodash.forEach(entities, (entity) => {
+                        entity[relationProperty.code] = lodash.filter(relationLinks, (link) => {
                             return link[relationProperty.selfIdColumnName] == entity["id"];
                         }).map(link => mapDbRowToEntity(targetModel, link.targetEntity, false));
                     });
@@ -1793,7 +1797,7 @@ async function findEntities(server, dataAccessor, options) {
                     relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds);
                 }
                 else {
-                    const targetEntityIds = ___namespace.uniq(___namespace.reject(___namespace.map(entities, (entity) => entity[relationProperty.targetIdColumnName]), isNullOrUndefined));
+                    const targetEntityIds = lodash.uniq(lodash.reject(lodash.map(entities, (entity) => entity[relationProperty.targetIdColumnName]), isNullOrUndefined));
                     relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds);
                 }
                 const targetModel = server.getModel({
@@ -1801,12 +1805,12 @@ async function findEntities(server, dataAccessor, options) {
                 });
                 entities.forEach((entity) => {
                     if (isManyRelation) {
-                        entity[relationProperty.code] = ___namespace.filter(relatedEntities, (relatedEntity) => {
+                        entity[relationProperty.code] = lodash.filter(relatedEntities, (relatedEntity) => {
                             return relatedEntity[relationProperty.selfIdColumnName] == entity.id;
                         }).map(item => mapDbRowToEntity(targetModel, item, false));
                     }
                     else {
-                        entity[relationProperty.code] = mapDbRowToEntity(targetModel, ___namespace.find(relatedEntities, (relatedEntity) => {
+                        entity[relationProperty.code] = mapDbRowToEntity(targetModel, lodash.find(relatedEntities, (relatedEntity) => {
                             // TODO: id property code should be configurable.
                             return relatedEntity["id"] == entity[relationProperty.targetIdColumnName];
                         }), false);
@@ -1819,7 +1823,7 @@ async function findEntities(server, dataAccessor, options) {
 }
 async function findEntity(server, dataAccessor, options) {
     const entities = await findEntities(server, dataAccessor, options);
-    return ___namespace.first(entities);
+    return lodash.first(entities);
 }
 async function findById(server, dataAccessor, id, keepNonPropertyFields = false) {
     return await findEntity(server, dataAccessor, {
@@ -1845,7 +1849,7 @@ async function replaceFiltersWithFiltersOperator(server, model, filters) {
             replacedFilters.push(filter);
         }
         else if (operator === "exists" || operator === "notExists") {
-            const relationProperty = ___namespace.find(model.properties, (property) => property.code === filter.field);
+            const relationProperty = lodash.find(model.properties, (property) => property.code === filter.field);
             if (!relationProperty) {
                 throw new Error(`Invalid filters. Property '${filter.field}' was not found in model '${model.namespace}.${model.singularCode}'`);
             }
@@ -1890,7 +1894,7 @@ async function replaceFiltersWithFiltersOperator(server, model, filters) {
                     filters: filter.filters,
                     properties: ["id"],
                 });
-                const entityIds = ___namespace.map(entities, (entity) => entity["id"]);
+                const entityIds = lodash.map(entities, (entity) => entity["id"]);
                 replacedFilters.push({
                     field: relationProperty.targetIdColumnName,
                     operator: operator === "exists" ? "in" : "notIn",
@@ -1909,7 +1913,7 @@ async function replaceFiltersWithFiltersOperator(server, model, filters) {
                     filters: filter.filters,
                     properties: [relationProperty.selfIdColumnName],
                 });
-                const selfEntityIds = ___namespace.map(targetEntities, (entity) => entity[relationProperty.selfIdColumnName]);
+                const selfEntityIds = lodash.map(targetEntities, (entity) => entity[relationProperty.selfIdColumnName]);
                 replacedFilters.push({
                     field: "id",
                     operator: operator === "exists" ? "in" : "notIn",
@@ -1934,7 +1938,7 @@ async function replaceFiltersWithFiltersOperator(server, model, filters) {
                     filters: filter.filters,
                     properties: ['id'],
                 });
-                const targetEntityIds = ___namespace.map(targetEntities, (entity) => entity['id']);
+                const targetEntityIds = lodash.map(targetEntities, (entity) => entity['id']);
                 const command = `SELECT * FROM ${server.queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })} WHERE ${server.queryBuilder.quoteObject(relationProperty.targetIdColumnName)} = ANY($1::int[])`;
                 const params = [targetEntityIds];
                 const links = await server.queryDatabaseObject(command, params);
@@ -1971,8 +1975,8 @@ async function findManyRelationLinksViaLinkTable(server, targetModel, relationPr
         singularCode: targetModel.singularCode,
     });
     const targetEntities = await dataAccessor.find(findEntityOptions);
-    ___namespace.forEach(links, (link) => {
-        link.targetEntity = ___namespace.find(targetEntities, (e) => e["id"] == link[relationProperty.targetIdColumnName]);
+    lodash.forEach(links, (link) => {
+        link.targetEntity = lodash.find(targetEntities, (e) => e["id"] == link[relationProperty.targetIdColumnName]);
     });
     return links;
 }
@@ -2011,7 +2015,7 @@ async function createEntity(server, dataAccessor, options) {
     const { entity } = options;
     const oneRelationPropertiesToCreate = [];
     const manyRelationPropertiesToCreate = [];
-    ___namespace.keys(entity).forEach((propertyCode) => {
+    lodash.keys(entity).forEach((propertyCode) => {
         const property = model.properties.find((e) => e.code === propertyCode);
         if (!property) {
             // Unknown property
@@ -2030,7 +2034,7 @@ async function createEntity(server, dataAccessor, options) {
     // save one-relation properties
     for (const property of oneRelationPropertiesToCreate) {
         const fieldValue = entity[property.code];
-        if (___namespace.isObject(fieldValue)) {
+        if (lodash.isObject(fieldValue)) {
             if (!fieldValue["id"]) {
                 const targetDataAccessor = server.getDataAccessor({
                     singularCode: property.targetSingularCode,
@@ -2059,12 +2063,12 @@ async function createEntity(server, dataAccessor, options) {
             singularCode: property.targetSingularCode,
         });
         const relatedEntitiesToBeSaved = entity[property.code];
-        if (!___namespace.isArray(relatedEntitiesToBeSaved)) {
+        if (!lodash.isArray(relatedEntitiesToBeSaved)) {
             throw new Error(`Value of field '${property.code}' should be an array.`);
         }
         for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
             let relatedEntityId;
-            if (___namespace.isObject(relatedEntityToBeSaved)) {
+            if (lodash.isObject(relatedEntityToBeSaved)) {
                 relatedEntityId = relatedEntityToBeSaved["id"];
                 if (!relatedEntityId) {
                     // related entity is to be created
@@ -2138,7 +2142,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     }
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
-    ___namespace.keys(changes).forEach((propertyCode) => {
+    lodash.keys(changes).forEach((propertyCode) => {
         const property = model.properties.find((e) => e.code === propertyCode);
         if (!property) {
             // Unknown property
@@ -2156,7 +2160,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     const row = mapEntityToDbRow(model, changes);
     oneRelationPropertiesToUpdate.forEach(property => {
         const fieldValue = changes[property.code];
-        if (___namespace.isObject(fieldValue)) {
+        if (lodash.isObject(fieldValue)) {
             row[property.targetIdColumnName] = fieldValue["id"];
         }
         else {
@@ -2175,7 +2179,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
             singularCode: property.targetSingularCode,
         });
         const relatedEntitiesToBeSaved = changes[property.code];
-        if (!___namespace.isArray(relatedEntitiesToBeSaved)) {
+        if (!lodash.isArray(relatedEntitiesToBeSaved)) {
             throw new Error(`Value of field '${property.code}' should be an array.`);
         }
         if (property.linkTableName) {
@@ -2184,7 +2188,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         }
         for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
             let relatedEntityId;
-            if (___namespace.isObject(relatedEntityToBeSaved)) {
+            if (lodash.isObject(relatedEntityToBeSaved)) {
                 relatedEntityId = relatedEntityToBeSaved["id"];
                 if (!relatedEntityId) {
                     // related entity is to be created
@@ -2369,6 +2373,7 @@ class EntityManager {
 }
 
 class RapidServer {
+    #logger;
     #pluginManager;
     #plugins;
     #eventManager;
@@ -2384,6 +2389,7 @@ class RapidServer {
     databaseConfig;
     #buildedRoutes;
     constructor(options) {
+        this.#logger = options.logger;
         this.#pluginManager = new PluginManager(this);
         this.#eventManager = new EventManager();
         this.#middlewares = [];
@@ -2400,6 +2406,9 @@ class RapidServer {
         this.config = options.serverConfig;
         this.#plugins = options.plugins || [];
     }
+    getLogger() {
+        return this.#logger;
+    }
     getApplicationConfig() {
         return this.#applicationConfig;
     }
@@ -2407,12 +2416,13 @@ class RapidServer {
         const { models, routes } = config;
         if (models) {
             for (const model of models) {
-                const originalModel = ___namespace.find(this.#applicationConfig.models, (item) => item.singularCode == model.singularCode);
+                const originalModel = lodash.find(this.#applicationConfig.models, (item) => item.singularCode == model.singularCode);
                 if (originalModel) {
+                    lodash.merge(originalModel, lodash.omit(model, ["id", "maintainedBy", "namespace", "singularCode", "pluralCode", "schema", "tableName", "properties", "extensions"]));
                     originalModel.name = model.name;
                     const originalProperties = originalModel.properties;
                     for (const property of model.properties) {
-                        const originalProperty = ___namespace.find(originalProperties, (item) => item.code == property.code);
+                        const originalProperty = lodash.find(originalProperties, (item) => item.code == property.code);
                         if (originalProperty) {
                             originalProperty.name = property.name;
                         }
@@ -2428,7 +2438,7 @@ class RapidServer {
         }
         if (routes) {
             for (const route of routes) {
-                const originalRoute = ___namespace.find(this.#applicationConfig.routes, (item) => item.code == route.code);
+                const originalRoute = lodash.find(this.#applicationConfig.routes, (item) => item.code == route.code);
                 if (originalRoute) {
                     originalRoute.name = route.name;
                     originalRoute.actions = route.actions;
@@ -2439,8 +2449,24 @@ class RapidServer {
             }
         }
     }
+    appendModelProperties(modelSingularCode, properties) {
+        const originalModel = lodash.find(this.#applicationConfig.models, (item) => item.singularCode == modelSingularCode);
+        if (!originalModel) {
+            throw new Error(`Cannot append model properties. Model '${modelSingularCode}' was not found.`);
+        }
+        const originalProperties = originalModel.properties;
+        for (const property of properties) {
+            const originalProperty = lodash.find(originalProperties, (item) => item.code == property.code);
+            if (originalProperty) {
+                originalProperty.name = property.name;
+            }
+            else {
+                originalProperties.push(property);
+            }
+        }
+    }
     registerActionHandler(plugin, options) {
-        const handler = ___namespace.bind(options.handler, null, plugin);
+        const handler = lodash.bind(options.handler, null, plugin);
         this.#actionHandlersMapByCode.set(options.code, handler);
     }
     getActionHandlerByCode(code) {
@@ -2459,7 +2485,7 @@ class RapidServer {
         if (!model) {
             throw new Error(`Data model ${namespace}.${singularCode} not found.`);
         }
-        dataAccessor = new DataAccessor(this.#databaseAccessor, {
+        dataAccessor = new DataAccessor(this, this.#databaseAccessor, {
             model,
             queryBuilder: this.queryBuilder,
         });
@@ -2487,7 +2513,7 @@ class RapidServer {
         return this;
     }
     async emitEvent(eventName, sender, payload) {
-        console.log(`Emit event "${eventName}"`, payload);
+        this.#logger.debug(`Emitting '${eventName}' event.`, { eventName, payload });
         await this.#eventManager.emit(eventName, sender, payload);
         // TODO: should move this logic into metaManager
         // if (
@@ -2499,7 +2525,7 @@ class RapidServer {
         // }
     }
     async start() {
-        console.log("Starting rapid server...");
+        this.#logger.info("Starting rapid server...");
         const pluginManager = this.#pluginManager;
         await pluginManager.loadPlugins(this.#plugins);
         await pluginManager.initPlugins();
@@ -2509,11 +2535,11 @@ class RapidServer {
         await pluginManager.registerMessageHandlers();
         await pluginManager.registerTaskProcessors();
         await this.configureApplication();
-        console.log(`Application ready.`);
+        this.#logger.info(`Rapid server ready.`);
         await pluginManager.onApplicationReady(this.#applicationConfig);
     }
     async configureApplication() {
-        this.#applicationConfig = ___namespace.merge({}, this.#bootstrapApplicationConfig);
+        this.#applicationConfig = lodash.cloneDeep(this.#bootstrapApplicationConfig);
         const pluginManager = this.#pluginManager;
         await pluginManager.onLoadingApplication(this.#applicationConfig);
         await pluginManager.configureModels(this.#applicationConfig);
@@ -2524,14 +2550,20 @@ class RapidServer {
         this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
     }
     async queryDatabaseObject(sql, params) {
-        return await this.#databaseAccessor.queryDatabaseObject(sql, params);
+        try {
+            return await this.#databaseAccessor.queryDatabaseObject(sql, params);
+        }
+        catch (err) {
+            this.#logger.error("Failed to query database object.", { errorMessage: err.message, sql, params });
+            throw err;
+        }
     }
     async tryQueryDatabaseObject(sql, params) {
         try {
             return await this.queryDatabaseObject(sql, params);
         }
         catch (err) {
-            console.error(err.message);
+            this.#logger.error("Failed to query database object.", { errorMessage: err.message, sql, params });
         }
         return [];
     }
@@ -2539,13 +2571,16 @@ class RapidServer {
         return this.#middlewares;
     }
     async handleRequest(request, next) {
-        const rapidRequest = new RapidRequest(request);
+        const rapidRequest = new RapidRequest(this, request);
         await rapidRequest.parseBody();
-        const routeContext = new RouteContext(rapidRequest);
-        this.#pluginManager.onPrepareRouteContext(routeContext);
+        const routeContext = new RouteContext(this, rapidRequest);
+        await this.#pluginManager.onPrepareRouteContext(routeContext);
         await this.#buildedRoutes(routeContext, next);
         return routeContext.response.getResponse();
     }
+    async beforeRunRouteActions(handlerContext) {
+        await this.#pluginManager.beforeRunRouteActions(handlerContext);
+    }
 }
 
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
@@ -2751,10 +2786,6 @@ class MetaManager {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         server.registerActionHandler(this, listMetaModels);
         server.registerActionHandler(this, listMetaRoutes);
@@ -2765,31 +2796,20 @@ class MetaManager {
         server.registerEventHandler("entity.update", handleEntityUpdateEvent.bind(this, server));
         server.registerEventHandler("entity.delete", handleEntityDeleteEvent.bind(this, server));
     }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
     async configureModels(server, applicationConfig) {
+        const logger = server.getLogger();
         try {
+            logger.info("Loading meta of models...");
             const models = await listCollections(server, applicationConfig);
             server.appendApplicationConfig({ models });
         }
-        catch (ex) {
-            console.warn("Failed to loading existing meta of models.", ex);
+        catch (error) {
+            logger.crit("Failed to load meta of models.", { error });
         }
     }
-    async configureModelProperties(server, applicationConfig) {
-    }
-    async configureRoutes(server, applicationConfig) {
-    }
     async onApplicationLoaded(server, applicationConfig) {
-        console.log("metaManager.onApplicationLoaded");
         await syncDatabaseSchema(server, applicationConfig);
     }
-    async onApplicationReady(server, applicationConfig) {
-    }
 }
 async function handleEntityCreateEvent(server, sender, payload) {
     if (sender === this) {
@@ -2849,15 +2869,16 @@ function listCollections(server, applicationConfig) {
     });
 }
 async function syncDatabaseSchema(server, applicationConfig) {
-    console.log("Synchronizing database schema...");
+    const logger = server.getLogger();
+    logger.info("Synchronizing database schema...");
     const sqlQueryTableInformations = `SELECT table_schema, table_name FROM information_schema.tables`;
     const tablesInDb = await server.queryDatabaseObject(sqlQueryTableInformations);
     const { queryBuilder } = server;
     for (const model of applicationConfig.models) {
-        console.debug(`Checking data table for '${model.namespace}.${model.singularCode}'...`);
+        logger.debug(`Checking data table for '${model.namespace}.${model.singularCode}'...`);
         const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
         const expectedTableName = model.tableName;
-        const tableInDb = ___namespace.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
+        const tableInDb = lodash.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
         if (!tableInDb) {
             await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
         }
@@ -2866,16 +2887,16 @@ async function syncDatabaseSchema(server, applicationConfig) {
   FROM information_schema.columns;`;
     const columnsInDb = await server.queryDatabaseObject(sqlQueryColumnInformations, []);
     for (const model of applicationConfig.models) {
-        console.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
+        logger.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
         for (const property of model.properties) {
             let columnDDL;
             if (isRelationProperty(property)) {
                 if (property.relation === "one") {
                     const targetModel = applicationConfig.models.find(item => item.singularCode === property.targetSingularCode);
                     if (!targetModel) {
-                        console.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                        logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
                     }
-                    const columnInDb = ___namespace.find(columnsInDb, {
+                    const columnInDb = lodash.find(columnsInDb, {
                         table_schema: model.schema || "public",
                         table_name: model.tableName,
                         column_name: property.targetIdColumnName,
@@ -2893,7 +2914,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
                 }
                 else if (property.relation === "many") {
                     if (property.linkTableName) {
-                        const tableInDb = ___namespace.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName });
+                        const tableInDb = lodash.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName });
                         if (!tableInDb) {
                             columnDDL = generateLinkTableDDL(queryBuilder, {
                                 linkSchema: property.linkSchema,
@@ -2906,10 +2927,10 @@ async function syncDatabaseSchema(server, applicationConfig) {
                     else {
                         const targetModel = applicationConfig.models.find(item => item.singularCode === property.targetSingularCode);
                         if (!targetModel) {
-                            console.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                            logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
                             continue;
                         }
-                        const columnInDb = ___namespace.find(columnsInDb, {
+                        const columnInDb = lodash.find(columnsInDb, {
                             table_schema: targetModel.schema || "public",
                             table_name: targetModel.tableName,
                             column_name: property.selfIdColumnName,
@@ -2935,7 +2956,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
             }
             else {
                 const columnName = property.columnName || property.code;
-                const columnInDb = ___namespace.find(columnsInDb, {
+                const columnInDb = lodash.find(columnsInDb, {
                     table_schema: model.schema || "public",
                     table_name: model.tableName,
                     column_name: columnName,
@@ -2997,7 +3018,6 @@ function generateCreateColumnDDL(queryBuilder, options) {
     else {
         const columnType = pgPropertyTypeColumnMap[options.type];
         if (!columnType) {
-            console.log('options', options);
             throw new Error(`Property type "${options.type}" is not supported.`);
         }
         columnDDL += ` ${columnType}`;
@@ -3035,22 +3055,19 @@ const pgPropertyTypeColumnMap = {
 };
 
 function mergeInput(defaultInput, input, fixedInput) {
-    return ___namespace.mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
+    return lodash.mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
 }
 function doNotMergeArray(objValue, srcValue) {
-    if (___namespace.isArray(srcValue)) {
+    if (lodash.isArray(srcValue)) {
         return srcValue;
     }
 }
 
 async function runCollectionEntityActionHandler(ctx, options, code, handleEntityAction) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     const result = handleEntityAction(entityManager, mergedInput);
     if (result instanceof Promise) {
@@ -3122,8 +3139,8 @@ var findCollectionEntities = /*#__PURE__*/Object.freeze({
 
 const code$g = "findCollectionEntityById";
 async function handler$g(plugin, ctx, options) {
-    console.debug(`Running ${code$g} handler...`);
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
+    logger.debug(`Running ${code$g} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById(id);
@@ -3155,13 +3172,10 @@ var countCollectionEntities = /*#__PURE__*/Object.freeze({
 
 const code$e = "createCollectionEntity";
 async function handler$e(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$e} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
     const userId = ctx.routerContext.state?.userId;
     if (userId) {
         input.createdBy = userId;
@@ -3181,19 +3195,16 @@ var createCollectionEntity = /*#__PURE__*/Object.freeze({
 
 const code$d = "createCollectionEntitiesBatch";
 async function handler$d(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$d} handler...`);
+    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
-    if (!_.isArray(entities)) {
+    if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
     }
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
     const output = [];
     for (const entity of entities) {
         const mergedEntity = mergeInput(defaultInput?.entity || {}, entity, fixedInput?.entity);
-        console.debug(`mergedEntity: ${JSON.stringify(mergedEntity)}`);
         const userId = ctx.routerContext.state?.userId;
         if (userId) {
             mergedEntity.createdBy = userId;
@@ -3215,13 +3226,10 @@ var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
 
 const code$c = "updateCollectionEntityById";
 async function handler$c(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$c} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code$c} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput }, plugin);
     ctx.output = output;
@@ -3235,8 +3243,8 @@ var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
 
 const code$b = "deleteCollectionEntityById";
 async function handler$b(plugin, ctx, options) {
-    console.debug(`Running ${code$b} handler...`);
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
+    logger.debug(`Running ${code$b} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById(input.id, plugin);
     ctx.status = 200;
@@ -3251,13 +3259,10 @@ var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
 
 const code$a = "addEntityRelations";
 async function handler$a(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$a} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code$a} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.addRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3271,13 +3276,10 @@ var addEntityRelations = /*#__PURE__*/Object.freeze({
 
 const code$9 = "removeEntityRelations";
 async function handler$9(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$9} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code$9} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3291,16 +3293,13 @@ var removeEntityRelations = /*#__PURE__*/Object.freeze({
 
 const code$8 = "queryDatabase";
 async function handler$8(plugin, ctx, options) {
-    const { server, input } = ctx;
+    const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$8} handler...`);
-    console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
-    console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+    logger.debug(`Running ${code$8} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
-        ctx.output = ___namespace.first(result);
+        ctx.output = lodash.first(result);
     }
     else {
         ctx.output = result;
@@ -3390,10 +3389,6 @@ class DataManager {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         server.registerActionHandler(this, findCollectionEntities);
         server.registerActionHandler(this, findCollectionEntityById);
@@ -3406,18 +3401,6 @@ class DataManager {
         server.registerActionHandler(this, deleteCollectionEntityById);
         server.registerActionHandler(this, queryDatabase);
     }
-    async registerEventHandlers(server) {
-    }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
-    async configureModels(server, applicationConfig) {
-    }
-    async configureModelProperties(server, applicationConfig) {
-    }
     async configureRoutes(server, applicationConfig) {
         const { models } = applicationConfig;
         const routes = [];
@@ -3445,11 +3428,6 @@ class DataManager {
         });
         server.appendApplicationConfig({ routes });
     }
-    async onApplicationLoaded(server, applicationConfig) {
-        console.log("[dataManager.onApplicationLoaded]");
-    }
-    async onApplicationReady(server, applicationConfig) {
-    }
 }
 
 async function fetchWithTimeout(url, reqInit, timeout) {
@@ -3504,7 +3482,8 @@ async function sendSourceResponse(proxyCtx, targetRes) {
 
 const code$7 = "httpProxy";
 async function handler$7(plugin, ctx, options) {
-    console.debug(`Running ${code$7} handler...`);
+    const { logger } = ctx;
+    logger.debug(`Running ${code$7} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
@@ -3533,10 +3512,6 @@ class RouteManager {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         server.registerActionHandler(this, httpProxy);
     }
@@ -3546,18 +3521,10 @@ class RouteManager {
         // server.registerEventHandler("entity.update", handleEntityEvent.bind(null, server))
         // server.registerEventHandler("entity.delete", handleEntityEvent.bind(null, server))
     }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
-    async configureModels(server, applicationConfig) {
-    }
-    async configureModelProperties(server, applicationConfig) {
-    }
     async configureRoutes(server, applicationConfig) {
+        const logger = server.getLogger();
         try {
+            logger.info("Loading meta of routes...");
             const entityManager = server.getEntityManager("route");
             const routes = await entityManager.findEntities({
                 orderBy: [
@@ -3566,15 +3533,10 @@ class RouteManager {
             });
             applicationConfig.routes.push(...routes);
         }
-        catch (ex) {
-            console.warn("Failed to loading existing meta of routes.", ex.message);
+        catch (error) {
+            logger.crit("Failed to load meta of routes.", { error });
         }
     }
-    async onApplicationLoaded(server, applicationConfig) {
-        console.log("[routeManager.onApplicationLoaded] onApplicationLoaded");
-    }
-    async onApplicationReady(server, applicationConfig) {
-    }
 }
 
 var pluginConfig = {
@@ -3654,16 +3616,23 @@ var pluginConfig = {
  * Webhooks plugin
  */
 function listWebhooks(server) {
-    const entityManager = server.getEntityManager("webhook");
-    return entityManager.findEntities({
-        filters: [
-            {
-                field: "enabled",
-                operator: "eq",
-                value: true,
-            },
-        ],
-    });
+    const logger = server.getLogger();
+    logger.info("Loading meta of webhooks...");
+    try {
+        const entityManager = server.getEntityManager("webhook");
+        return entityManager.findEntities({
+            filters: [
+                {
+                    field: "enabled",
+                    operator: "eq",
+                    value: true,
+                },
+            ],
+        });
+    }
+    catch (error) {
+        logger.crit("Failed to load meta of webhooks.", { error });
+    }
 }
 class WebhooksPlugin {
     #webhooks;
@@ -3685,12 +3654,6 @@ class WebhooksPlugin {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
-    async registerActionHandlers(server) {
-    }
     async registerEventHandlers(server) {
         const events = [
             "entity.create",
@@ -3701,12 +3664,6 @@ class WebhooksPlugin {
             server.registerEventHandler(event, this.handleEntityEvent.bind(this, server, event));
         }
     }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
     async configureModels(server, applicationConfig) {
         server.appendApplicationConfig({
             models: pluginConfig.models,
@@ -3717,7 +3674,6 @@ class WebhooksPlugin {
     async configureRoutes(server, applicationConfig) {
     }
     async onApplicationLoaded(server, applicationConfig) {
-        console.log("[webhooks.onApplicationLoaded] loading webhooks");
         this.#webhooks = await listWebhooks(server);
     }
     async onApplicationReady(server, applicationConfig) {
@@ -3734,16 +3690,18 @@ class WebhooksPlugin {
         if (payload.namespace === "meta" || payload.namespace === "sys") {
             return;
         }
+        const logger = server.getLogger();
         for (const webhook of this.#webhooks) {
-            if (___namespace.indexOf(webhook.events, event) === -1) {
+            if (lodash.indexOf(webhook.events, event) === -1) {
                 continue;
             }
             if (webhook.namespace != payload.namespace ||
                 webhook.modelSingularCode !== payload.modelSingularCode) {
                 continue;
             }
-            console.debug(`Triggering webhook. ${webhook.url}`);
+            logger.debug(`Triggering webhook. ${webhook.url}`);
             // TODO: It's better to trigger webhook through message queue.
+            const requestBody = { event, payload };
             try {
                 await fetchWithTimeout(webhook.url, {
                     method: "post",
@@ -3751,12 +3709,11 @@ class WebhooksPlugin {
                         "Content-Type": "application/json",
                         "x-webhook-secret": webhook.secret || "",
                     },
-                    body: JSON.stringify({ event, payload }),
+                    body: JSON.stringify(requestBody),
                 });
             }
-            catch (err) {
-                console.warn(new Error("Failed to call webhook. " + err.message));
-                console.warn(err);
+            catch (error) {
+                logger.error("Failed to call webhook.", { error, webhookUrl: webhook.url, requestBody });
             }
         }
     }
@@ -3991,36 +3948,17 @@ class AuthPlugin {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         for (const actionHandler of pluginActionHandlers$1) {
             server.registerActionHandler(this, actionHandler);
         }
     }
-    async registerEventHandlers(server) {
-    }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
     async configureModels(server, applicationConfig) {
         server.appendApplicationConfig({ models: pluginModels });
     }
-    async configureModelProperties(server, applicationConfig) {
-    }
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes$1 });
     }
-    async onApplicationLoaded(server, applicationConfig) {
-        console.log("authManager.onApplicationLoaded");
-    }
-    async onApplicationReady(server, applicationConfig) {
-    }
     async onPrepareRouteContext(server, routeContext) {
         const request = routeContext.request;
         let token;
@@ -4043,8 +3981,9 @@ class AuthPlugin {
             routeContext.state.userId = tokenPayload.aud;
             routeContext.state.userLogin = tokenPayload.act;
         }
-        catch (err) {
-            console.warn(err);
+        catch (error) {
+            const logger = server.getLogger();
+            logger.debug("Verify JWT failed.", { error });
         }
     }
 }
@@ -4136,7 +4075,7 @@ const code$1 = "uploadFile";
 async function handler$1(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
-    if (_.isArray(file)) {
+    if (lodash.isArray(file)) {
         file = file[0];
     }
     if (!file) {
@@ -4225,35 +4164,14 @@ class FileManager {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         server.registerActionHandler(this, downloadDocumentActionHandler);
         server.registerActionHandler(this, downloadFileActionHandler);
         server.registerActionHandler(this, uploadFileActionHandler);
     }
-    async registerEventHandlers(server) {
-    }
-    async registerMessageHandlers(server) {
-    }
-    async registerTaskProcessors(server) {
-    }
-    async onLoadingApplication(server, applicationConfig) {
-    }
-    async configureModels(server, applicationConfig) {
-    }
-    async configureModelProperties(server, applicationConfig) {
-    }
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes });
     }
-    async onApplicationLoaded(server, applicationConfig) {
-        console.log("fileManager.onApplicationLoaded");
-    }
-    async onApplicationReady(server, applicationConfig) {
-    }
 }
 
 const code = "runServerOperation";
@@ -4421,10 +4339,116 @@ class EntityWatchPlugin {
     }
 }
 
+function isAccessAllowed(policy, allowedActions) {
+    let isAnyCheckPassed = true;
+    let isAllCheckPassed = true;
+    if (policy.any) {
+        isAnyCheckPassed = false;
+        for (const action of policy.any) {
+            if (lodash.find(allowedActions, item => item === action) != null) {
+                isAnyCheckPassed = true;
+                break;
+            }
+        }
+    }
+    if (policy.all) {
+        isAllCheckPassed = true;
+        for (const action of policy.all) {
+            if (lodash.find(allowedActions, item => item === action) == null) {
+                isAnyCheckPassed = false;
+                break;
+            }
+        }
+    }
+    return isAnyCheckPassed && isAllCheckPassed;
+}
+
+class EntityAccessControlPlugin {
+    constructor() {
+    }
+    get code() {
+        return "entityAccessControl";
+    }
+    get description() {
+        return "";
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async onLoadingApplication(server, applicationConfig) {
+        const properties = [
+            {
+                name: "permissionPolicies",
+                code: "permissionPolicies",
+                columnName: "permission_policies",
+                type: "json",
+            },
+        ];
+        server.appendModelProperties("model", properties);
+    }
+    async configureRoutes(server, applicationConfig) {
+        const logger = server.getLogger();
+        logger.info("Configuring entity access checking policies...");
+        const model = lodash.find(applicationConfig.models, (item) => item.singularCode === "model");
+        if (!model) {
+            return;
+        }
+        const { permissionPolicies } = model;
+        if (!permissionPolicies) {
+            return;
+        }
+        const routes = applicationConfig.routes;
+        for (const route of routes) {
+            const { actions } = route;
+            if (!actions) {
+                continue;
+            }
+            for (const action of route.actions) {
+                if (action.code === "findCollectionEntityById") {
+                    if (permissionPolicies.find) {
+                        lodash.set(action, "config.permissionPolicy", permissionPolicies.find);
+                    }
+                }
+            }
+        }
+    }
+    async onPrepareRouteContext(server, routeContext) {
+        const userId = routeContext.state.userId;
+        if (!userId) {
+            return;
+        }
+        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
+      inner join oc_role_sys_action_links ra on a.id = ra.action_id
+      inner join oc_role_user_links ru on ru.role_id = ra.role_id
+      where ru.user_id = $1;`, [userId]);
+        routeContext.state.allowedActions = actions.map(item => item.code);
+    }
+    async beforeRunRouteActions(server, handlerContext) {
+        // Check permission
+        const { routerContext } = handlerContext;
+        const { routeConfig } = routerContext;
+        for (const actionConfig of routeConfig.actions) {
+            const permissionPolicy = actionConfig.config?.permissionPolicy;
+            if (permissionPolicy) {
+                if (!isAccessAllowed(permissionPolicy, routerContext.state.allowedActions || [])) {
+                    throw new Error(`Your action of '${actionConfig.code}' is not permitted.`);
+                }
+            }
+        }
+    }
+}
+
 fixBigIntJSONSerialize();
 
 exports.AuthPlugin = AuthPlugin;
 exports.DataManagePlugin = DataManager;
+exports.EntityAccessControlPlugin = EntityAccessControlPlugin;
 exports.EntityWatchPlugin = EntityWatchPlugin;
 exports.FileManagePlugin = FileManager;
 exports.GlobalRequest = GlobalRequest;