@platforma-sdk/model 1.45.26 → 1.45.35

package/src/filters/converter.ts

@@ -107,6 +107,16 @@ export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionIm
     return rank(col(value.column), false).over([]).le(lit(value.n));
   }
 
+  if (
+    value.type === 'patternMatchesRegularExpression'
+    || value.type === 'patternFuzzyContainSubsequence'
+    || value.type === 'inSet'
+    || value.type === 'notInSet'
+    || value.type === 'notEqual'
+  ) {
+    throw new Error('Not implemented filter type: ' + value.type);
+  }
+
   if (value.type === undefined) {
     throw new Error('Filter type is undefined, this should not happen');
   }

package/src/filters/types.ts

@@ -14,32 +14,38 @@ export type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> =
   | CommonNode & { type: 'or'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] }
   | CommonNode & { type: 'and'; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] };
 
-export type FilterSpecLeaf =
+export type FilterSpecLeaf<T = SUniversalPColumnId> =
   | { type: undefined }
-  | { type: 'isNA'; column: SUniversalPColumnId }
-  | { type: 'isNotNA'; column: SUniversalPColumnId }
-
-  | { type: 'patternEquals'; column: SUniversalPColumnId; value: string }
-  | { type: 'patternNotEquals'; column: SUniversalPColumnId; value: string }
-  | { type: 'patternContainSubsequence'; column: SUniversalPColumnId; value: string }
-  | { type: 'patternNotContainSubsequence'; column: SUniversalPColumnId; value: string }
-
-  | { type: 'topN'; column: SUniversalPColumnId; n: number }
-  | { type: 'bottomN'; column: SUniversalPColumnId; n: number }
-
-  | { type: 'equal'; column: SUniversalPColumnId; x: number }
-  | { type: 'lessThan'; column: SUniversalPColumnId; x: number }
-  | { type: 'greaterThan'; column: SUniversalPColumnId; x: number }
-  | { type: 'lessThanOrEqual'; column: SUniversalPColumnId; x: number }
-  | { type: 'greaterThanOrEqual'; column: SUniversalPColumnId; x: number }
-
-  | { type: 'equalToColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId }
-  | { type: 'lessThanColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
-  | { type: 'greaterThanColumn'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
-  | { type: 'lessThanColumnOrEqual'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number }
-  | { type: 'greaterThanColumnOrEqual'; column: SUniversalPColumnId; rhs: SUniversalPColumnId; minDiff?: number };
-
-export type FilterSpec<Leaf extends FilterSpecLeaf = FilterSpecLeaf, CommonNode = {}, CommonLeaf = CommonNode> =
+  | { type: 'isNA'; column: T }
+  | { type: 'isNotNA'; column: T }
+
+  | { type: 'patternEquals'; column: T; value: string }
+  | { type: 'patternNotEquals'; column: T; value: string }
+  | { type: 'patternContainSubsequence'; column: T; value: string }
+  | { type: 'patternNotContainSubsequence'; column: T; value: string }
+  | { type: 'patternMatchesRegularExpression'; column: T; value: string }
+  | { type: 'patternFuzzyContainSubsequence'; column: T; value: string; maxEdits?: number; substitutionsOnly?: boolean; wildcard?: string }
+
+  | { type: 'inSet'; column: T; value: string[] }
+  | { type: 'notInSet'; column: T; value: string[] }
+
+  | { type: 'topN'; column: T; n: number }
+  | { type: 'bottomN'; column: T; n: number }
+
+  | { type: 'equal'; column: T; x: number }
+  | { type: 'notEqual'; column: T; x: number }
+  | { type: 'lessThan'; column: T; x: number }
+  | { type: 'greaterThan'; column: T; x: number }
+  | { type: 'lessThanOrEqual'; column: T; x: number }
+  | { type: 'greaterThanOrEqual'; column: T; x: number }
+
+  | { type: 'equalToColumn'; column: T; rhs: T }
+  | { type: 'lessThanColumn'; column: T; rhs: T; minDiff?: number }
+  | { type: 'greaterThanColumn'; column: T; rhs: T; minDiff?: number }
+  | { type: 'lessThanColumnOrEqual'; column: T; rhs: T; minDiff?: number }
+  | { type: 'greaterThanColumnOrEqual'; column: T; rhs: T; minDiff?: number };
+
+export type FilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> =
   FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
 
 export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>['type'];