@ruiapp/rapid-core 0.5.11 → 0.5.13

package/src/helpers/filterHelper.ts

@@ -1,148 +1,148 @@
-import {
-  EntityFilterOptions,
-  EntityNonRelationPropertyFilterOptions,
-  FindEntityExistenceFilterOptions,
-  FindEntityLogicalFilterOptions,
-  RpdDataModel,
-  RpdDataModelIndexOptions,
-  RpdDataModelProperty,
-} from "~/types";
-import { isNullOrUndefined } from "~/utilities/typeUtility";
-import { getEntityOwnProperty, getEntityOwnPropertyByCode, isManyRelationProperty, isOneRelationProperty } from "./metaHelper";
-import { IRpdServer } from "~/core/server";
-import { isPlainObject } from "lodash";
-import { RowFilterOptions } from "~/dataAccess/dataAccessTypes";
-import { Logger } from "~/facilities/log/LogFacility";
-
-export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
-  const result: EntityFilterOptions[] = [];
-  if (!filters) {
-    return result;
-  }
-
-  for (const filter of filters) {
-    const { operator } = filter;
-
-    switch (operator) {
-      case "null":
-      case "notNull":
-        result.push(filter);
-        break;
-      case "exists":
-      case "notExists":
-      case "and":
-      case "or":
-        const transformedFilter = transformFilterWithSubFilters(filter);
-        if (transformedFilter !== null) {
-          result.push(transformedFilter);
-        }
-        break;
-      default:
-        if (!isNullOrUndefined(filter.value)) {
-          result.push(filter);
-        }
-    }
-  }
-
-  return result;
-}
-
-function transformFilterWithSubFilters(
-  filter: FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions,
-): FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions | null {
-  const subFilters = removeFiltersWithNullValue(filter.filters);
-  if (!subFilters.length) {
-    return null;
-  }
-
-  filter.filters = subFilters;
-  return filter;
-}
-
-export function convertModelIndexConditionsToRowFilterOptions(logger: Logger, model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
-  if (!filters || !filters.length) {
-    return [];
-  }
-
-  const replacedFilters: RowFilterOptions[] = [];
-  for (const filter of filters) {
-    const { operator } = filter;
-    if (operator === "and" || operator === "or") {
-      replacedFilters.push({
-        operator: operator,
-        filters: convertModelIndexConditionsToRowFilterOptions(logger, model, filter.filters),
-      });
-    } else {
-      const replacedFilter = replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model, filter);
-      if (replacedFilter) {
-        replacedFilters.push(replacedFilter);
-      }
-    }
-  }
-  return replacedFilters;
-}
-
-export function replaceModelIndexConditionEntityPropertyWithTableColumn(
-  logger: Logger,
-  model: RpdDataModel,
-  filter: RpdDataModelIndexOptions,
-): RowFilterOptions {
-  const { operator } = filter;
-  const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
-  let property: RpdDataModelProperty = getEntityOwnPropertyByCode(model, filterField);
-
-  let filterValue = (filter as any).value;
-
-  let columnName = "";
-  if (property) {
-    if (isOneRelationProperty(property)) {
-      columnName = property.targetIdColumnName;
-      if (isPlainObject(filterValue)) {
-        filterValue = filterValue.id;
-      }
-    } else if (isManyRelationProperty(property)) {
-      logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
-      return null;
-    } else {
-      columnName = property.columnName || property.code;
-    }
-  } else if ((operator as any) === "exists" || (operator as any) === "notExists") {
-    logger.warn(`"exists" and "notExists" operators are not supported in index conditions.`);
-    return null;
-  } else {
-    property = getEntityOwnProperty(model, (property) => {
-      return property.columnName === filterField;
-    });
-
-    if (property) {
-      columnName = property.columnName;
-    } else {
-      // may be relation property.
-      property = getEntityOwnProperty(model, (property) => {
-        return property.targetIdColumnName === filterField;
-      });
-
-      if (property) {
-        if (isManyRelationProperty(property)) {
-          logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
-          return null;
-        }
-        columnName = property.targetIdColumnName;
-        if (isPlainObject(filterValue)) {
-          filterValue = filterValue.id;
-        }
-      } else {
-        logger.warn(`Unknown field "${filterField}" in index conditions.`);
-        return null;
-      }
-    }
-  }
-
-  // TODO: do not use `any` here
-  return {
-    operator: filter.operator,
-    field: columnName,
-    value: filterValue,
-    itemType: (filter as any).itemType,
-  } as RowFilterOptions;
-}
+import {
+  EntityFilterOptions,
+  EntityNonRelationPropertyFilterOptions,
+  FindEntityExistenceFilterOptions,
+  FindEntityLogicalFilterOptions,
+  RpdDataModel,
+  RpdDataModelIndexOptions,
+  RpdDataModelProperty,
+} from "~/types";
+import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { getEntityOwnProperty, getEntityOwnPropertyByCode, isManyRelationProperty, isOneRelationProperty } from "./metaHelper";
+import { IRpdServer } from "~/core/server";
+import { isPlainObject } from "lodash";
+import { RowFilterOptions } from "~/dataAccess/dataAccessTypes";
+import { Logger } from "~/facilities/log/LogFacility";
+
+export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
+  const result: EntityFilterOptions[] = [];
+  if (!filters) {
+    return result;
+  }
+
+  for (const filter of filters) {
+    const { operator } = filter;
+
+    switch (operator) {
+      case "null":
+      case "notNull":
+        result.push(filter);
+        break;
+      case "exists":
+      case "notExists":
+      case "and":
+      case "or":
+        const transformedFilter = transformFilterWithSubFilters(filter);
+        if (transformedFilter !== null) {
+          result.push(transformedFilter);
+        }
+        break;
+      default:
+        if (!isNullOrUndefined(filter.value)) {
+          result.push(filter);
+        }
+    }
+  }
+
+  return result;
+}
+
+function transformFilterWithSubFilters(
+  filter: FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions,
+): FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions | null {
+  const subFilters = removeFiltersWithNullValue(filter.filters);
+  if (!subFilters.length) {
+    return null;
+  }
+
+  filter.filters = subFilters;
+  return filter;
+}
+
+export function convertModelIndexConditionsToRowFilterOptions(logger: Logger, model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
+  if (!filters || !filters.length) {
+    return [];
+  }
+
+  const replacedFilters: RowFilterOptions[] = [];
+  for (const filter of filters) {
+    const { operator } = filter;
+    if (operator === "and" || operator === "or") {
+      replacedFilters.push({
+        operator: operator,
+        filters: convertModelIndexConditionsToRowFilterOptions(logger, model, filter.filters),
+      });
+    } else {
+      const replacedFilter = replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model, filter);
+      if (replacedFilter) {
+        replacedFilters.push(replacedFilter);
+      }
+    }
+  }
+  return replacedFilters;
+}
+
+export function replaceModelIndexConditionEntityPropertyWithTableColumn(
+  logger: Logger,
+  model: RpdDataModel,
+  filter: RpdDataModelIndexOptions,
+): RowFilterOptions {
+  const { operator } = filter;
+  const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
+  let property: RpdDataModelProperty = getEntityOwnPropertyByCode(model, filterField);
+
+  let filterValue = (filter as any).value;
+
+  let columnName = "";
+  if (property) {
+    if (isOneRelationProperty(property)) {
+      columnName = property.targetIdColumnName;
+      if (isPlainObject(filterValue)) {
+        filterValue = filterValue.id;
+      }
+    } else if (isManyRelationProperty(property)) {
+      logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+      return null;
+    } else {
+      columnName = property.columnName || property.code;
+    }
+  } else if ((operator as any) === "exists" || (operator as any) === "notExists") {
+    logger.warn(`"exists" and "notExists" operators are not supported in index conditions.`);
+    return null;
+  } else {
+    property = getEntityOwnProperty(model, (property) => {
+      return property.columnName === filterField;
+    });
+
+    if (property) {
+      columnName = property.columnName;
+    } else {
+      // may be relation property.
+      property = getEntityOwnProperty(model, (property) => {
+        return property.targetIdColumnName === filterField;
+      });
+
+      if (property) {
+        if (isManyRelationProperty(property)) {
+          logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+          return null;
+        }
+        columnName = property.targetIdColumnName;
+        if (isPlainObject(filterValue)) {
+          filterValue = filterValue.id;
+        }
+      } else {
+        logger.warn(`Unknown field "${filterField}" in index conditions.`);
+        return null;
+      }
+    }
+  }
+
+  // TODO: do not use `any` here
+  return {
+    operator: filter.operator,
+    field: columnName,
+    value: filterValue,
+    itemType: (filter as any).itemType,
+  } as RowFilterOptions;
+}

