@ruiapp/rapid-core 0.1.20 → 0.1.21

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -42,12 +42,6 @@ class MetaManager implements RapidPlugin {
     return [];
   }
 
-  async initPlugin(server: IRpdServer): Promise<any> {
-  }
-
-  async registerMiddlewares(server: IRpdServer): Promise<any> {
-  }
-
   async registerActionHandlers(server: IRpdServer): Promise<any> {
     server.registerActionHandler(this, listMetaModels);
     server.registerActionHandler(this, listMetaRoutes);
@@ -69,37 +63,20 @@ class MetaManager implements RapidPlugin {
     );
   }
 
-  async registerMessageHandlers(server: IRpdServer): Promise<any> {
-  }
-
-  async registerTaskProcessors(server: IRpdServer): Promise<any> {
-  }
-
-  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
   async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    const logger = server.getLogger();
     try {
+      logger.info("Loading meta of models...");
       const models: RpdDataModel[] = 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: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
-  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    console.log("metaManager.onApplicationLoaded");
     await syncDatabaseSchema(server, applicationConfig);
   }
-
-  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
 }
 
 export default MetaManager;
@@ -236,13 +213,14 @@ async function syncDatabaseSchema(
   server: IRpdServer,
   applicationConfig: RpdApplicationConfig,
 ) {
-  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: TableInformation[] = 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;
@@ -257,7 +235,7 @@ async function syncDatabaseSchema(
   const columnsInDb: ColumnInformation[] = 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;
@@ -265,7 +243,7 @@ async function syncDatabaseSchema(
         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: ColumnInformation | undefined = find(columnsInDb, {
@@ -298,7 +276,7 @@ async function syncDatabaseSchema(
           } 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;
             }
 
@@ -398,7 +376,6 @@ function generateCreateColumnDDL(queryBuilder: IQueryBuilder, 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}`;

package/src/plugins/routeManage/RouteManagePlugin.ts

@@ -30,12 +30,6 @@ class RouteManager implements RapidPlugin {
     return [];
   }
 
-  async initPlugin(server: IRpdServer): Promise<any> {
-  }
-
-  async registerMiddlewares(server: IRpdServer): Promise<any> {
-  }
-
   async registerActionHandlers(server: IRpdServer): Promise<any> {
     server.registerActionHandler(this, httpProxy);
   }
@@ -47,23 +41,10 @@ class RouteManager implements RapidPlugin {
     // server.registerEventHandler("entity.delete", handleEntityEvent.bind(null, server))
   }
 
-  async registerMessageHandlers(server: IRpdServer): Promise<any> {
-  }
-
-  async registerTaskProcessors(server: IRpdServer): Promise<any> {
-  }
-
-  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
-  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
-  async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
   async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    const logger = server.getLogger();
     try {
+      logger.info("Loading meta of routes...");
       const entityManager = server.getEntityManager("route");
       const routes = await entityManager.findEntities({
         orderBy: [
@@ -71,17 +52,10 @@ class RouteManager implements RapidPlugin {
         ],
       });
       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: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    console.log("[routeManager.onApplicationLoaded] onApplicationLoaded");
-  }
-
-  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
 }
 
 export default RouteManager;

package/src/plugins/routeManage/actionHandlers/httpProxy.ts

@@ -10,7 +10,8 @@ export async function handler(
   ctx: ActionHandlerContext,
   options: RunProxyHandlerOptions,
 ) {
-  console.debug(`Running ${code} handler...`);
+  const { logger } = ctx;
+  logger.debug(`Running ${code} handler...`);
 
   await doProxy(ctx.routerContext, options);
 }

package/src/plugins/webhooks/WebhooksPlugin.ts

@@ -30,16 +30,23 @@ export interface Webhook {
 function listWebhooks(
   server: IRpdServer,
 ) {
-  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 });
+  }
 }
 
 
@@ -70,15 +77,6 @@ class WebhooksPlugin implements RapidPlugin {
     return [];
   }
 
-  async initPlugin(server: IRpdServer): Promise<any> {
-  }
-
-  async registerMiddlewares(server: IRpdServer): Promise<any> {
-  }
-
-  async registerActionHandlers(server: IRpdServer): Promise<any> {
-  }
-
   async registerEventHandlers(server: IRpdServer): Promise<any> {
     const events: (keyof RpdServerEventTypes)[] = [
       "entity.create",
@@ -93,15 +91,6 @@ class WebhooksPlugin implements RapidPlugin {
     }
   }
 
-  async registerMessageHandlers(server: IRpdServer): Promise<any> {
-  }
-
-  async registerTaskProcessors(server: IRpdServer): Promise<any> {
-  }
-
-  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
-
   async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
     server.appendApplicationConfig({
       models: pluginConfig.models,
@@ -115,7 +104,6 @@ class WebhooksPlugin implements RapidPlugin {
   }
 
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    console.log("[webhooks.onApplicationLoaded] loading webhooks");
     this.#webhooks = await listWebhooks(server);
   }
 
@@ -145,6 +133,8 @@ class WebhooksPlugin implements RapidPlugin {
       return;
     }
 
+    const logger = server.getLogger();
+
     for (const webhook of this.#webhooks) {
       if (indexOf(webhook.events, event) === -1) {
         continue;
@@ -157,8 +147,9 @@ class WebhooksPlugin implements RapidPlugin {
         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",
@@ -166,11 +157,10 @@ class WebhooksPlugin implements RapidPlugin {
             "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 });
       }
     }
   }

package/src/server.ts

@@ -24,8 +24,10 @@ import { RapidRequest } from "./core/request";
 import bootstrapApplicationConfig from "./bootstrapApplicationConfig";
 import EntityManager from "./dataAccess/entityManager";
 import { bind, cloneDeep, find, merge, omit } from "lodash";
+import { Logger } from "./facilities/log/LogFacility";
 
 export interface InitServerOptions {
+  logger: Logger;
   databaseAccessor: IDatabaseAccessor;
   databaseConfig: IDatabaseConfig;
   serverConfig: RapidServerConfig;
@@ -34,6 +36,7 @@ export interface InitServerOptions {
 }
 
 export class RapidServer implements IRpdServer {
+  #logger: Logger;
   #pluginManager: PluginManager;
   #plugins: RapidPlugin[];
   #eventManager: EventManager<RpdServerEventTypes>;
@@ -50,6 +53,8 @@ export class RapidServer implements IRpdServer {
   #buildedRoutes: (ctx: any, next: any) => any;
 
   constructor(options: InitServerOptions) {
+    this.#logger = options.logger;
+
     this.#pluginManager = new PluginManager(this);
     this.#eventManager = new EventManager();
     this.#middlewares = [];
@@ -70,6 +75,10 @@ export class RapidServer implements IRpdServer {
     this.#plugins = options.plugins || [];
   }
 
+  getLogger(): Logger {
+    return this.#logger;
+  }
+
   getApplicationConfig() {
     return this.#applicationConfig;
   }
@@ -158,7 +167,7 @@ export class RapidServer implements IRpdServer {
       throw new Error(`Data model ${namespace}.${singularCode} not found.`);
     }
 
-    dataAccessor = new DataAccessor<T>(this.#databaseAccessor, {
+    dataAccessor = new DataAccessor<T>(this, this.#databaseAccessor, {
       model,
       queryBuilder: this.queryBuilder as QueryBuilder,
     });
@@ -199,7 +208,7 @@ export class RapidServer implements IRpdServer {
     sender: RapidPlugin,
     payload: RpdServerEventTypes[K][1],
   ) {
-    console.log(`Emit event "${eventName}"`, payload);
+    this.#logger.debug(`Emitting '${eventName}' event.`, { eventName, payload });
     await this.#eventManager.emit<K>(eventName, sender, payload as any);
 
     // TODO: should move this logic into metaManager
@@ -213,7 +222,7 @@ export class RapidServer implements IRpdServer {
   }
 
   async start() {
-    console.log("Starting rapid server...");
+    this.#logger.info("Starting rapid server...");
     const pluginManager = this.#pluginManager;
     await pluginManager.loadPlugins(this.#plugins);
 
@@ -227,7 +236,7 @@ export class RapidServer implements IRpdServer {
 
     await this.configureApplication();
 
-    console.log(`Application ready.`);
+    this.#logger.info(`Rapid server ready.`);
     await pluginManager.onApplicationReady(this.#applicationConfig);
   }
 
@@ -250,14 +259,19 @@ export class RapidServer implements IRpdServer {
   }
 
   async queryDatabaseObject(sql: string, params?: unknown[] | Record<string,unknown>) : Promise<any[]> {
-    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: string, params?: unknown[] | Record<string,unknown>) : Promise<any[]> {
     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 [];
@@ -268,9 +282,9 @@ export class RapidServer implements IRpdServer {
   }
 
   async handleRequest(request: Request, next: 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);