@ruiapp/rapid-core 0.1.19 → 0.1.21

package/src/plugins/entityAccessControl/EntityAccessControlPlugin.ts

@@ -0,0 +1,107 @@
+import type { RpdApplicationConfig, RpdDataModelProperty } from "~/types";
+
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+import { find, set } from "lodash";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { isAccessAllowed } from "~/utilities/accessControlUtility";
+import { RouteContext } from "~/core/routeContext";
+
+class EntityAccessControlPlugin implements RapidPlugin {
+  constructor() {
+  }
+
+  get code(): string {
+    return "entityAccessControl";
+  }
+
+  get description(): string {
+    return "";
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    const properties: RpdDataModelProperty[] = [
+      {
+        name: "permissionPolicies",
+        code: "permissionPolicies",
+        columnName: "permission_policies",
+        type: "json",
+      },
+    ];
+    server.appendModelProperties("model", properties);
+  }
+
+  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    const logger = server.getLogger();
+    logger.info("Configuring entity access checking policies...")
+
+    const model = 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) {
+            set(action, "config.permissionPolicy", permissionPolicies.find);
+          }
+        }
+      }
+    }
+  }
+
+  async onPrepareRouteContext(server: IRpdServer, routeContext: 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: IRpdServer, handlerContext: ActionHandlerContext): Promise<any> {
+    // 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.`);
+        }
+      }
+    }
+  }
+}
+
+export default EntityAccessControlPlugin;

package/src/plugins/fileManage/FileManagePlugin.ts

@@ -34,46 +34,15 @@ class FileManager implements RapidPlugin {
     return [];
   }
 
-  async initPlugin(server: IRpdServer): Promise<any> {
-  }
-
-  async registerMiddlewares(server: IRpdServer): Promise<any> {
-  }
-
   async registerActionHandlers(server: IRpdServer): Promise<any> {
     server.registerActionHandler(this, downloadDocumentActionHandler);
     server.registerActionHandler(this, downloadFileActionHandler);
     server.registerActionHandler(this, uploadFileActionHandler);
   }
 
-  async registerEventHandlers(server: IRpdServer): Promise<any> {
-  }
-
-  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> {
     server.appendApplicationConfig({ routes: pluginRoutes });
   }
-
-  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    console.log("fileManager.onApplicationLoaded");
-  }
-
-  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
 }
 
 export default FileManager;

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -2,7 +2,6 @@
  * Meta manager plugin
  */
 
-import * as _ from "lodash";
 import {
   IQueryBuilder,
   QuoteTableOptions,
@@ -20,6 +19,7 @@ import * as listMetaModels from "./actionHandlers/listMetaModels";
 import * as listMetaRoutes from "./actionHandlers/listMetaRoutes";
 import * as getMetaModelDetail from "./actionHandlers/getMetaModelDetail";
 import { isRelationProperty } from "~/utilities/rapidUtility";
+import { find } from "lodash";
 
 class MetaManager implements RapidPlugin {
   get code(): string {
@@ -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,17 +213,18 @@ 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;
-    const tableInDb = _.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName});
+    const tableInDb = find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName});
     if (!tableInDb) {
       await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
     }
@@ -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,10 +243,10 @@ 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, {
+          const columnInDb: ColumnInformation | undefined = find(columnsInDb, {
             table_schema: model.schema || "public",
             table_name: model.tableName,
             column_name: property.targetIdColumnName!,
@@ -286,7 +264,7 @@ async function syncDatabaseSchema(
           }
         } else if (property.relation === "many") {
           if (property.linkTableName) {
-            const tableInDb = _.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName});
+            const tableInDb = find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName});
             if (!tableInDb) {
               columnDDL = generateLinkTableDDL(queryBuilder, {
                 linkSchema: property.linkSchema,
@@ -298,11 +276,11 @@ 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;
             }
 
-            const columnInDb: ColumnInformation | undefined = _.find(columnsInDb, {
+            const columnInDb: ColumnInformation | undefined = find(columnsInDb, {
               table_schema: targetModel.schema || "public",
               table_name: targetModel.tableName,
               column_name: property.selfIdColumnName!,
@@ -328,7 +306,7 @@ async function syncDatabaseSchema(
         }
       } else {
         const columnName = property.columnName || property.code;
-        const columnInDb: ColumnInformation | undefined = _.find(columnsInDb, {
+        const columnInDb: ColumnInformation | undefined = find(columnsInDb, {
           table_schema: model.schema || "public",
           table_name: model.tableName,
           column_name: columnName,
@@ -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

@@ -2,7 +2,6 @@
  * Webhooks plugin
  */
 
-import * as _ from "lodash";
 import {
   RpdApplicationConfig,
   RpdEntityCreateEventPayload,
@@ -13,6 +12,7 @@ import {
 import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer, RapidPlugin } from "~/core/server";
 import { fetchWithTimeout } from "~/utilities/httpUtility";
 import pluginConfig from "./pluginConfig";
+import { indexOf } from "lodash";
 
 
 export interface Webhook {
@@ -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,8 +133,10 @@ class WebhooksPlugin implements RapidPlugin {
       return;
     }
 
+    const logger = server.getLogger();
+
     for (const webhook of this.#webhooks) {
-      if (_.indexOf(webhook.events, event) === -1) {
+      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/queryBuilder/queryBuilder.ts

@@ -1,4 +1,4 @@
-import * as _ from "lodash";
+import { find } from "lodash";
 import {
   CountEntityOptions,
   DeleteEntityOptions,
@@ -148,7 +148,7 @@ export default class QueryBuilder {
 
       let property: RpdDataModelProperty | null = null;
       if (model) {
-        property = _.find(
+        property = find(
           model.properties,
           (e: RpdDataModelProperty) => e.code === propertyName,
         );
@@ -192,7 +192,7 @@ export default class QueryBuilder {
 
       let property: RpdDataModelProperty | null = null;
       if (model) {
-        property = _.find(
+        property = find(
           model.properties,
           (e: RpdDataModelProperty) => (e.columnName || e.code) === propertyName,
         );