package/src/helpers/inputHelper.ts

@@ -1,11 +1,11 @@
-import { isArray, mergeWith } from "lodash";
-
-export function mergeInput(defaultInput: any, input: any, fixedInput: any) {
-  return mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
-}
-
-function doNotMergeArray(objValue: any, srcValue: any) {
-  if (isArray(srcValue)) {
-    return srcValue;
-  }
-}
+import { isArray, mergeWith } from "lodash";
+
+export function mergeInput(defaultInput: any, input: any, fixedInput: any) {
+  return mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
+}
+
+function doNotMergeArray(objValue: any, srcValue: any) {
+  if (isArray(srcValue)) {
+    return srcValue;
+  }
+}

package/src/helpers/metaHelper.ts

@@ -1,104 +1,104 @@
-import { cloneDeep, filter, find } from "lodash";
-import { IRpdServer } from "~/core/server";
-import { RpdDataModel, RpdDataModelProperty } from "~/types";
-
-export function isRelationProperty(property: RpdDataModelProperty) {
-  return property.type === "relation" || property.type === "relation[]";
-}
-
-export function isOneRelationProperty(property: RpdDataModelProperty) {
-  return isRelationProperty(property) && property.relation === "one";
-}
-
-export function isManyRelationProperty(property: RpdDataModelProperty) {
-  return isRelationProperty(property) && property.relation === "many";
-}
-
-export function getEntityProperties(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean) {
-  if (!predicate) {
-    return model.properties;
-  }
-
-  return filter(model.properties, predicate);
-}
-
-export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean) {
-  if (!model.base) {
-    return getEntityProperties(server, model, predicate);
-  }
-
-  const baseModel = server.getModel({
-    singularCode: model.base,
-  });
-  let baseProperties: RpdDataModelProperty[] = [];
-  if (baseModel) {
-    if (predicate) {
-      baseProperties = filter(baseModel.properties, predicate);
-    } else {
-      baseProperties = baseModel.properties;
-    }
-    baseProperties = baseProperties.map((property) => {
-      property = cloneDeep(property);
-      property.isBaseProperty = true;
-      return property;
-    });
-  }
-
-  let properties: RpdDataModelProperty[];
-  if (predicate) {
-    properties = filter(model.properties, predicate);
-  } else {
-    properties = model.properties;
-  }
-  return [...baseProperties, ...properties];
-}
-
-export function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
-  return getEntityProperty(server, model, (e) => e.code === propertyCode);
-}
-
-export function getEntityProperty(
-  server: IRpdServer,
-  model: RpdDataModel,
-  predicate: (item: RpdDataModelProperty) => boolean,
-): RpdDataModelProperty | undefined {
-  let property = model.properties.find(predicate);
-  if (!property) {
-    const baseModelSingularCode = model.base;
-    if (baseModelSingularCode) {
-      const baseModel = server.getModel({
-        singularCode: baseModelSingularCode,
-      });
-
-      property = baseModel.properties.find(predicate);
-      if (property) {
-        property = cloneDeep(property);
-        property.isBaseProperty = true;
-      }
-    }
-  }
-
-  return property;
-}
-
-export function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
-  return getEntityOwnProperty(model, (e) => e.code === propertyCode);
-}
-
-export function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined {
-  let property = model.properties.find(predicate);
-  return property;
-}
-
-export function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined {
-  let property = getEntityPropertyByCode(server, model, fieldName);
-  if (!property) {
-    property = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === fieldName);
-  }
-
-  if (!property) {
-    property = getEntityProperty(server, model, (item) => item.columnName === fieldName);
-  }
-
-  return property;
-}
+import { cloneDeep, filter, find } from "lodash";
+import { IRpdServer } from "~/core/server";
+import { RpdDataModel, RpdDataModelProperty } from "~/types";
+
+export function isRelationProperty(property: RpdDataModelProperty) {
+  return property.type === "relation" || property.type === "relation[]";
+}
+
+export function isOneRelationProperty(property: RpdDataModelProperty) {
+  return isRelationProperty(property) && property.relation === "one";
+}
+
+export function isManyRelationProperty(property: RpdDataModelProperty) {
+  return isRelationProperty(property) && property.relation === "many";
+}
+
+export function getEntityProperties(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean) {
+  if (!predicate) {
+    return model.properties;
+  }
+
+  return filter(model.properties, predicate);
+}
+
+export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean) {
+  if (!model.base) {
+    return getEntityProperties(server, model, predicate);
+  }
+
+  const baseModel = server.getModel({
+    singularCode: model.base,
+  });
+  let baseProperties: RpdDataModelProperty[] = [];
+  if (baseModel) {
+    if (predicate) {
+      baseProperties = filter(baseModel.properties, predicate);
+    } else {
+      baseProperties = baseModel.properties;
+    }
+    baseProperties = baseProperties.map((property) => {
+      property = cloneDeep(property);
+      property.isBaseProperty = true;
+      return property;
+    });
+  }
+
+  let properties: RpdDataModelProperty[];
+  if (predicate) {
+    properties = filter(model.properties, predicate);
+  } else {
+    properties = model.properties;
+  }
+  return [...baseProperties, ...properties];
+}
+
+export function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
+  return getEntityProperty(server, model, (e) => e.code === propertyCode);
+}
+
+export function getEntityProperty(
+  server: IRpdServer,
+  model: RpdDataModel,
+  predicate: (item: RpdDataModelProperty) => boolean,
+): RpdDataModelProperty | undefined {
+  let property = model.properties.find(predicate);
+  if (!property) {
+    const baseModelSingularCode = model.base;
+    if (baseModelSingularCode) {
+      const baseModel = server.getModel({
+        singularCode: baseModelSingularCode,
+      });
+
+      property = baseModel.properties.find(predicate);
+      if (property) {
+        property = cloneDeep(property);
+        property.isBaseProperty = true;
+      }
+    }
+  }
+
+  return property;
+}
+
+export function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
+  return getEntityOwnProperty(model, (e) => e.code === propertyCode);
+}
+
+export function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined {
+  let property = model.properties.find(predicate);
+  return property;
+}
+
+export function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined {
+  let property = getEntityPropertyByCode(server, model, fieldName);
+  if (!property) {
+    property = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === fieldName);
+  }
+
+  if (!property) {
+    property = getEntityProperty(server, model, (item) => item.columnName === fieldName);
+  }
+
+  return property;
+}

