@ruiapp/rapid-core 0.0.1

package/src/plugins/dataManager/httpHandlers/removeEntityRelations.ts

@@ -0,0 +1,72 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { mergeInput } from "~/helpers/inputHelper";
+import { isRelationProperty } from "~/utilities/rapidUtility";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "removeEntityRelations";
+
+interface RemoveEntityRelationsInput {
+  id: number;
+  property: string;
+  relations: {id?: number, [k: string]: any}[];
+}
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { queryBuilder } = server;
+  const { defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+  console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+
+  const dataAccessor = server.getDataAccessor(options);
+  const model = dataAccessor.getModel();
+
+  const {id, property, relations} = mergedInput as RemoveEntityRelationsInput;
+  const row = await dataAccessor.findById(id);
+  if (!row) {
+    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+  }
+
+  console.log(mergedInput);
+
+  const relationProperty = model.properties.find(e => e.code === property);
+  if (!relationProperty) {
+    throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
+  }
+
+  if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+    throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
+  }
+
+  if (relationProperty.linkTableName) {
+    for (const relation of relations) {
+      const command = `DELETE FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
+  WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2;`;
+      const params = [id, relation.id];
+      await server.queryDatabaseObject(command, params);
+    }
+  }
+
+  ctx.output = {};
+
+  server.emitEvent(
+    "entity.removeRelations",
+    plugin,
+    {
+      namespace: options.namespace,
+      modelSingularCode: options.singularCode,
+      entity: row,
+      property,
+      relations: relations,
+    },
+  );
+}

package/src/plugins/dataManager/httpHandlers/updateCollectionEntityById.ts

@@ -0,0 +1,53 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { getEntityPartChanges } from "~/helpers/entityHelpers";
+import { mergeInput } from "~/helpers/inputHelper";
+import { updateEntityById } from "~/dataAccess/entityManager";
+import { mapDbRowToEntity } from "~/dataAccess/entityMapper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "updateCollectionEntityById";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+  console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+
+  const dataAccessor = server.getDataAccessor(options);
+  const id = mergedInput.id;
+  const row = await dataAccessor.findById(id);
+  if (!row) {
+    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+  }
+
+  const entity = mapDbRowToEntity(dataAccessor.getModel(), row);
+  const changes = getEntityPartChanges(entity, mergedInput);
+  if (!changes) {
+    ctx.output = entity;
+    return;
+  }
+
+  const output = await updateEntityById(server, dataAccessor, { id, entity, changes });
+  ctx.output = output;
+
+  server.emitEvent(
+    "entity.update",
+    plugin,
+    {
+      namespace: options.namespace,
+      modelSingularCode: options.singularCode,
+      before: entity,
+      after: output,
+      changes: changes,
+    },
+  );
+}

package/src/plugins/dataManager/mod.ts

