@ruiapp/rapid-core 0.1.20 → 0.1.21

package/dist/index.js

@@ -27,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;
@@ -62,7 +64,7 @@ class DataAccessor {
         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);
     }
@@ -569,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) {
@@ -602,9 +605,13 @@ 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,
@@ -690,6 +697,7 @@ class RapidResponse {
 }
 
 class RouteContext {
+    #logger;
     request;
     response;
     state;
@@ -697,7 +705,8 @@ class RouteContext {
     path;
     params;
     routeConfig;
-    constructor(request) {
+    constructor(server, request) {
+        this.#logger = server.getLogger();
         this.request = request;
         this.state = {};
         this.response = new RapidResponse();
@@ -1009,6 +1018,7 @@ function setCookie(headers, cookie) {
 
 const GlobalRequest = global.Request;
 class RapidRequest {
+    #logger;
     #raw;
     #bodyParsed;
     #body;
@@ -1016,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);
@@ -1024,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;
@@ -2362,6 +2373,7 @@ class EntityManager {
 }
 
 class RapidServer {
+    #logger;
     #pluginManager;
     #plugins;
     #eventManager;
@@ -2377,6 +2389,7 @@ class RapidServer {
     databaseConfig;
     #buildedRoutes;
     constructor(options) {
+        this.#logger = options.logger;
         this.#pluginManager = new PluginManager(this);
         this.#eventManager = new EventManager();
         this.#middlewares = [];
@@ -2393,6 +2406,9 @@ class RapidServer {
         this.config = options.serverConfig;
         this.#plugins = options.plugins || [];
     }
+    getLogger() {
+        return this.#logger;
+    }
     getApplicationConfig() {
         return this.#applicationConfig;
     }
@@ -2469,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,
         });
@@ -2497,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 (
@@ -2509,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();
@@ -2519,7 +2535,7 @@ 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() {
@@ -2534,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 [];
     }
@@ -2549,9 +2571,9 @@ 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);
+        const routeContext = new RouteContext(this, rapidRequest);
         await this.#pluginManager.onPrepareRouteContext(routeContext);
         await this.#buildedRoutes(routeContext, next);
         return routeContext.response.getResponse();
@@ -2764,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);
@@ -2778,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) {
@@ -2862,12 +2869,13 @@ 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 = lodash.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
@@ -2879,14 +2887,14 @@ 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 = lodash.find(columnsInDb, {
                         table_schema: model.schema || "public",
@@ -2919,7 +2927,7 @@ 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 = lodash.find(columnsInDb, {
@@ -3010,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}`;
@@ -3057,13 +3064,10 @@ function doNotMergeArray(objValue, 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) {
@@ -3135,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);
@@ -3168,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;
@@ -3194,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 (!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;
@@ -3228,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;
@@ -3248,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;
@@ -3264,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 = {};
@@ -3284,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 = {};
@@ -3304,13 +3293,10 @@ 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 = lodash.first(result);
@@ -3403,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);
@@ -3419,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 = [];
@@ -3458,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) {
@@ -3517,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);
 }
 
@@ -3546,10 +3512,6 @@ class RouteManager {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
     async registerActionHandlers(server) {
         server.registerActionHandler(this, httpProxy);
     }
@@ -3559,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: [
@@ -3579,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 = {
@@ -3667,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;
@@ -3698,12 +3654,6 @@ class WebhooksPlugin {
     get configurations() {
         return [];
     }
-    async initPlugin(server) {
-    }
-    async registerMiddlewares(server) {
-    }
-    async registerActionHandlers(server) {
-    }
     async registerEventHandlers(server) {
         const events = [
             "entity.create",
@@ -3714,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,
@@ -3730,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) {
@@ -3747,6 +3690,7 @@ class WebhooksPlugin {
         if (payload.namespace === "meta" || payload.namespace === "sys") {
             return;
         }
+        const logger = server.getLogger();
         for (const webhook of this.#webhooks) {
             if (lodash.indexOf(webhook.events, event) === -1) {
                 continue;
@@ -3755,8 +3699,9 @@ class WebhooksPlugin {
                 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",
@@ -3764,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 });
             }
         }
     }
@@ -4004,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;
@@ -4056,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 });
         }
     }
 }
@@ -4467,6 +4393,8 @@ class EntityAccessControlPlugin {
         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;