@ruiapp/rapid-core 0.3.0 → 0.3.2

package/src/helpers/entityHelpers.ts

@@ -1,76 +1,76 @@
-import { isNumber, isObject } from "lodash";
-import { IRpdServer } from "~/core/server";
-import { getEntityPropertyByCode, isOneRelationProperty } from "~/helpers/metaHelper";
-import { RpdDataModel } from "~/types";
-
-export function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
-  if (!before) {
-    throw new Error("Argument 'before' can not be null.");
-  }
-
-  if (!after) {
-    throw new Error("Argument 'after' can not be null.");
-  }
-
-  let changed = false;
-  let changes = {};
-  for (const key in after) {
-    const property = getEntityPropertyByCode(server, model, key);
-    if (property && isOneRelationProperty(property)) {
-      const afterValue: number | { id: number } | null = after[key];
-      const beforeValue: number | { id: number } | null = before[key] || before[property.targetIdColumnName];
-      if (afterValue) {
-        if (isNumber(afterValue)) {
-          if (beforeValue) {
-            if (isNumber(beforeValue)) {
-              if (afterValue != beforeValue) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            } else {
-              if (afterValue != beforeValue.id) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            }
-          } else {
-            changed = true;
-            changes[key] = afterValue;
-          }
-        } else {
-          if (beforeValue) {
-            if (isNumber(beforeValue)) {
-              if (afterValue.id != beforeValue) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            } else {
-              if (afterValue.id != beforeValue.id) {
-                changed = true;
-                changes[key] = afterValue;
-              }
-            }
-          } else {
-            changed = true;
-            changes[key] = afterValue;
-          }
-        }
-      } else {
-        if (beforeValue) {
-          changed = true;
-          changes[key] = null;
-        }
-      }
-    } else {
-      if (after[key] != before[key]) {
-        changed = true;
-        changes[key] = after[key];
-      }
-    }
-  }
-
-  if (changed) {
-    return changes;
-  }
-  return null;
-}
+import { isNumber, isObject } from "lodash";
+import { IRpdServer } from "~/core/server";
+import { getEntityPropertyByCode, isOneRelationProperty } from "~/helpers/metaHelper";
+import { RpdDataModel } from "~/types";
+
+export function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
+  if (!before) {
+    throw new Error("Argument 'before' can not be null.");
+  }
+
+  if (!after) {
+    throw new Error("Argument 'after' can not be null.");
+  }
+
+  let changed = false;
+  let changes = {};
+  for (const key in after) {
+    const property = getEntityPropertyByCode(server, model, key);
+    if (property && isOneRelationProperty(property)) {
+      const afterValue: number | { id: number } | null = after[key];
+      const beforeValue: number | { id: number } | null = before[key] || before[property.targetIdColumnName];
+      if (afterValue) {
+        if (isNumber(afterValue)) {
+          if (beforeValue) {
+            if (isNumber(beforeValue)) {
+              if (afterValue != beforeValue) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            } else {
+              if (afterValue != beforeValue.id) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            }
+          } else {
+            changed = true;
+            changes[key] = afterValue;
+          }
+        } else {
+          if (beforeValue) {
+            if (isNumber(beforeValue)) {
+              if (afterValue.id != beforeValue) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            } else {
+              if (afterValue.id != beforeValue.id) {
+                changed = true;
+                changes[key] = afterValue;
+              }
+            }
+          } else {
+            changed = true;
+            changes[key] = afterValue;
+          }
+        }
+      } else {
+        if (beforeValue) {
+          changed = true;
+          changes[key] = null;
+        }
+      }
+    } else {
+      if (after[key] != before[key]) {
+        changed = true;
+        changes[key] = after[key];
+      }
+    }
+  }
+
+  if (changed) {
+    return changes;
+  }
+  return null;
+}

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/metaHelper.ts

@@ -1,89 +1,89 @@
-import { cloneDeep } 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) {
-  return model.properties;
-}
-
-export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel) {
-  if (!model.base) {
-    return model.properties;
-  }
-
-  const baseModel = server.getModel({
-    singularCode: model.base,
-  });
-  let baseProperties: RpdDataModelProperty[] = [];
-  if (baseModel) {
-    baseProperties = baseModel.properties.map((property) => {
-      property = cloneDeep(property);
-      property.isBaseProperty = true;
-      return property;
-    });
-  }
-
-  return [...baseProperties, ...model.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 } 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) {
+  return model.properties;
+}
+
+export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel) {
+  if (!model.base) {
+    return model.properties;
+  }
+
+  const baseModel = server.getModel({
+    singularCode: model.base,
+  });
+  let baseProperties: RpdDataModelProperty[] = [];
+  if (baseModel) {
+    baseProperties = baseModel.properties.map((property) => {
+      property = cloneDeep(property);
+      property.isBaseProperty = true;
+      return property;
+    });
+  }
+
+  return [...baseProperties, ...model.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;
+}