@ruiapp/rapid-core 0.9.9 → 0.10.1

package/src/plugins/webhooks/WebhooksPlugin.ts

@@ -1,148 +1,148 @@
-/**
- * Webhooks plugin
- */
-
-import { RpdApplicationConfig, RpdEntityCreateEventPayload, RpdEntityDeleteEventPayload, RpdEntityUpdateEventPayload, RpdServerEventTypes } from "~/types";
-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 {
-  name: string;
-  url: string;
-  secret: string;
-  namespace: string;
-  modelSingularCode: string;
-  events: string[];
-  properties: string[];
-  enabled: boolean;
-}
-
-function listWebhooks(server: IRpdServer) {
-  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 implements RapidPlugin {
-  #webhooks: Webhook[];
-
-  constructor() {
-    this.#webhooks = [];
-  }
-
-  get code(): string {
-    return "webhooks";
-  }
-
-  get description(): string {
-    return null;
-  }
-
-  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
-    return [];
-  }
-
-  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
-    return [];
-  }
-
-  get configurations(): RpdConfigurationItemOptions[] {
-    return [];
-  }
-
-  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));
-    }
-  }
-
-  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> {
-    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;
-    }
-
-    const logger = server.getLogger();
-
-    for (const webhook of this.#webhooks) {
-      if (indexOf(webhook.events, event) === -1) {
-        continue;
-      }
-
-      if (webhook.namespace != payload.namespace || webhook.modelSingularCode !== payload.modelSingularCode) {
-        continue;
-      }
-
-      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",
-          headers: {
-            "Content-Type": "application/json",
-            "x-webhook-secret": webhook.secret || "",
-          },
-          body: JSON.stringify(requestBody),
-        });
-      } catch (error) {
-        logger.error("Failed to call webhook.", { error, webhookUrl: webhook.url, requestBody });
-      }
-    }
-  }
-}
-
-export default WebhooksPlugin;
+/**
+ * Webhooks plugin
+ */
+
+import { RpdApplicationConfig, RpdEntityCreateEventPayload, RpdEntityDeleteEventPayload, RpdEntityUpdateEventPayload, RpdServerEventTypes } from "~/types";
+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 {
+  name: string;
+  url: string;
+  secret: string;
+  namespace: string;
+  modelSingularCode: string;
+  events: string[];
+  properties: string[];
+  enabled: boolean;
+}
+
+function listWebhooks(server: IRpdServer) {
+  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 implements RapidPlugin {
+  #webhooks: Webhook[];
+
+  constructor() {
+    this.#webhooks = [];
+  }
+
+  get code(): string {
+    return "webhooks";
+  }
+
+  get description(): string {
+    return null;
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  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));
+    }
+  }
+
+  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> {
+    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;
+    }
+
+    const logger = server.getLogger();
+
+    for (const webhook of this.#webhooks) {
+      if (indexOf(webhook.events, event) === -1) {
+        continue;
+      }
+
+      if (webhook.namespace != payload.namespace || webhook.modelSingularCode !== payload.modelSingularCode) {
+        continue;
+      }
+
+      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",
+          headers: {
+            "Content-Type": "application/json",
+            "x-webhook-secret": webhook.secret || "",
+          },
+          body: JSON.stringify(requestBody),
+        });
+      } catch (error) {
+        logger.error("Failed to call webhook.", { error, webhookUrl: webhook.url, requestBody });
+      }
+    }
+  }
+}
+
+export default WebhooksPlugin;

package/src/plugins/webhooks/pluginConfig.ts

@@ -1,75 +1,75 @@
-import { RpdApplicationConfig } from "~/types";
-
-export default {
-  models: [
-    {
-      name: "webhook",
-      namespace: "sys",
-      singularCode: "webhook",
-      pluralCode: "webhooks",
-      schema: "public",
-      tableName: "sys_webhooks",
-      properties: [
-        {
-          name: "id",
-          code: "id",
-          columnName: "id",
-          type: "integer",
-          required: true,
-          autoIncrement: true,
-        },
-        {
-          name: "name",
-          code: "name",
-          columnName: "name",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "url",
-          code: "url",
-          columnName: "url",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "secret",
-          code: "secret",
-          columnName: "secret",
-          type: "text",
-          required: false,
-        },
-        {
-          name: "namespace",
-          code: "namespace",
-          columnName: "namespace",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "model singular code",
-          code: "modelSingularCode",
-          columnName: "model_singular_code",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "events",
-          code: "events",
-          columnName: "events",
-          type: "json",
-          required: false,
-        },
-        {
-          name: "enabled",
-          code: "enabled",
-          columnName: "enabled",
-          type: "boolean",
-          required: true,
-        },
-      ],
-    },
-  ],
-  dataDictionaries: [],
-  routes: [],
-} satisfies RpdApplicationConfig;
+import { RpdApplicationConfig } from "~/types";
+
+export default {
+  models: [
+    {
+      name: "webhook",
+      namespace: "sys",
+      singularCode: "webhook",
+      pluralCode: "webhooks",
+      schema: "public",
+      tableName: "sys_webhooks",
+      properties: [
+        {
+          name: "id",
+          code: "id",
+          columnName: "id",
+          type: "integer",
+          required: true,
+          autoIncrement: true,
+        },
+        {
+          name: "name",
+          code: "name",
+          columnName: "name",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "url",
+          code: "url",
+          columnName: "url",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "secret",
+          code: "secret",
+          columnName: "secret",
+          type: "text",
+          required: false,
+        },
+        {
+          name: "namespace",
+          code: "namespace",
+          columnName: "namespace",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "model singular code",
+          code: "modelSingularCode",
+          columnName: "model_singular_code",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "events",
+          code: "events",
+          columnName: "events",
+          type: "json",
+          required: false,
+        },
+        {
+          name: "enabled",
+          code: "enabled",
+          columnName: "enabled",
+          type: "boolean",
+          required: true,
+        },
+      ],
+    },
+  ],
+  dataDictionaries: [],
+  routes: [],
+} satisfies RpdApplicationConfig;

