@ruiapp/rapid-core 0.1.12 → 0.1.13

package/src/plugins/entityWatch/EntityWatchPlugin.ts

@@ -0,0 +1,96 @@
+import type { RpdEntityCreateEventPayload, RpdServerEventTypes } from "~/types";
+
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+import { EntityWatchHandlerContext, EntityWatchPluginInitOptions, EntityWatcher } from "./EntityWatchPluginTypes";
+import EventManager from "~/core/eventManager";
+
+class EntityWatchPlugin implements RapidPlugin {
+  #createEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>
+  #updateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>
+  #deleteEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>
+  #addRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>
+  #removeRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>
+
+  constructor(options: EntityWatchPluginInitOptions) {
+    const { watchers } = options;
+
+    this.#createEventEmitters = new EventManager();
+    this.#updateEventEmitters = new EventManager();
+    this.#deleteEventEmitters = new EventManager();
+    this.#addRelationsEventEmitters = new EventManager();
+    this.#removeRelationsEventEmitters = new EventManager();
+
+    for (const watcher of watchers) {
+      if (watcher.eventName === "entity.create") {
+        this.#createEventEmitters.on(watcher.modelSingularCode, watcher.handler);
+      } else if (watcher.eventName === "entity.update") {
+        this.#updateEventEmitters.on(watcher.modelSingularCode, watcher.handler);
+      } else if (watcher.eventName === "entity.delete") {
+        this.#deleteEventEmitters.on(watcher.modelSingularCode, watcher.handler);
+      } else if (watcher.eventName === "entity.addRelations") {
+        this.#addRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
+      } else if (watcher.eventName === "entity.removeRelations") {
+        this.#removeRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
+      }
+    }
+  }
+
+  get code(): string {
+    return "entityWatch";
+  }
+
+  get description(): string {
+    return "";
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    server.registerEventHandler("entity.create", this.handleEntityEvent.bind(this, server, "entity.create"));
+    server.registerEventHandler("entity.update", this.handleEntityEvent.bind(this, server, "entity.update"));
+    server.registerEventHandler("entity.delete", this.handleEntityEvent.bind(this, server, "entity.delete"));
+    server.registerEventHandler("entity.addRelations", this.handleEntityEvent.bind(this, server, "entity.addRelations"));
+    server.registerEventHandler("entity.removeRelations", this.handleEntityEvent.bind(this, server, "entity.removeRelations"));
+  }
+
+  handleEntityEvent(
+    server: IRpdServer,
+    eventName: keyof RpdServerEventTypes,
+    sender: RapidPlugin,
+    payload: RpdEntityCreateEventPayload
+    ) {
+    if (sender === this) {
+      return;
+    }
+
+    const { modelSingularCode } = payload;
+    const entityWatchHandlerContext: EntityWatchHandlerContext<typeof eventName> = {
+      server,
+      payload,
+    };
+
+    if (eventName === "entity.create") {
+      this.#createEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+    } else if (eventName === "entity.update") {
+      this.#updateEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+    } else if (eventName === "entity.delete") {
+      this.#deleteEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+    } else if (eventName === "entity.addRelations") {
+      this.#addRelationsEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+    } else if (eventName === "entity.removeRelations") {
+      this.#removeRelationsEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+    }
+  }
+}
+
+export default EntityWatchPlugin;

package/src/plugins/entityWatch/EntityWatchPluginTypes.ts

@@ -0,0 +1,19 @@
+import { IRpdServer } from "~/core/server";
+import { RpdServerEventTypes } from "~/types";
+
+export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes> {
+  eventName: TEventName;
+  modelSingularCode: string;
+  handler: EntityWatchHandler<TEventName>;
+}
+
+export type EntityWatchHandler<TEventName extends keyof RpdServerEventTypes> = (ctx: EntityWatchHandlerContext<TEventName>) => Promise<void>;
+
+export type EntityWatchHandlerContext<TEventName extends keyof RpdServerEventTypes> = {
+  server: IRpdServer;
+  payload: RpdServerEventTypes[TEventName][1];
+}
+
+export interface EntityWatchPluginInitOptions {
+  watchers: EntityWatcher<keyof RpdServerEventTypes>[];
+}

package/src/plugins/serverOperation/ServerOperationPlugin.ts

@@ -0,0 +1,94 @@
+import type { RpdApplicationConfig, RpdRoute } from "~/types";
+
+import pluginActionHandlers from "./actionHandlers";
+import { ServerOperation, ServerOperationPluginInitOptions } from "./ServerOperationPluginTypes";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+
+class ServerOperationPlugin implements RapidPlugin {
+  #operations: ServerOperation[];
+
+  constructor(options: ServerOperationPluginInitOptions) {
+    this.#operations = options.operations || [];
+  }
+
+  get code(): string {
+    return "serverOperation";
+  }
+
+  get description(): string {
+    return "";
+  }
+
+  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> {
+    for (const actionHandler of pluginActionHandlers) {
+      server.registerActionHandler(this, actionHandler);
+    }
+  }
+
+  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> {
+    const routes: RpdRoute[] = [];
+    for (const operation of this.#operations) {
+      routes.push({
+        namespace: "app",
+        name: `app.operations.${operation.code}`,
+        code: `app.operations.${operation.code}`,
+        type: "RESTful",
+        method: operation.method,
+        endpoint: `/app/${operation.code}`,
+        actions: [
+          {
+            code: "runServerOperation",
+            config: {
+              operation: operation.handler,
+            }
+          },
+        ],
+      })
+    }
+    server.appendApplicationConfig({ routes });
+  }
+
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+
+  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+}
+
+export default ServerOperationPlugin;

package/src/plugins/serverOperation/ServerOperationPluginTypes.ts

@@ -0,0 +1,13 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RpdHttpMethod } from "~/types";
+
+export interface ServerOperation {
+  code: string;
+  description?: string;
+  method: RpdHttpMethod;
+  handler: (ctx: ActionHandlerContext) => Promise<void>;
+}
+
+export interface ServerOperationPluginInitOptions {
+  operations: ServerOperation[];
+}

