feat: add models package

packages/models/src/Domain/Runtime/Predicate/Generators.ts

@@ -0,0 +1,140 @@
+import { CompoundPredicate } from './CompoundPredicate'
+import { IncludesPredicate } from './IncludesPredicate'
+import {
+  AllPredicateCompoundOperators,
+  PredicateCompoundOperator,
+  PredicateInterface,
+  PredicateOperator,
+  SureValue,
+  PredicateJsonForm,
+  AllPredicateOperators,
+  RawPredicateInArrayForm,
+  SureValueNonObjectTypesAsStrings,
+  StringKey,
+  PredicateTarget,
+} from './Interface'
+import { NotPredicate } from './NotPredicate'
+import { Predicate } from './Predicate'
+
+export function predicateFromArguments<T extends PredicateTarget>(
+  keypath: StringKey<T> | undefined,
+  operator: PredicateOperator,
+  value: SureValue | PredicateJsonForm,
+): PredicateInterface<T> {
+  if (AllPredicateCompoundOperators.includes(operator as PredicateCompoundOperator)) {
+    return compoundPredicateFromArguments(operator, value as unknown as PredicateJsonForm[])
+  } else if (operator === 'not') {
+    return new NotPredicate(predicateFromJson(value as PredicateJsonForm))
+  } else if (operator === 'includes' && keypath) {
+    if (isSureValue(value)) {
+      return new Predicate(keypath, operator, value)
+    } else {
+      return new IncludesPredicate(keypath, predicateFromJson(value as PredicateJsonForm))
+    }
+  } else if (keypath) {
+    return new Predicate(keypath, operator, value as SureValue)
+  }
+
+  throw Error('Invalid predicate arguments')
+}
+
+export function compoundPredicateFromArguments<T extends PredicateTarget>(
+  operator: PredicateOperator,
+  value: PredicateJsonForm[],
+): PredicateInterface<T> {
+  const subPredicates = value.map((jsonPredicate) => {
+    return predicateFromJson(jsonPredicate)
+  })
+  return new CompoundPredicate(operator as PredicateCompoundOperator, subPredicates)
+}
+
+export function notPredicateFromArguments<T extends PredicateTarget>(value: PredicateJsonForm): PredicateInterface<T> {
+  const subPredicate = predicateFromJson(value)
+  return new NotPredicate(subPredicate)
+}
+
+export function includesPredicateFromArguments<T extends PredicateTarget>(
+  keypath: StringKey<T>,
+  value: PredicateJsonForm,
+): PredicateInterface<T> {
+  const subPredicate = predicateFromJson(value)
+  return new IncludesPredicate<T>(keypath, subPredicate)
+}
+
+export function predicateFromJson<T extends PredicateTarget>(values: PredicateJsonForm): PredicateInterface<T> {
+  if (Array.isArray(values)) {
+    throw Error('Invalid predicateFromJson value')
+  }
+  return predicateFromArguments(
+    values.keypath as StringKey<T>,
+    values.operator,
+    isValuePredicateInArrayForm(values.value)
+      ? predicateDSLArrayToJsonPredicate(values.value)
+      : (values.value as PredicateJsonForm),
+  )
+}
+
+export function predicateFromDSLString<T extends PredicateTarget>(dsl: string): PredicateInterface<T> {
+  try {
+    const components = JSON.parse(dsl.substring(1, dsl.length)) as string[]
+    components.shift()
+    const predicateJson = predicateDSLArrayToJsonPredicate(components as RawPredicateInArrayForm)
+    return predicateFromJson(predicateJson)
+  } catch (e) {
+    throw Error(`Invalid smart view syntax ${e}`)
+  }
+}
+
+function isValuePredicateInArrayForm(
+  value: SureValue | PredicateJsonForm | PredicateJsonForm[] | RawPredicateInArrayForm,
+): value is RawPredicateInArrayForm {
+  return Array.isArray(value) && AllPredicateOperators.includes(value[1] as PredicateOperator)
+}
+
+function isSureValue(value: unknown): value is SureValue {
+  if (SureValueNonObjectTypesAsStrings.includes(typeof value)) {
+    return true
+  }
+
+  if (Array.isArray(value)) {
+    return !isValuePredicateInArrayForm(value)
+  }
+
+  return false
+}
+
+function predicateDSLArrayToJsonPredicate(predicateArray: RawPredicateInArrayForm): PredicateJsonForm {
+  const predicateValue = predicateArray[2] as
+    | SureValue
+    | SureValue[]
+    | RawPredicateInArrayForm
+    | RawPredicateInArrayForm[]
+
+  let resolvedPredicateValue: PredicateJsonForm | SureValue | PredicateJsonForm[]
+
+  if (Array.isArray(predicateValue)) {
+    const level1CondensedValue = predicateValue as SureValue[] | RawPredicateInArrayForm | RawPredicateInArrayForm[]
+
+    if (Array.isArray(level1CondensedValue[0])) {
+      const level2CondensedValue = level1CondensedValue as RawPredicateInArrayForm[]
+      resolvedPredicateValue = level2CondensedValue.map((subPredicate) =>
+        predicateDSLArrayToJsonPredicate(subPredicate),
+      )
+    } else if (isValuePredicateInArrayForm(predicateValue[1])) {
+      const level2CondensedValue = level1CondensedValue as RawPredicateInArrayForm
+      resolvedPredicateValue = predicateDSLArrayToJsonPredicate(level2CondensedValue)
+    } else {
+      const level2CondensedValue = predicateValue as SureValue
+      resolvedPredicateValue = level2CondensedValue
+    }
+  } else {
+    const level1CondensedValue = predicateValue as SureValue
+    resolvedPredicateValue = level1CondensedValue
+  }
+
+  return {
+    keypath: predicateArray[0],
+    operator: predicateArray[1] as PredicateOperator,
+    value: resolvedPredicateValue,
+  }
+}