@ruiapp/rapid-core 0.1.4 → 0.1.6

package/src/plugins/{metaManager → metaManage}/mod.ts

@@ -5,7 +5,6 @@
 import * as _ from "lodash";
 import { findEntities } from "~/dataAccess/entityManager";
 import {
-  IPluginInstance,
   IQueryBuilder,
   QuoteTableOptions,
   RpdApplicationConfig,
@@ -16,50 +15,103 @@ import {
   RpdEntityDeleteEventPayload,
   RpdEntityUpdateEventPayload,
 } from "~/types";
-import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
 
-import * as listMetaModels from "./httpHandlers/listMetaModels";
-import * as getMetaModelDetail from "./httpHandlers/getMetaModelDetail";
+import * as listMetaModels from "./actionHandlers/listMetaModels";
+import * as listMetaRoutes from "./actionHandlers/listMetaRoutes";
+import * as getMetaModelDetail from "./actionHandlers/getMetaModelDetail";
 import { isRelationProperty } from "~/utilities/rapidUtility";
 
-export const code = "metaManager";
-export const description = "metaManager";
-export const extendingAbilities: RpdServerPluginExtendingAbilities[] = [];
-export const configurableTargets: RpdServerPluginConfigurableTargetOptions[] = [];
-export const configurations: RpdConfigurationItemOptions[] = [];
+class MetaManager implements RapidPlugin {
+  get code(): string {
+    return "metaManager";
+  }
 
-let _plugin: IPluginInstance;
+  get description(): string {
+    return null;
+  }
 
-export async function initPlugin(plugin: IPluginInstance, server: IRpdServer) {
-  _plugin = plugin;
-}
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
 
-export async function registerHttpHandlers(server: IRpdServer) {
-  server.registerHttpHandler(_plugin, listMetaModels);
-  server.registerHttpHandler(_plugin, getMetaModelDetail);
-}
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async initPlugin(server: IRpdServer): Promise<any> {
+  }
+
+  async registerMiddlewares(server: IRpdServer): Promise<any> {
+  }
 
-export async function registerEventHandlers(server: IRpdServer) {
-  server.registerEventHandler(
-    "entity.create",
-    handleEntityCreateEvent.bind(null, server),
-  );
-  server.registerEventHandler(
-    "entity.update",
-    handleEntityUpdateEvent.bind(null, server),
-  );
-  server.registerEventHandler(
-    "entity.delete",
-    handleEntityDeleteEvent.bind(null, server),
-  );
+  async registerActionHandlers(server: IRpdServer): Promise<any> {
+    server.registerActionHandler(this, listMetaModels);
+    server.registerActionHandler(this, listMetaRoutes);
+    server.registerActionHandler(this, getMetaModelDetail);
+  }
+
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    server.registerEventHandler(
+      "entity.create",
+      handleEntityCreateEvent.bind(this, server),
+    );
+    server.registerEventHandler(
+      "entity.update",
+      handleEntityUpdateEvent.bind(this, server),
+    );
+    server.registerEventHandler(
+      "entity.delete",
+      handleEntityDeleteEvent.bind(this, 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> {
+    try {
+      const models: RpdDataModel[] = await listCollections(server, applicationConfig);
+      server.appendApplicationConfig({ models });
+    } catch (ex) {
+      console.warn("Failed to loading existing meta of models.", ex);
+    }
+  }
+
+  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;
+
+
 async function handleEntityCreateEvent(
   server: IRpdServer,
-  sender: IPluginInstance,
+  sender: RapidPlugin,
   payload: RpdEntityCreateEventPayload,
 ) {
-  if (sender === _plugin) {
+  if (sender === this) {
     return;
   }
 
@@ -79,10 +131,10 @@ async function handleEntityCreateEvent(
 
 async function handleEntityUpdateEvent(
   server: IRpdServer,
-  sender: IPluginInstance,
+  sender: RapidPlugin,
   payload: RpdEntityUpdateEventPayload,
 ) {
-  if (sender === _plugin) {
+  if (sender === this) {
     return;
   }
 
@@ -102,10 +154,10 @@ async function handleEntityUpdateEvent(
 
 async function handleEntityDeleteEvent(
   server: IRpdServer,
-  sender: IPluginInstance,
+  sender: RapidPlugin,
   payload: RpdEntityDeleteEventPayload,
 ) {
-  if (sender === _plugin) {
+  if (sender === this) {
     return;
   }
 
@@ -150,18 +202,6 @@ async function handleEntityDeleteEvent(
   }
 }
 
-export async function configureModels(
-  server: IRpdServer,
-  applicationConfig: RpdApplicationConfig,
-) {
-  try {
-    const models: RpdDataModel[] = await listCollections(server, applicationConfig);
-    server.appendApplicationConfig({ models });
-  } catch (ex) {
-    console.warn("Failed to loading existing meta of models.", ex);
-  }
-}
-
 function listCollections(
   server: IRpdServer,
   applicationConfig: RpdApplicationConfig,
@@ -177,13 +217,6 @@ function listCollections(
   });
 }
 
-export async function onApplicationLoaded(
-  server: IRpdServer,
-  applicationConfig: RpdApplicationConfig,
-) {
-  console.log("metaManager.onApplicationLoaded");
-  await syncDatabaseSchema(server, applicationConfig);
-}
 
 type TableInformation = {
   table_schema: string;

package/src/plugins/{routeManager/httpHandlers → routeManage/actionHandlers}/httpProxy.ts

@@ -1,12 +1,13 @@
-import { IPluginInstance, RunProxyHandlerOptions } from "~/types";
+import { RunProxyHandlerOptions } from "~/types";
 import { doProxy } from "~/proxy/mod";
-import { HttpHandlerContext } from "~/core/httpHandler";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
 
 export const code = "httpProxy";
 
 export async function handler(
-  plugin: IPluginInstance,
-  ctx: HttpHandlerContext,
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
   options: RunProxyHandlerOptions,
 ) {
   console.debug(`Running ${code} handler...`);

package/src/plugins/routeManage/mod.ts

@@ -0,0 +1,92 @@
+/**
+ * Route manager plugin
+ */
+
+import {
+  RpdApplicationConfig,
+} from "~/types";
+import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer, RapidPlugin } from "~/core/server";
+import { findEntities } from "../../dataAccess/entityManager";
+import * as httpProxy from "./actionHandlers/httpProxy";
+
+
+class RouteManager implements RapidPlugin {
+  get code(): string {
+    return "routeManager";
+  }
+
+  get description(): string {
+    return null;
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async initPlugin(server: IRpdServer): Promise<any> {
+  }
+
+  async registerMiddlewares(server: IRpdServer): Promise<any> {
+  }
+
+  async registerActionHandlers(server: IRpdServer): Promise<any> {
+    server.registerActionHandler(this, httpProxy);
+  }
+
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    // TODO: Should rebuild routes after route configurations changed.
+    // server.registerEventHandler("entity.create", handleEntityEvent.bind(null, server))
+    // server.registerEventHandler("entity.update", handleEntityEvent.bind(null, server))
+    // 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> {
+    try {
+      const dataAccessor = server.getDataAccessor({
+        namespace: "meta",
+        singularCode: "route",
+      });
+    
+      const routes = await findEntities(server, dataAccessor, {
+        orderBy: [
+          { field: "endpoint" },
+        ],
+      });
+      applicationConfig.routes.push(...routes);
+    } catch (ex) {
+      console.warn("Failed to loading existing meta of routes.", ex.message);
+    }
+  }
+
+  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/webhooks/mod.ts

@@ -4,23 +4,17 @@
 
 import * as _ from "lodash";
 import {
-  IPluginInstance,
   RpdApplicationConfig,
   RpdEntityCreateEventPayload,
   RpdEntityDeleteEventPayload,
   RpdEntityUpdateEventPayload,
   RpdServerEventTypes,
 } from "~/types";
-import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer } from "~/core/server";
+import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer, RapidPlugin } from "~/core/server";
 import { fetchWithTimeout } from "~/utilities/httpUtility";
 import { findEntities } from "~/dataAccess/entityManager";
 import pluginConfig from "./pluginConfig";
 
-export const code = "webhooks";
-export const description = "webhooks";
-export const extendingAbilities: RpdServerPluginExtendingAbilities[] = [];
-export const configurableTargets: RpdServerPluginConfigurableTargetOptions[] = [];
-export const configurations: RpdConfigurationItemOptions[] = [];
 
 export interface Webhook {
   name: string;
@@ -33,112 +27,158 @@ export interface Webhook {
   enabled: boolean;
 }
 
-let _plugin: IPluginInstance;
-let webhooks: Webhook[];
 
-export async function initPlugin(plugin: IPluginInstance, server: IRpdServer) {
-  _plugin = plugin;
-}
-
-export async function configureModels(
+function listWebhooks(
   server: IRpdServer,
-  applicationConfig: RpdApplicationConfig,
 ) {
-  server.appendApplicationConfig({
-    models: pluginConfig.models,
+  const dataAccessor = server.getDataAccessor({
+    namespace: "sys",
+    singularCode: "webhook",
+  });
+
+  return findEntities(server, dataAccessor, {
+    filters: [
+      {
+        field: "enabled",
+        operator: "eq",
+        value: true,
+      },
+    ],
   });
 }
 
-export async function registerEventHandlers(server: IRpdServer) {
-  const events: (keyof RpdServerEventTypes)[] = [
-    "entity.create",
-    "entity.update",
-    "entity.delete",
-  ];
-  for (const event of events) {
-    server.registerEventHandler(
-      event,
-      handleEntityEvent.bind(null, server, event),
-    );
+
+class WebhooksPlugin implements RapidPlugin {
+  #webhooks: Webhook[];
+
+  constructor() {
+    this.#webhooks = [];
   }
-}
 
-async function handleEntityEvent(
-  server: IRpdServer,
-  event: keyof RpdServerEventTypes,
-  sender: IPluginInstance,
-  payload:
-    | RpdEntityCreateEventPayload
-    | RpdEntityUpdateEventPayload
-    | RpdEntityDeleteEventPayload,
-) {
-  if (sender === _plugin) {
-    return;
+  get code(): string {
+    return "webhooks";
   }
 
-  if (payload.namespace === "sys" && payload.modelSingularCode === "webhook") {
-    webhooks = await listWebhooks(server);
-    return;
+  get description(): string {
+    return null;
   }
 
-  // We will not trigger webhooks if entity changed is in "meta" or "sys" namespaces.
-  if (payload.namespace === "meta" || payload.namespace === "sys") {
-    return;
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
   }
 
-  for (const webhook of webhooks) {
-    if (_.indexOf(webhook.events, event) === -1) {
-      continue;
-    }
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
 
-    if (
-      webhook.namespace != payload.namespace ||
-      webhook.modelSingularCode !== payload.modelSingularCode
-    ) {
-      continue;
-    }
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async initPlugin(server: IRpdServer): Promise<any> {
+  }
+
+  async registerMiddlewares(server: IRpdServer): Promise<any> {
+  }
+
+  async registerActionHandlers(server: IRpdServer): Promise<any> {
+  }
 
-    console.debug(`Triggering webhook. ${webhook.url}`);
-    // TODO: It's better to trigger webhook through message queue.
-    try {
-      await fetchWithTimeout(webhook.url, {
-        method: "post",
-        headers: {
-          "Content-Type": "application/json",
-          "x-webhook-secret": webhook.secret || "",
-        },
-        body: JSON.stringify({ event, payload }),
-      });
-    } catch (err) {
-      console.warn(new Error("Failed to call webhook. " + err.message));
-      console.warn(err);
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    const events: (keyof RpdServerEventTypes)[] = [
+      "entity.create",
+      "entity.update",
+      "entity.delete",
+    ];
+    for (const event of events) {
+      server.registerEventHandler(
+        event,
+        this.handleEntityEvent.bind(this, server, event),
+      );
     }
   }
-}
 
-export async function onApplicationLoaded(
-  server: IRpdServer,
-  applicationConfig: RpdApplicationConfig,
-) {
-  console.log("[webhooks.onApplicationLoaded] loading webhooks");
-  webhooks = await listWebhooks(server);
-}
+  async registerMessageHandlers(server: IRpdServer): Promise<any> {
+  }
 
-function listWebhooks(
-  server: IRpdServer,
-) {
-  const dataAccessor = server.getDataAccessor({
-    namespace: "sys",
-    singularCode: "webhook",
-  });
+  async registerTaskProcessors(server: IRpdServer): Promise<any> {
+  }
 
-  return findEntities(server, dataAccessor, {
-    filters: [
-      {
-        field: "enabled",
-        operator: "eq",
-        value: true,
-      },
-    ],
-  });
+  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+
+  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({
+      models: pluginConfig.models,
+    });
+  }
+
+  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("[webhooks.onApplicationLoaded] loading webhooks");
+    this.#webhooks = await listWebhooks(server);
+  }
+
+  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+
+  async handleEntityEvent(
+    server: IRpdServer,
+    event: keyof RpdServerEventTypes,
+    sender: RapidPlugin,
+    payload:
+      | RpdEntityCreateEventPayload
+      | RpdEntityUpdateEventPayload
+      | RpdEntityDeleteEventPayload,
+  ) {
+    if (sender === this) {
+      return;
+    }
+
+    if (payload.namespace === "sys" && payload.modelSingularCode === "webhook") {
+      this.#webhooks = await listWebhooks(server);
+      return;
+    }
+
+    // We will not trigger webhooks if entity changed is in "meta" or "sys" namespaces.
+    if (payload.namespace === "meta" || payload.namespace === "sys") {
+      return;
+    }
+
+    for (const webhook of this.#webhooks) {
+      if (_.indexOf(webhook.events, event) === -1) {
+        continue;
+      }
+
+      if (
+        webhook.namespace != payload.namespace ||
+        webhook.modelSingularCode !== payload.modelSingularCode
+      ) {
+        continue;
+      }
+
+      console.debug(`Triggering webhook. ${webhook.url}`);
+      // TODO: It's better to trigger webhook through message queue.
+      try {
+        await fetchWithTimeout(webhook.url, {
+          method: "post",
+          headers: {
+            "Content-Type": "application/json",
+            "x-webhook-secret": webhook.secret || "",
+          },
+          body: JSON.stringify({ event, payload }),
+        });
+      } catch (err) {
+        console.warn(new Error("Failed to call webhook. " + err.message));
+        console.warn(err);
+      }
+    }
+  }
 }
+
+export default WebhooksPlugin;