package/src/plugins/serverOperation/actionHandlers/index.ts

@@ -0,0 +1,6 @@
+import { IPluginActionHandler } from "~/core/actionHandler";
+import * as runServerOperation from "./runServerOperation";
+
+export default [
+  runServerOperation,
+] satisfies IPluginActionHandler[];

package/src/plugins/serverOperation/actionHandlers/runServerOperation.ts

@@ -0,0 +1,15 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+
+export const code = "runServerOperation";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: {
+    operation: (ctx: ActionHandlerContext) => Promise<void>;
+  },
+) {
+  const { operation } = options;
+  await operation(ctx);
+}

package/src/server.ts

@@ -35,7 +35,7 @@ export interface InitServerOptions {
 export class RapidServer implements IRpdServer {
   #pluginManager: PluginManager;
   #plugins: RapidPlugin[];
-  #eventManager: EventManager;
+  #eventManager: EventManager<RpdServerEventTypes>;
   #middlewares: any[];
   #bootstrapApplicationConfig: RpdApplicationConfig;
   #applicationConfig: RpdApplicationConfig;

package/src/types.ts

@@ -431,10 +431,21 @@ export interface UpdateEntityOptions {
 
 export interface UpdateEntityByIdOptions {
   id: any;
-  entity: any;
-  changes: any;
+  entityToSave: any;
 }
 
 export interface DeleteEntityOptions {
   filters?: EntityFilterOptions[];
 }
+
+export interface AddEntityRelationsOptions {
+  id: number;
+  property: string;
+  relations: {id?: number, [k: string]: any}[];
+}
+
+export interface RemoveEntityRelationsOptions {
+  id: number;
+  property: string;
+  relations: {id?: number, [k: string]: any}[];
+}