@@ -0,0 +1,150 @@
+/**
+ * Support manage data in database.
+ * This plugin provide:
+ * - routes for manage data in database.
+ */
+
+import * as _ from "lodash";
+import {
+  IPluginInstance,
+  RpdApplicationConfig,
+  RpdHttpMethod,
+  RunEntityHttpHandlerOptions,
+} from "~/types";
+
+import * as findCollectionEntitiesHttpHandler from "./httpHandlers/findCollectionEntities";
+import * as findCollectionEntityById from "./httpHandlers/findCollectionEntityById";
+import * as countCollectionEntities from "./httpHandlers/countCollectionEntities";
+import * as createCollectionEntity from "./httpHandlers/createCollectionEntity";
+import * as createCollectionEntitiesBatch from "./httpHandlers/createCollectionEntitiesBatch";
+import * as updateCollectionEntityById from "./httpHandlers/updateCollectionEntityById";
+import * as deleteCollectionEntityById from "./httpHandlers/deleteCollectionEntityById";
+import * as addEntityRelations from "./httpHandlers/addEntityRelations";
+import * as removeEntityRelations from "./httpHandlers/removeEntityRelations";
+import * as queryDatabase from "./httpHandlers/queryDatabase";
+import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer } from "~/core/server";
+
+export const code = "dataManager";
+export const description = "对数据进行管理，提供增删改查等接口。";
+export const extendingAbilities: RpdServerPluginExtendingAbilities[] = [];
+export const configurableTargets: RpdServerPluginConfigurableTargetOptions[] = [];
+export const configurations: RpdConfigurationItemOptions[] = [];
+
+const routeConfigs: {
+  code: string;
+  method: RpdHttpMethod;
+  endpoint: string;
+  handlerCode: string;
+}[] = [
+  {
+    code: "createBatch",
+    method: "post",
+    endpoint: "/operations/create_batch",
+    handlerCode: "createCollectionEntitiesBatch",
+  },
+  {
+    code: "find",
+    method: "post",
+    endpoint: "/operations/find",
+    handlerCode: "findCollectionEntities",
+  },
+  {
+    code: "count",
+    method: "post",
+    endpoint: "/operations/count",
+    handlerCode: "countCollectionEntities",
+  },
+  {
+    code: "addRelations",
+    method: "post",
+    endpoint: "/operations/add_relations",
+    handlerCode: "addEntityRelations",
+  },
+  {
+    code: "removeRelations",
+    method: "post",
+    endpoint: "/operations/remove_relations",
+    handlerCode: "removeEntityRelations",
+  },
+  {
+    code: "getById",
+    method: "get",
+    endpoint: "/:id",
+    handlerCode: "findCollectionEntityById",
+  },
+  {
+    code: "create",
+    method: "post",
+    endpoint: "",
+    handlerCode: "createCollectionEntity",
+  },
+  {
+    code: "updateById",
+    method: "post",
+    endpoint: "/:id",
+    handlerCode: "updateCollectionEntityById",
+  },
+  {
+    code: "deleteById",
+    method: "delete",
+    endpoint: "/:id",
+    handlerCode: "deleteCollectionEntityById",
+  },
+];
+
+let _plugin: IPluginInstance;
+
+export async function initPlugin(plugin: IPluginInstance, server: IRpdServer) {
+  _plugin = plugin;
+}
+
+export async function registerHttpHandlers(server: IRpdServer) {
+  server.registerHttpHandler(_plugin, findCollectionEntitiesHttpHandler);
+  server.registerHttpHandler(_plugin, findCollectionEntityById);
+  server.registerHttpHandler(_plugin, countCollectionEntities);
+  server.registerHttpHandler(_plugin, createCollectionEntity);
+  server.registerHttpHandler(_plugin, createCollectionEntitiesBatch);
+  server.registerHttpHandler(_plugin, updateCollectionEntityById);
+  server.registerHttpHandler(_plugin, addEntityRelations);
+  server.registerHttpHandler(_plugin, removeEntityRelations);
+  server.registerHttpHandler(_plugin, deleteCollectionEntityById);
+  server.registerHttpHandler(_plugin, queryDatabase);
+}
+
+export async function configureRoutes(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  const { routes, models } = applicationConfig;
+
+  models.forEach((model) => {
+    const { namespace, singularCode, pluralCode } = model;
+
+    routeConfigs.forEach((routeConfig) => {
+      routes.push({
+        namespace,
+        name: `${namespace}.${singularCode}.${routeConfig.code}`,
+        code: `${namespace}.${singularCode}.${routeConfig.code}`,
+        type: "RESTful",
+        method: routeConfig.method,
+        endpoint: `/api/${namespace}/${pluralCode}${routeConfig.endpoint}`,
+        handlers: [
+          {
+            code: routeConfig.handlerCode,
+            config: {
+              namespace,
+              singularCode,
+            } as RunEntityHttpHandlerOptions,
+          },
+        ],
+      });
+    });
+  });
+}
+
+export async function onApplicationLoaded(
+  server: IRpdServer,
+  application: RpdApplicationConfig,
+) {
+  console.log("[dataManager.onApplicationLoaded]");
+}

package/src/plugins/metaManager/httpHandlers/getMetaModelDetail.ts

@@ -0,0 +1,14 @@
+import { HttpHandlerContext } from "~/core/httpHandler";
+import { IPluginInstance } from "~/types";
+
+export const code = "getMetaModelDetail";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, input } = ctx;
+  const model = server.getModel(input);
+  ctx.output = model;
+}

package/src/plugins/metaManager/httpHandlers/listMetaModels.ts

@@ -0,0 +1,13 @@
+import { HttpHandlerContext } from "~/core/httpHandler";
+import { IPluginInstance } from "~/types";
+
+export const code = "listMetaModels";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { applicationConfig } = ctx;
+  ctx.output = { list: applicationConfig.models };
+}