@ruiapp/rapid-core 0.1.78 → 0.1.80

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from "./core/server";
 export * from "./core/http-types";
 export * from "./core/actionHandler";
 export * from "./utilities/jwtUtility";
+export { mapDbRowToEntity } from "./dataAccess/entityMapper";
 export * as bootstrapApplicationConfig from "./bootstrapApplicationConfig";
 export { default as MetaManagePlugin } from "./plugins/metaManage/MetaManagePlugin";
 export { default as DataManagePlugin } from "./plugins/dataManage/DataManagePlugin";

package/dist/index.js

@@ -4006,32 +4006,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$s = "listMetaModels";
-async function handler$s(plugin, ctx, options) {
+const code$t = "listMetaModels";
+async function handler$t(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$s,
-  handler: handler$s
+  code: code$t,
+  handler: handler$t
 });
 
-const code$r = "listMetaRoutes";
-async function handler$r(plugin, ctx, options) {
+const code$s = "listMetaRoutes";
+async function handler$s(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$r,
-  handler: handler$r
+  code: code$s,
+  handler: handler$s
 });
 
-const code$q = "getMetaModelDetail";
-async function handler$q(plugin, ctx, options) {
+const code$r = "getMetaModelDetail";
+async function handler$r(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -4039,8 +4039,8 @@ async function handler$q(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$q,
-  handler: handler$q
+  code: code$r,
+  handler: handler$r
 });
 
 /**
@@ -4459,9 +4459,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$p = "findCollectionEntities";
-async function handler$p(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$p, async (entityManager, input) => {
+const code$q = "findCollectionEntities";
+async function handler$q(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$q, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         const entities = await entityManager.findEntities(input);
@@ -4477,14 +4477,14 @@ async function handler$p(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$p,
-  handler: handler$p
+  code: code$q,
+  handler: handler$q
 });
 
-const code$o = "findCollectionEntityById";
-async function handler$o(plugin, ctx, options) {
+const code$p = "findCollectionEntityById";
+async function handler$p(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$o} handler...`, { input });
+    logger.debug(`Running ${code$p} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById({
@@ -4499,13 +4499,13 @@ async function handler$o(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$p,
+  handler: handler$p
 });
 
-const code$n = "countCollectionEntities";
-async function handler$n(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$n, (entityManager, input) => {
+const code$o = "countCollectionEntities";
+async function handler$o(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$o, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         return entityManager.count(input);
@@ -4514,16 +4514,16 @@ async function handler$n(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "createCollectionEntity";
-async function handler$m(plugin, ctx, options) {
+const code$n = "createCollectionEntity";
+async function handler$n(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$m} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$n} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     const output = await entityManager.createEntity({
         entity: input,
@@ -4534,15 +4534,15 @@ async function handler$m(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
-const code$l = "createCollectionEntitiesBatch";
-async function handler$l(plugin, ctx, options) {
+const code$m = "createCollectionEntitiesBatch";
+async function handler$m(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$l} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$m} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -4566,16 +4566,16 @@ async function handler$l(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
-const code$k = "updateCollectionEntityById";
-async function handler$k(plugin, ctx, options) {
+const code$l = "updateCollectionEntityById";
+async function handler$l(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$k} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$l} handler...`, { defaultInput, fixedInput, mergedInput });
     const operation = mergedInput.$operation;
     if (operation) {
         delete mergedInput.$operation;
@@ -4597,6 +4597,35 @@ async function handler$k(plugin, ctx, options) {
 }
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$l,
+  handler: handler$l
+});
+
+const code$k = "deleteCollectionEntities";
+async function handler$k(plugin, ctx, options) {
+    const { logger, server, routerContext } = ctx;
+    const input = ctx.input;
+    logger.debug(`Running ${code$k} handler...`);
+    if (!input.filters || !input.filters.length) {
+        throw new Error("Filters are required when deleting entities.");
+    }
+    const entityManager = server.getEntityManager(options.singularCode);
+    const entities = await entityManager.findEntities({
+        routeContext: routerContext,
+        filters: input.filters,
+    });
+    for (const entity of entities) {
+        await entityManager.deleteById({
+            routeContext: ctx.routerContext,
+            id: entity.id,
+        }, plugin);
+    }
+    ctx.status = 200;
+    ctx.output = {};
+}
+
+var deleteCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
   code: code$k,
   handler: handler$k
@@ -4702,6 +4731,12 @@ const routeConfigs = [
         endpoint: "/operations/count",
         handlerCode: "countCollectionEntities",
     },
+    {
+        code: "delete",
+        method: "POST",
+        endpoint: "/operations/delete",
+        handlerCode: "deleteCollectionEntities",
+    },
     {
         code: "addRelations",
         method: "POST",
@@ -4764,6 +4799,7 @@ class DataManager {
         server.registerActionHandler(this, updateCollectionEntityById);
         server.registerActionHandler(this, addEntityRelations);
         server.registerActionHandler(this, removeEntityRelations);
+        server.registerActionHandler(this, deleteCollectionEntities);
         server.registerActionHandler(this, deleteCollectionEntityById);
         server.registerActionHandler(this, queryDatabase);
     }
@@ -7306,7 +7342,7 @@ class EntityAccessControlPlugin {
                         lodash.set(action, "config.permissionCheck", permissionPolicies.update);
                     }
                 }
-                else if (action.code === "deleteCollectionEntityById") {
+                else if (action.code === "deleteCollectionEntityById" || action.code === "deleteCollectionEntities") {
                     const model = lodash.find(applicationConfig.models, (item) => item.singularCode === action.config.singularCode);
                     if (!model) {
                         continue;
@@ -7370,4 +7406,5 @@ exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;
 exports.createJwt = createJwt;
 exports.decodeJwt = decodeJwt;
 exports.generateJwtSecretKey = generateJwtSecretKey;
+exports.mapDbRowToEntity = mapDbRowToEntity;
 exports.verifyJwt = verifyJwt;

package/dist/plugins/dataManage/actionHandlers/deleteCollectionEntities.d.ts

@@ -0,0 +1,8 @@
+import { FindEntityOptions, RunEntityActionHandlerOptions } from "../../../types";
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export interface DeleteCollectionEntitiesInput {
+    filters: FindEntityOptions["filters"];
+}
+export declare const code = "deleteCollectionEntities";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/rollup.config.js

@@ -1,16 +1,16 @@
-import typescript from "rollup-plugin-typescript2";
-import tscAlias from "rollup-plugin-tsc-alias";
-
-export default {
-  input: ["src/index.ts"],
-  output: [
-    {
-      dir: "dist",
-      entryFileNames: "[name].js",
-      format: "cjs",
-      exports: "named",
-    },
-  ],
-  plugins: [typescript(), tscAlias()],
-  external: [],
-};
+import typescript from "rollup-plugin-typescript2";
+import tscAlias from "rollup-plugin-tsc-alias";
+
+export default {
+  input: ["src/index.ts"],
+  output: [
+    {
+      dir: "dist",
+      entryFileNames: "[name].js",
+      format: "cjs",
+      exports: "named",
+    },
+  ],
+  plugins: [typescript(), tscAlias()],
+  external: [],
+};

package/src/core/actionHandler.ts

@@ -1,22 +1,22 @@
-import { RpdApplicationConfig } from "~/types";
-import { IRpdServer, RapidPlugin } from "./server";
-import { Next, RouteContext } from "./routeContext";
-import { Logger } from "~/facilities/log/LogFacility";
-
-export interface ActionHandlerContext {
-  logger: Logger;
-  routerContext: RouteContext;
-  next: Next;
-  server: IRpdServer;
-  applicationConfig: RpdApplicationConfig;
-  input?: any;
-  output?: any;
-  status?: Response["status"];
-}
-
-export type ActionHandler = (ctx: ActionHandlerContext, options: any) => void | Promise<void>;
-
-export interface IPluginActionHandler {
-  code: string;
-  handler: (plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) => void | Promise<void>;
-}
+import { RpdApplicationConfig } from "~/types";
+import { IRpdServer, RapidPlugin } from "./server";
+import { Next, RouteContext } from "./routeContext";
+import { Logger } from "~/facilities/log/LogFacility";
+
+export interface ActionHandlerContext {
+  logger: Logger;
+  routerContext: RouteContext;
+  next: Next;
+  server: IRpdServer;
+  applicationConfig: RpdApplicationConfig;
+  input?: any;
+  output?: any;
+  status?: Response["status"];
+}
+
+export type ActionHandler = (ctx: ActionHandlerContext, options: any) => void | Promise<void>;
+
+export interface IPluginActionHandler {
+  code: string;
+  handler: (plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) => void | Promise<void>;
+}

package/src/core/eventManager.ts

@@ -1,20 +1,20 @@
-import { EventEmitter } from "events";
-
-export default class EventManager<EventTypes extends Record<string, any[]>> {
-  #eventEmitter: EventEmitter;
-
-  constructor() {
-    this.#eventEmitter = new EventEmitter();
-  }
-
-  on<K extends keyof EventTypes>(eventName: K, listener: (...args: EventTypes[K]) => void) {
-    this.#eventEmitter.on(eventName as string, listener);
-  }
-
-  async emit<K extends keyof EventTypes>(eventName: K, ...args: EventTypes[K]) {
-    const listeners = this.#eventEmitter.listeners(eventName as string);
-    for (const listener of listeners) {
-      await listener(...args);
-    }
-  }
-}
+import { EventEmitter } from "events";
+
+export default class EventManager<EventTypes extends Record<string, any[]>> {
+  #eventEmitter: EventEmitter;
+
+  constructor() {
+    this.#eventEmitter = new EventEmitter();
+  }
+
+  on<K extends keyof EventTypes>(eventName: K, listener: (...args: EventTypes[K]) => void) {
+    this.#eventEmitter.on(eventName as string, listener);
+  }
+
+  async emit<K extends keyof EventTypes>(eventName: K, ...args: EventTypes[K]) {
+    const listeners = this.#eventEmitter.listeners(eventName as string);
+    for (const listener of listeners) {
+      await listener(...args);
+    }
+  }
+}

package/src/core/facility.ts

@@ -1,7 +1,7 @@
-import { IRpdServer } from "./server";
-
-export interface FacilityFactory {
-  name: string;
-
-  createFacility: (server: IRpdServer, options?: any) => Promise<any>;
-}
+import { IRpdServer } from "./server";
+
+export interface FacilityFactory {
+  name: string;
+
+  createFacility: (server: IRpdServer, options?: any) => Promise<any>;
+}

package/src/core/http/formDataParser.ts

@@ -1,89 +1,89 @@
-import type { RapidRequest } from "../request";
-
-export type BodyData = Record<string, string | File | (string | File)[]>;
-export type ParseBodyOptions = {
-  /**
-   * Parse all fields with multiple values should be parsed as an array.
-   * @default false
-   * @example
-   * ```ts
-   * const data = new FormData()
-   * data.append('file', 'aaa')
-   * data.append('file', 'bbb')
-   * data.append('message', 'hello')
-   * ```
-   *
-   * If `all` is `false`:
-   * parseBody should return `{ file: 'bbb', message: 'hello' }`
-   *
-   * If `all` is `true`:
-   * parseBody should return `{ file: ['aaa', 'bbb'], message: 'hello' }`
-   */
-  all?: boolean;
-};
-
-export const parseFormDataBody = async <T extends BodyData = BodyData>(request: Request, options: ParseBodyOptions = { all: false }): Promise<T> => {
-  const contentType = request.headers.get("Content-Type");
-
-  if (isFormDataContent(contentType)) {
-    return parseFormData<T>(request, options);
-  }
-
-  return {} as T;
-};
-
-function isFormDataContent(contentType: string | null): boolean {
-  if (contentType === null) {
-    return false;
-  }
-
-  return contentType.startsWith("multipart/form-data") || contentType.startsWith("application/x-www-form-urlencoded");
-}
-
-async function parseFormData<T extends BodyData = BodyData>(request: Request, options: ParseBodyOptions): Promise<T> {
-  const formData = await (request as Request).formData();
-
-  if (formData) {
-    return convertFormDataToBodyData<T>(formData, options);
-  }
-
-  return {} as T;
-}
-
-function convertFormDataToBodyData<T extends BodyData = BodyData>(formData: FormData, options: ParseBodyOptions): T {
-  const form: BodyData = {};
-
-  formData.forEach((value, key) => {
-    const shouldParseAllValues = options.all || key.endsWith("[]");
-
-    if (!shouldParseAllValues) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-
-  return form as T;
-}
-
-const handleParsingAllValues = (form: BodyData, key: string, value: FormDataEntryValue): void => {
-  if (form[key] && isArrayField(form[key])) {
-    appendToExistingArray(form[key] as (string | File)[], value);
-  } else if (form[key]) {
-    convertToNewArray(form, key, value);
-  } else {
-    form[key] = value;
-  }
-};
-
-function isArrayField(field: unknown): field is (string | File)[] {
-  return Array.isArray(field);
-}
-
-const appendToExistingArray = (arr: (string | File)[], value: FormDataEntryValue): void => {
-  arr.push(value);
-};
-
-const convertToNewArray = (form: BodyData, key: string, value: FormDataEntryValue): void => {
-  form[key] = [form[key] as string | File, value];
-};
+import type { RapidRequest } from "../request";
+
+export type BodyData = Record<string, string | File | (string | File)[]>;
+export type ParseBodyOptions = {
+  /**
+   * Parse all fields with multiple values should be parsed as an array.
+   * @default false
+   * @example
+   * ```ts
+   * const data = new FormData()
+   * data.append('file', 'aaa')
+   * data.append('file', 'bbb')
+   * data.append('message', 'hello')
+   * ```
+   *
+   * If `all` is `false`:
+   * parseBody should return `{ file: 'bbb', message: 'hello' }`
+   *
+   * If `all` is `true`:
+   * parseBody should return `{ file: ['aaa', 'bbb'], message: 'hello' }`
+   */
+  all?: boolean;
+};
+
+export const parseFormDataBody = async <T extends BodyData = BodyData>(request: Request, options: ParseBodyOptions = { all: false }): Promise<T> => {
+  const contentType = request.headers.get("Content-Type");
+
+  if (isFormDataContent(contentType)) {
+    return parseFormData<T>(request, options);
+  }
+
+  return {} as T;
+};
+
+function isFormDataContent(contentType: string | null): boolean {
+  if (contentType === null) {
+    return false;
+  }
+
+  return contentType.startsWith("multipart/form-data") || contentType.startsWith("application/x-www-form-urlencoded");
+}
+
+async function parseFormData<T extends BodyData = BodyData>(request: Request, options: ParseBodyOptions): Promise<T> {
+  const formData = await (request as Request).formData();
+
+  if (formData) {
+    return convertFormDataToBodyData<T>(formData, options);
+  }
+
+  return {} as T;
+}
+
+function convertFormDataToBodyData<T extends BodyData = BodyData>(formData: FormData, options: ParseBodyOptions): T {
+  const form: BodyData = {};
+
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+
+  return form as T;
+}
+
+const handleParsingAllValues = (form: BodyData, key: string, value: FormDataEntryValue): void => {
+  if (form[key] && isArrayField(form[key])) {
+    appendToExistingArray(form[key] as (string | File)[], value);
+  } else if (form[key]) {
+    convertToNewArray(form, key, value);
+  } else {
+    form[key] = value;
+  }
+};
+
+function isArrayField(field: unknown): field is (string | File)[] {
+  return Array.isArray(field);
+}
+
+const appendToExistingArray = (arr: (string | File)[], value: FormDataEntryValue): void => {
+  arr.push(value);
+};
+
+const convertToNewArray = (form: BodyData, key: string, value: FormDataEntryValue): void => {
+  form[key] = [form[key] as string | File, value];
+};