@ruiapp/rapid-core 0.1.41 → 0.1.43

package/src/core/routesBuilder.ts

@@ -7,16 +7,13 @@ import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { Next, RouteContext } from "./routeContext";
 import { cloneDeep } from "lodash";
 
-export async function buildRoutes(
-  server: IRpdServer,
-  applicationConfig: RpdApplicationConfig,
-) {
+export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
   const logger = server.getLogger();
   const router = new Router();
 
   let baseUrl = server.config.baseUrl;
   if (baseUrl) {
-    if (baseUrl.endsWith('/')) {
+    if (baseUrl.endsWith("/")) {
       baseUrl = baseUrl.substring(0, baseUrl.length - 1);
     }
   } else {
@@ -30,67 +27,61 @@ export async function buildRoutes(
 
     const routePath = baseUrl + routeConfig.endpoint;
 
-    (router as any)[routeConfig.method.toLowerCase()](
-      routePath,
-      async (routerContext: RouteContext, next: Next) => {
-        routerContext.routeConfig = cloneDeep(routeConfig);
-        const { request, params } = routerContext;
+    (router as any)[routeConfig.method.toLowerCase()](routePath, async (routerContext: RouteContext, next: Next) => {
+      routerContext.routeConfig = cloneDeep(routeConfig);
+      const { request, params } = routerContext;
 
-        let search = request.url.search;
-        if (search && search.startsWith("?")) {
-          search = search.substring(1);
-        }
-        const query = qs.parse(search);
-        const input = Object.assign({}, params, query);
+      let search = request.url.search;
+      if (search && search.startsWith("?")) {
+        search = search.substring(1);
+      }
+      const query = qs.parse(search);
+      const input = Object.assign({}, params, query);
 
-        const requestMethod = request.method;
-        if (
-          (requestMethod === "POST" || requestMethod === "PUT" ||
-            requestMethod === "PATCH")
-        ) {
-          const body = request.body;
-          if (body) {
-            Object.assign(input, body.value);
-          }
+      const requestMethod = request.method;
+      if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
+        const body = request.body;
+        if (body) {
+          Object.assign(input, body.value);
         }
+      }
 
-        // Normalize input value
-
-        logger.debug("Processing rapid request.", {
-          method: requestMethod,
-          url: request.url.toString(),
-          input
-        });
+      // Normalize input value
 
-        let handlerContext: ActionHandlerContext = {
-          logger,
-          routerContext,
-          next,
-          server,
-          applicationConfig,
-          input,
-        };
+      logger.debug("Processing rapid request.", {
+        method: requestMethod,
+        url: request.url.toString(),
+        input,
+      });
 
-        await server.beforeRunRouteActions(handlerContext);
+      let handlerContext: ActionHandlerContext = {
+        logger,
+        routerContext,
+        next,
+        server,
+        applicationConfig,
+        input,
+      };
 
-        for (const actionConfig of routeConfig.actions) {
-          const actionCode = actionConfig.code;
-          const handler = server.getActionHandlerByCode(actionCode);
-          if (!handler) {
-            throw new Error("Unknown handler: " + actionCode);
-          }
+      await server.beforeRunRouteActions(handlerContext);
 
-          const result = handler(handlerContext, actionConfig.config);
-          if (result instanceof Promise) {
-            await result;
-          }
+      for (const actionConfig of routeConfig.actions) {
+        const actionCode = actionConfig.code;
+        const handler = server.getActionHandlerByCode(actionCode);
+        if (!handler) {
+          throw new Error("Unknown handler: " + actionCode);
         }
 
-        if (!isNullOrUndefined(handlerContext.output)) {
-          routerContext.json(handlerContext.output, handlerContext.status);
+        const result = handler(handlerContext, actionConfig.config);
+        if (result instanceof Promise) {
+          await result;
         }
-      },
-    );
+      }
+
+      if (!isNullOrUndefined(handlerContext.output)) {
+        routerContext.json(handlerContext.output, handlerContext.status);
+      }
+    });
   });
 
   return router.routes();

package/src/core/server.ts

@@ -13,25 +13,14 @@ export interface IRpdServer {
 
   registerFacilityFactory(factory: FacilityFactory);
 
-  getFacility<TFacility=any>(name: string, options?: any): Promise<TFacility>;
+  getFacility<TFacility = any>(name: string, options?: any): Promise<TFacility>;
 
-  queryDatabaseObject: (
-    sql: string,
-    params?: unknown[] | Record<string, unknown>,
-  ) => Promise<any[]>;
-  tryQueryDatabaseObject: (
-    sql: string,
-    params?: unknown[] | Record<string, unknown>,
-  ) => Promise<any[]>;
+  queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
+  tryQueryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
   registerMiddleware(middleware: any): void;
-  registerActionHandler(
-    plugin: RapidPlugin,
-    options: IPluginActionHandler,
-  ): void;
+  registerActionHandler(plugin: RapidPlugin, options: IPluginActionHandler): void;
   getActionHandlerByCode(code: string): ActionHandler | undefined;
-  getDataAccessor<T = any>(
-    options: GetDataAccessorOptions,
-  ): IRpdDataAccessor<T>;
+  getDataAccessor<T = any>(options: GetDataAccessorOptions): IRpdDataAccessor<T>;
   getEntityManager<TEntity = any>(singularCode: string): EntityManager<TEntity>;
   registerService(name: string, service: any);
   getService<TService>(name: string): TService;
@@ -39,30 +28,15 @@ export interface IRpdServer {
   appendApplicationConfig(config: Partial<RpdApplicationConfig>);
   appendModelProperties(modelSingularCode: string, properties: RpdDataModelProperty[]);
   getModel(options: GetModelOptions): RpdDataModel | undefined;
-  registerEventHandler<K extends keyof RpdServerEventTypes>(
-    eventName: K,
-    listener: (...args: RpdServerEventTypes[K]) => void,
-  ): this;
-  emitEvent<K extends keyof RpdServerEventTypes>(
-    eventName: K,
-    payload: RpdServerEventTypes[K][1],
-    sender?: RapidPlugin,
-  ): void;
+  registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): this;
+  emitEvent<K extends keyof RpdServerEventTypes>(eventName: K, payload: RpdServerEventTypes[K][1], sender?: RapidPlugin): void;
   handleRequest(request: Request, next: Next): Promise<Response>;
   beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
   beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;
   beforeUpdateEntity(model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any): Promise<void>;
 }
 
-
-
-export type RpdConfigurationItemTypes =
-  | "integer"
-  | "text"
-  | "boolean"
-  | "date"
-  | "datetime"
-  | "json";
+export type RpdConfigurationItemTypes = "integer" | "text" | "boolean" | "date" | "datetime" | "json";
 
 export interface RpdConfigurationItemOptions {
   /**

package/src/dataAccess/dataAccessTypes.ts

@@ -0,0 +1,86 @@
+export type RowFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
+
+export type RowFilterSetOperators = "in" | "notIn";
+
+export type RowFilterLogicalOperators = "or" | "and";
+
+export type RowFilterUnaryOperators = "null" | "notNull";
+
+export type RowFilterExistenceOperators = "exists" | "notExists";
+
+export type RowFilterOperators = RowFilterRelationalOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
+
+export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
+
+export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
+
+export type ColumnQueryOptions = string | ColumnNameWithTableName;
+
+export type ColumnNameWithTableName = {
+  name: string;
+  tableName?: string;
+}
+
+export interface FindRowOptions {
+  filters?: RowFilterOptions[];
+  orderBy?: FindRowOrderByOptions[];
+  pagination?: FindRowPaginationOptions;
+  // TODO: may be `columns` is a better name.
+  fields?: ColumnQueryOptions[];
+  keepNonPropertyFields?: boolean;
+}
+
+
+export interface FindRowRelationalFilterOptions {
+  // TODO: may be `column` is a better name.
+  field: ColumnQueryOptions;
+  operator: RowFilterRelationalOperators;
+  value: any;
+}
+
+export interface FindRowSetFilterOptions {
+  field: ColumnQueryOptions;
+  operator: RowFilterSetOperators;
+  value: any[];
+  itemType?: string;
+}
+
+export interface FindRowLogicalFilterOptions {
+  operator: RowFilterLogicalOperators;
+  filters: RowFilterOptions[];
+}
+
+export interface FindRowUnaryFilterOptions {
+  field: ColumnQueryOptions;
+  operator: RowFilterUnaryOperators;
+}
+
+export interface FindRowExistenceFilterOptions {
+  field: ColumnQueryOptions;
+  operator: RowFilterExistenceOperators;
+  filters: RowFilterOptions[];
+}
+
+export interface FindRowPaginationOptions {
+  offset: number;
+  limit: number;
+  withoutTotal?: boolean;
+}
+
+export interface FindRowOrderByOptions {
+  field: ColumnQueryOptions;
+  desc?: boolean;
+}
+
+export interface CountRowOptions {
+  filters?: RowFilterOptions[];
+}
+
+export interface UpdateRowOptions {
+  filters?: RowFilterOptions[];
+  entity: any;
+}
+
+export interface DeleteRowOptions {
+  filters?: RowFilterOptions[];
+}

package/src/dataAccess/dataAccessor.ts

@@ -1,16 +1,10 @@
-import {
-  CountEntityOptions,
-  FindEntityOptions,
-  CreateEntityOptions,
-  IRpdDataAccessor,
-  RpdDataModel,
-  UpdateEntityOptions,
-  IDatabaseAccessor,
-} from "~/types";
+import { CreateEntityOptions, IRpdDataAccessor, RpdDataModel, IDatabaseAccessor, DatabaseQuery } from "~/types";
 import QueryBuilder from "~/queryBuilder/queryBuilder";
 import { first, set } from "lodash";
 import { IRpdServer } from "~/core/server";
 import { Logger } from "~/facilities/log/LogFacility";
+import { newDatabaseError } from "~/utilities/errorUtility";
+import { CountRowOptions, FindRowOptions, UpdateRowOptions } from "./dataAccessTypes";
 
 export interface IDataAccessorOptions {
   model: RpdDataModel;
@@ -21,9 +15,11 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
   #logger: Logger;
   #model: RpdDataModel;
   #queryBuilder: QueryBuilder;
+  #server: IRpdServer;
   #databaseAccessor: IDatabaseAccessor;
 
   constructor(server: IRpdServer, databaseAccessor: IDatabaseAccessor, options: IDataAccessorOptions) {
+    this.#server = server;
     this.#logger = server.getLogger();
     this.#databaseAccessor = databaseAccessor;
     this.#queryBuilder = options.queryBuilder;
@@ -44,11 +40,13 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
   }
 
   async updateById(id: any, entity: Partial<T>): Promise<{ count: number }> {
-    const options: UpdateEntityOptions = {
+    const options: UpdateRowOptions = {
       entity,
       filters: [
         {
-          field: "id",
+          field: {
+            name: "id",
+          },
           operator: "eq",
           value: id,
         },
@@ -59,35 +57,57 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
     return first(result);
   }
 
-  async find(options: FindEntityOptions): Promise<T[]> {
+  async find(options: FindRowOptions): Promise<T[]> {
     this.#logger.debug(`Finding '${this.#model.singularCode}' entity.`, { options });
-    const query = this.#queryBuilder.select(this.#model, options);
-    return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    let query: DatabaseQuery;
+    if (this.#model.base) {
+      const baseModel = this.#server.getModel({
+        singularCode: this.#model.base,
+      });
+      query = this.#queryBuilder.selectDerived(this.#model, baseModel, options);
+    } else {
+      query = this.#queryBuilder.select(this.#model, options);
+    }
+
+    try {
+      return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    } catch (err) {
+      throw newDatabaseError(`Failed to find entities. ${err.message}`, err);
+    }
   }
 
-  async findOne(options: FindEntityOptions): Promise<T> {
+  async findOne(options: FindRowOptions): Promise<T> {
     set(options, "pagination.limit", 1);
     const list = await this.find(options);
     return first(list);
   }
 
   async findById(id: any): Promise<T | null> {
-    const options: FindEntityOptions = {
+    const options: FindRowOptions = {
       filters: [
         {
-          field: "id",
+          field: {
+            name: "id",
+          },
           operator: "eq",
           value: id,
         },
       ],
     };
-    const query = this.#queryBuilder.select(this.#model, options);
-    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
-    return first(result);
+    const result = await this.findOne(options);
+    return result;
   }
 
-  async count(options: CountEntityOptions): Promise<any> {
-    const query = this.#queryBuilder.count(this.#model, options);
+  async count(options: CountRowOptions): Promise<any> {
+    let query: DatabaseQuery;
+    if (this.#model.base) {
+      const baseModel = this.#server.getModel({
+        singularCode: this.#model.base,
+      });
+      query = this.#queryBuilder.countDerived(this.#model, baseModel, options);
+    } else {
+      query = this.#queryBuilder.count(this.#model, options);
+    }
     const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
 
     const row = first(result);
@@ -100,10 +120,12 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
   }
 
   async deleteById(id: any) {
-    const options: FindEntityOptions = {
+    const options: FindRowOptions = {
       filters: [
         {
-          field: "id",
+          field: {
+            name: "id",
+          },
           operator: "eq",
           value: id,
         },