@ruiapp/rapid-core 0.1.81 → 0.1.83

package/dist/index.js

@@ -2262,6 +2262,9 @@ function convertEntityOrderByToRowOrderBy(server, model, baseModel, orderByList)
         }
         if (relationField) {
             const relationProperty = getEntityPropertyByCode(server, model, relationField);
+            if (!relationProperty) {
+                throw new Error(`Property '${relationProperty}' was not found in ${model.namespace}.${model.singularCode}`);
+            }
             if (!isRelationProperty(relationProperty)) {
                 throw new Error("orderBy[].relation must be a one-relation property.");
             }
@@ -2318,7 +2321,12 @@ async function findEntities(server, dataAccessor, options) {
     let relationOptions = options.relations || {};
     let relationPropertyCodes = Object.keys(relationOptions) || [];
     if (!options.properties || !options.properties.length) {
-        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property) || relationPropertyCodes.includes(property.code));
+        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => {
+            if (!property) {
+                throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
+            }
+            return !options.keepNonPropertyFields || isRelationProperty(property) || relationPropertyCodes.includes(property.code);
+        });
     }
     else {
         propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code) || relationPropertyCodes.includes(property.code));
@@ -2326,6 +2334,9 @@ async function findEntities(server, dataAccessor, options) {
     const columnsToSelect = [];
     const relationPropertiesToSelect = [];
     lodash.forEach(propertiesToSelect, (property) => {
+        if (!property) {
+            throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
+        }
         if (isRelationProperty(property)) {
             relationPropertiesToSelect.push(property);
             if (property.relation === "one" && !property.linkTableName) {
@@ -2864,8 +2875,7 @@ async function createEntity(server, dataAccessor, options, plugin) {
     lodash.keys(entity).forEach((propertyCode) => {
         const property = getEntityPropertyByCode(server, model, propertyCode);
         if (!property) {
-            // Unknown property
-            return;
+            throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
         }
         if (isRelationProperty(property)) {
             if (property.relation === "many") {
@@ -3097,8 +3107,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     lodash.keys(changes).forEach((propertyCode) => {
         const property = getEntityPropertyByCode(server, model, propertyCode);
         if (!property) {
-            // Unknown property
-            return;
+            throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
         }
         if (isRelationProperty(property)) {
             if (property.relation === "many") {
@@ -3181,12 +3190,41 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         if (!lodash.isArray(relatedEntitiesToBeSaved)) {
             throw new Error(`Value of field '${property.code}' should be an array.`);
         }
+        const targetIdsToKeep = [];
+        for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
+            let relatedEntityId;
+            if (lodash.isObject(relatedEntityToBeSaved)) {
+                relatedEntityId = relatedEntityToBeSaved["id"];
+            }
+            else {
+                relatedEntityId = relatedEntityToBeSaved;
+            }
+            if (relatedEntityId) {
+                targetIdsToKeep.push(relatedEntityId);
+            }
+        }
+        let currentTargetIds = [];
         if (property.linkTableName) {
-            // TODO: should support removing relation
+            const targetLinks = await server.queryDatabaseObject(`SELECT ${server.queryBuilder.quoteObject(property.targetIdColumnName)} FROM ${server.queryBuilder.quoteTable({
+                schema: property.linkSchema,
+                tableName: property.linkTableName,
+            })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1`, [id]);
+            currentTargetIds = targetLinks.map((item) => item[property.targetIdColumnName]);
             await server.queryDatabaseObject(`DELETE FROM ${server.queryBuilder.quoteTable({
                 schema: property.linkSchema,
                 tableName: property.linkTableName,
+            })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1
+              AND ${server.queryBuilder.quoteObject(property.targetIdColumnName)} <> ALL($2::int[])`, [id, targetIdsToKeep]);
+        }
+        else {
+            const targetModel = server.getModel({
+                singularCode: property.targetSingularCode,
+            });
+            const targetRows = await server.queryDatabaseObject(`SELECT id FROM ${server.queryBuilder.quoteTable({
+                schema: targetModel.schema,
+                tableName: targetModel.tableName,
             })} WHERE ${server.queryBuilder.quoteObject(property.selfIdColumnName)} = $1`, [id]);
+            currentTargetIds = targetRows.map((item) => item.id);
         }
         for (const relatedEntityToBeSaved of relatedEntitiesToBeSaved) {
             let relatedEntityId;
@@ -3218,6 +3256,31 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
                     if (!targetEntity) {
                         throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
                     }
+                    if (!currentTargetIds.includes(relatedEntityId)) {
+                        if (property.linkTableName) {
+                            const command = `INSERT INTO ${server.queryBuilder.quoteTable({
+                                schema: property.linkSchema,
+                                tableName: property.linkTableName,
+                            })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
+                            const params = [id, relatedEntityId];
+                            await server.queryDatabaseObject(command, params);
+                        }
+                        else {
+                            await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: id });
+                            targetEntity[property.selfIdColumnName] = id;
+                        }
+                    }
+                    relatedEntities.push(targetEntity);
+                }
+            }
+            else {
+                // fieldValue is id
+                relatedEntityId = relatedEntityToBeSaved;
+                const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+                if (!targetEntity) {
+                    throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
+                }
+                if (!currentTargetIds.includes(relatedEntityId)) {
                     if (property.linkTableName) {
                         const command = `INSERT INTO ${server.queryBuilder.quoteTable({
                             schema: property.linkSchema,
@@ -3230,27 +3293,6 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
                         await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: id });
                         targetEntity[property.selfIdColumnName] = id;
                     }
-                    relatedEntities.push(targetEntity);
-                }
-            }
-            else {
-                // fieldValue is id
-                relatedEntityId = relatedEntityToBeSaved;
-                const targetEntity = await targetDataAccessor.findById(relatedEntityId);
-                if (!targetEntity) {
-                    throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
-                }
-                if (property.linkTableName) {
-                    const command = `INSERT INTO ${server.queryBuilder.quoteTable({
-                        schema: property.linkSchema,
-                        tableName: property.linkTableName,
-                    })} (${server.queryBuilder.quoteObject(property.selfIdColumnName)}, ${property.targetIdColumnName}) VALUES ($1, $2) ON CONFLICT DO NOTHING;`;
-                    const params = [id, relatedEntityId];
-                    await server.queryDatabaseObject(command, params);
-                }
-                else {
-                    await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName]: id });
-                    targetEntity[property.selfIdColumnName] = id;
                 }
                 relatedEntities.push(targetEntity);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "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];
+};