package/src/helpers/runCollectionEntityActionHandler.ts

@@ -1,57 +1,57 @@
-import { IDatabaseClient, RunEntityActionHandlerOptions } from "~/types";
-import { mergeInput } from "./inputHelper";
-import { ActionHandlerContext } from "~/core/actionHandler";
-import EntityManager from "~/dataAccess/entityManager";
-
-type EntityActionHandler = (entityManager: EntityManager, input: any) => Promise<any>;
-
-export default async function runCollectionEntityActionHandler(
-  ctx: ActionHandlerContext,
-  options: RunEntityActionHandlerOptions,
-  code: string,
-  autoMergeInput: boolean,
-  runInTransaction: boolean,
-  handleEntityAction: EntityActionHandler,
-) {
-  const { logger, server, input, routerContext: routeContext } = ctx;
-
-  const { defaultInput, fixedInput } = options;
-  let mergedInput: any;
-  if (autoMergeInput) {
-    mergedInput = mergeInput(defaultInput, input, fixedInput);
-  }
-  logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
-
-  const entityManager = server.getEntityManager(options.singularCode);
-
-  if (runInTransaction) {
-    let transactionDbClient: IDatabaseClient;
-
-    try {
-      transactionDbClient = await routeContext.beginDbTransaction();
-
-      const result = handleEntityAction(entityManager, autoMergeInput ? mergedInput : input);
-      if (result instanceof Promise) {
-        ctx.output = await result;
-      } else {
-        ctx.output = result;
-      }
-
-      await routeContext.commitDbTransaction();
-    } catch (ex) {
-      await routeContext.rollbackDbTransaction();
-      throw ex;
-    } finally {
-      if (transactionDbClient) {
-        transactionDbClient.release();
-      }
-    }
-  } else {
-    const result = handleEntityAction(entityManager, mergedInput);
-    if (result instanceof Promise) {
-      ctx.output = await result;
-    } else {
-      ctx.output = result;
-    }
-  }
-}
+import { IDatabaseClient, RunEntityActionHandlerOptions } from "~/types";
+import { mergeInput } from "./inputHelper";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import EntityManager from "~/dataAccess/entityManager";
+
+type EntityActionHandler = (entityManager: EntityManager, input: any) => Promise<any>;
+
+export default async function runCollectionEntityActionHandler(
+  ctx: ActionHandlerContext,
+  options: RunEntityActionHandlerOptions,
+  code: string,
+  autoMergeInput: boolean,
+  runInTransaction: boolean,
+  handleEntityAction: EntityActionHandler,
+) {
+  const { logger, server, input, routerContext: routeContext } = ctx;
+
+  const { defaultInput, fixedInput } = options;
+  let mergedInput: any;
+  if (autoMergeInput) {
+    mergedInput = mergeInput(defaultInput, input, fixedInput);
+  }
+  logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
+
+  const entityManager = server.getEntityManager(options.singularCode);
+
+  if (runInTransaction) {
+    let transactionDbClient: IDatabaseClient;
+
+    try {
+      transactionDbClient = await routeContext.beginDbTransaction();
+
+      const result = handleEntityAction(entityManager, autoMergeInput ? mergedInput : input);
+      if (result instanceof Promise) {
+        ctx.output = await result;
+      } else {
+        ctx.output = result;
+      }
+
+      await routeContext.commitDbTransaction();
+    } catch (ex) {
+      await routeContext.rollbackDbTransaction();
+      throw ex;
+    } finally {
+      if (transactionDbClient) {
+        transactionDbClient.release();
+      }
+    }
+  } else {
+    const result = handleEntityAction(entityManager, mergedInput);
+    if (result instanceof Promise) {
+      ctx.output = await result;
+    } else {
+      ctx.output = result;
+    }
+  }
+}