@ruiapp/rapid-core 0.1.4 → 0.1.5

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 "./httpHandlers/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 registerHttpHandlers(server: IRpdServer): Promise<any> {
+    server.registerHttpHandler(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 registerHttpHandlers(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;

package/src/server.ts

@@ -5,7 +5,6 @@ import {
   GetModelOptions,
   IDatabaseAccessor,
   IDatabaseConfig,
-  IPluginInstance,
   IQueryBuilder,
   IRpdDataAccessor,
   RpdApplicationConfig,
@@ -15,10 +14,10 @@ import {
 } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
-import * as pluginManager from "./core/pluginManager";
+import PluginManager from "./core/pluginManager";
 import EventManager from "./core/eventManager";
 import { HttpRequestHandler, IPluginHttpHandler } from "./core/httpHandler";
-import { IRpdServer } from "./core/server";
+import { IRpdServer, RapidPlugin } from "./core/server";
 import { buildRoutes } from "./core/routesBuilder";
 import { Next, RouteContext } from "./core/routeContext";
 import { RapidRequest } from "./core/request";
@@ -29,9 +28,12 @@ export interface InitServerOptions {
   databaseConfig: IDatabaseConfig;
   serverConfig: RapidServerConfig;
   applicationConfig?: RpdApplicationConfig;
+  plugins?: RapidPlugin[];
 }
 
 export class RapidServer implements IRpdServer {
+  #pluginManager: PluginManager;
+  #plugins: RapidPlugin[];
   #eventManager: EventManager;
   #middlewares: any[];
   #bootstrapApplicationConfig: RpdApplicationConfig;
@@ -44,6 +46,7 @@ export class RapidServer implements IRpdServer {
   #buildedRoutes: (ctx: any, next: any) => any;
 
   constructor(options: InitServerOptions) {
+    this.#pluginManager = new PluginManager(this);
     this.#eventManager = new EventManager();
     this.#middlewares = [];
     this.#bootstrapApplicationConfig = options.applicationConfig || bootstrapApplicationConfig;
@@ -57,6 +60,8 @@ export class RapidServer implements IRpdServer {
     });
     this.databaseConfig = options.databaseConfig;
     this.config = options.serverConfig;
+
+    this.#plugins = options.plugins || [];
   }
 
   getApplicationConfig() {
@@ -99,7 +104,7 @@ export class RapidServer implements IRpdServer {
   }
 
   registerHttpHandler(
-    plugin: IPluginInstance,
+    plugin: RapidPlugin,
     options: IPluginHttpHandler,
   ) {
     const handler = _.bind(options.handler, null, plugin);
@@ -149,7 +154,7 @@ export class RapidServer implements IRpdServer {
 
   async emitEvent<K extends keyof RpdServerEventTypes>(
     eventName: K,
-    sender: IPluginInstance,
+    sender: RapidPlugin,
     payload: RpdServerEventTypes[K][1],
   ) {
     console.log(`Emit event "${eventName}"`, payload);
@@ -167,15 +172,16 @@ export class RapidServer implements IRpdServer {
 
   async start() {
     console.log("Starting rapid server...");
-    await pluginManager.loadPlugins();
+    const pluginManager = this.#pluginManager;
+    await pluginManager.loadPlugins(this.#plugins);
 
-    await pluginManager.initPlugins(this);
+    await pluginManager.initPlugins();
 
-    await pluginManager.registerMiddlewares(this);
-    await pluginManager.registerHttpHandlers(this);
-    await pluginManager.registerEventHandlers(this);
-    await pluginManager.registerMessageHandlers(this);
-    await pluginManager.registerTaskProcessors(this);
+    await pluginManager.registerMiddlewares();
+    await pluginManager.registerHttpHandlers();
+    await pluginManager.registerEventHandlers();
+    await pluginManager.registerMessageHandlers();
+    await pluginManager.registerTaskProcessors();
 
     await this.configureApplication();
 
@@ -189,6 +195,7 @@ export class RapidServer implements IRpdServer {
       this.#bootstrapApplicationConfig,
     ) as RpdApplicationConfig;
 
+    const pluginManager = this.#pluginManager;
     await pluginManager.onLoadingApplication(this, this.#applicationConfig);
     await pluginManager.configureModels(this, this.#applicationConfig);
     await pluginManager.configureModelProperties(this, this.#applicationConfig);

package/src/types.ts

@@ -1,3 +1,5 @@
+import { RapidPlugin } from "./core/server";
+
 export type RapidServerConfig = {
   baseUrl?: string;
   sessionCookieName: string;
@@ -60,11 +62,11 @@ export interface GetModelOptions {
 }
 
 export type RpdServerEventTypes = {
-  "entity.create": [IPluginInstance, RpdEntityCreateEventPayload];
-  "entity.update": [IPluginInstance, RpdEntityUpdateEventPayload];
-  "entity.delete": [IPluginInstance, RpdEntityDeleteEventPayload];
-  "entity.addRelations": [IPluginInstance, RpdEntityAddRelationsEventPayload];
-  "entity.removeRelations": [IPluginInstance, RpdEntityRemoveRelationsEventPayload];
+  "entity.create": [RapidPlugin, RpdEntityCreateEventPayload];
+  "entity.update": [RapidPlugin, RpdEntityUpdateEventPayload];
+  "entity.delete": [RapidPlugin, RpdEntityDeleteEventPayload];
+  "entity.addRelations": [RapidPlugin, RpdEntityAddRelationsEventPayload];
+  "entity.removeRelations": [RapidPlugin, RpdEntityRemoveRelationsEventPayload];
 };
 
 export interface RpdEntityCreateEventPayload {
@@ -284,13 +286,8 @@ export interface RpdDataModelExtension {
   config: any;
 }
 
-
-export interface IPluginInstance {
-  getName(): string;
-}
-
 export type EventHandler<T = any> = (
-  sender: IPluginInstance,
+  sender: RapidPlugin,
   payload: T,
 ) => void;
 

package/dist/core/plugin.d.ts

@@ -1,6 +0,0 @@
-import { IPluginInstance } from "~/types";
-export default class Plugin implements IPluginInstance {
-    #private;
-    constructor(name: string);
-    getName(): string;
-}

package/dist/plugins/authManager/httpHandlers/deleteSession.d.ts

@@ -1,4 +0,0 @@
-import { HttpHandlerContext } from "~/core/httpHandler";
-import { IPluginInstance } from "~/types";
-export declare const code = "deleteSession";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/authManager/httpHandlers/getMyProfile.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "getMyProfile";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/authManager/mod.d.ts

@@ -1,16 +0,0 @@
-/**
- * Meta manager plugin
- */
-import { IPluginInstance, RpdApplicationConfig } from "~/types";
-import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
-export declare const code = "authManager";
-export declare const description = "authManager";
-export declare const extendingAbilities: RpdServerPluginExtendingAbilities[];
-export declare const configurableTargets: RpdServerPluginConfigurableTargetOptions[];
-export declare const configurations: RpdConfigurationItemOptions[];
-export declare function initPlugin(plugin: IPluginInstance, server: IRpdServer): Promise<void>;
-export declare function registerHttpHandlers(server: IRpdServer): Promise<void>;
-export declare function registerEventHandlers(server: IRpdServer): Promise<void>;
-export declare function configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
-export declare function configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
-export declare function onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/addEntityRelations.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "addEntityRelations";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/countCollectionEntities.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "countCollectionEntities";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/createCollectionEntitiesBatch.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "createCollectionEntitiesBatch";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/createCollectionEntity.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "createCollectionEntity";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/deleteCollectionEntityById.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "deleteCollectionEntityById";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/findCollectionEntities.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "findCollectionEntities";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/findCollectionEntityById.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "findCollectionEntityById";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/queryDatabase.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunQueryDatabaseHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "queryDatabase";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunQueryDatabaseHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/removeEntityRelations.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "removeEntityRelations";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/httpHandlers/updateCollectionEntityById.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "updateCollectionEntityById";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: RunEntityHttpHandlerOptions): Promise<void>;

package/dist/plugins/dataManager/mod.d.ts

@@ -1,16 +0,0 @@
-/**
- * Support manage data in database.
- * This plugin provide:
- * - routes for manage data in database.
- */
-import { IPluginInstance, RpdApplicationConfig } from "~/types";
-import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer } from "~/core/server";
-export declare const code = "dataManager";
-export declare const description = "\u5BF9\u6570\u636E\u8FDB\u884C\u7BA1\u7406\uFF0C\u63D0\u4F9B\u589E\u5220\u6539\u67E5\u7B49\u63A5\u53E3\u3002";
-export declare const extendingAbilities: RpdServerPluginExtendingAbilities[];
-export declare const configurableTargets: RpdServerPluginConfigurableTargetOptions[];
-export declare const configurations: RpdConfigurationItemOptions[];
-export declare function initPlugin(plugin: IPluginInstance, server: IRpdServer): Promise<void>;
-export declare function registerHttpHandlers(server: IRpdServer): Promise<void>;
-export declare function configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
-export declare function onApplicationLoaded(server: IRpdServer, application: RpdApplicationConfig): Promise<void>;

package/dist/plugins/fileManager/httpHandlers/downloadDocument.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "downloadDocument";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/httpHandlers/downloadFile.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "downloadFile";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/httpHandlers/uploadFile.d.ts

@@ -1,4 +0,0 @@
-import { IPluginInstance } from "~/types";
-import { HttpHandlerContext } from "~/core/httpHandler";
-export declare const code = "uploadFile";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;

package/dist/plugins/fileManager/mod.d.ts

@@ -1,15 +0,0 @@
-/**
- * File manager plugin
- */
-import { IPluginInstance, RpdApplicationConfig } from "~/types";
-import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
-export declare const code = "fileManager";
-export declare const description = "fileManager";
-export declare const extendingAbilities: RpdServerPluginExtendingAbilities[];
-export declare const configurableTargets: RpdServerPluginConfigurableTargetOptions[];
-export declare const configurations: RpdConfigurationItemOptions[];
-export declare function initPlugin(plugin: IPluginInstance, server: IRpdServer): Promise<void>;
-export declare function registerHttpHandlers(server: IRpdServer): Promise<void>;
-export declare function registerEventHandlers(server: IRpdServer): Promise<void>;
-export declare function configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
-export declare function onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;

package/dist/plugins/metaManager/httpHandlers/getMetaModelDetail.d.ts

@@ -1,4 +0,0 @@
-import { HttpHandlerContext } from "~/core/httpHandler";
-import { IPluginInstance } from "~/types";
-export declare const code = "getMetaModelDetail";
-export declare function handler(plugin: IPluginInstance, ctx: HttpHandlerContext, options: any): Promise<void>;