package/src/polyfill.ts

@@ -1,5 +1,5 @@
-export function fixBigIntJSONSerialize() {
-  (BigInt.prototype as any).toJSON = function () {
-    return this.toString();
-  };
-}
+export function fixBigIntJSONSerialize() {
+  (BigInt.prototype as any).toJSON = function () {
+    return this.toString();
+  };
+}

package/src/proxy/mod.ts

@@ -1,38 +1,38 @@
-import { fetchWithTimeout } from "../utilities/httpUtility";
-import { ProxyContext, ProxyOptions } from "./types";
-import { RouteContext } from "~/core/routeContext";
-
-export async function doProxy(sourceRouterCtx: RouteContext, options: ProxyOptions) {
-  const proxyCtx = createProxyContext(sourceRouterCtx, options);
-  const targetRes = await sendTargetRequest(proxyCtx);
-  sendSourceResponse(proxyCtx, targetRes);
-}
-
-export function createProxyContext(sourceRouterCtx: RouteContext, options: ProxyOptions) {
-  return {
-    sourceContext: {
-      request: sourceRouterCtx.request,
-      response: sourceRouterCtx.response,
-    },
-    targetContext: {},
-    options: options,
-  } satisfies ProxyContext;
-}
-
-export async function sendTargetRequest(proxyCtx: ProxyContext) {
-  const { sourceContext, options: proxyOptions } = proxyCtx;
-  const { target, timeout } = proxyOptions;
-  const { request: srcReq } = sourceContext;
-  const { method } = srcReq;
-
-  const reqInit: RequestInit = {
-    method,
-  };
-  return await fetchWithTimeout(target, reqInit, timeout);
-}
-
-export async function sendSourceResponse(proxyCtx: ProxyContext, targetRes: Response) {
-  const { response: srcRes } = proxyCtx.sourceContext;
-  srcRes.status = targetRes.status;
-  srcRes.body = targetRes.body;
-}
+import { fetchWithTimeout } from "../utilities/httpUtility";
+import { ProxyContext, ProxyOptions } from "./types";
+import { RouteContext } from "~/core/routeContext";
+
+export async function doProxy(sourceRouterCtx: RouteContext, options: ProxyOptions) {
+  const proxyCtx = createProxyContext(sourceRouterCtx, options);
+  const targetRes = await sendTargetRequest(proxyCtx);
+  sendSourceResponse(proxyCtx, targetRes);
+}
+
+export function createProxyContext(sourceRouterCtx: RouteContext, options: ProxyOptions) {
+  return {
+    sourceContext: {
+      request: sourceRouterCtx.request,
+      response: sourceRouterCtx.response,
+    },
+    targetContext: {},
+    options: options,
+  } satisfies ProxyContext;
+}
+
+export async function sendTargetRequest(proxyCtx: ProxyContext) {
+  const { sourceContext, options: proxyOptions } = proxyCtx;
+  const { target, timeout } = proxyOptions;
+  const { request: srcReq } = sourceContext;
+  const { method } = srcReq;
+
+  const reqInit: RequestInit = {
+    method,
+  };
+  return await fetchWithTimeout(target, reqInit, timeout);
+}
+
+export async function sendSourceResponse(proxyCtx: ProxyContext, targetRes: Response) {
+  const { response: srcRes } = proxyCtx.sourceContext;
+  srcRes.status = targetRes.status;
+  srcRes.body = targetRes.body;
+}

package/src/proxy/types.ts

@@ -1,21 +1,21 @@
-import { RapidRequest } from "~/core/request";
-import { RunProxyHandlerOptions } from "../types";
-import { RapidResponse } from "~/core/response";
-
-export interface ProxyContext {
-  sourceContext: ProxySourceContext;
-  targetContext: ProxyTargetContext;
-  options: ProxyOptions;
-}
-
-export interface ProxySourceContext {
-  request: RapidRequest;
-  response: RapidResponse;
-}
-
-export interface ProxyTargetContext {
-  request?: RapidRequest;
-  response?: RapidResponse;
-}
-
-export type ProxyOptions = RunProxyHandlerOptions;
+import { RapidRequest } from "~/core/request";
+import { RunProxyHandlerOptions } from "../types";
+import { RapidResponse } from "~/core/response";
+
+export interface ProxyContext {
+  sourceContext: ProxySourceContext;
+  targetContext: ProxyTargetContext;
+  options: ProxyOptions;
+}
+
+export interface ProxySourceContext {
+  request: RapidRequest;
+  response: RapidResponse;
+}
+
+export interface ProxyTargetContext {
+  request?: RapidRequest;
+  response?: RapidResponse;
+}
+
+export type ProxyOptions = RunProxyHandlerOptions;

package/src/queryBuilder/index.ts

@@ -1 +1 @@
-export * from "./queryBuilder";
+export * from "./queryBuilder";