@milaboratories/pl-model-common 1.24.2 → 1.24.4

package/src/drivers/pframe/linker_columns.ts

@@ -1,8 +1,4 @@
-import {
-  canonicalizeJson,
-  parseJson,
-  type CanonicalizedJson,
-} from '../../json';
+import { canonicalizeJson, parseJson, type CanonicalizedJson } from "../../json";
 import {
   Annotation,
   readAnnotationJson,
@@ -14,7 +10,7 @@ import {
   getNormalizedAxesList,
   getArrayFromAxisTree,
   getAxesTree,
-} from './spec/spec';
+} from "./spec/spec";
 
 type LinkerKey = CanonicalizedJson<AxisId[]>;
 export type CompositeLinkerMap = Map<
@@ -46,7 +42,9 @@ export class LinkerMap implements LinkersData {
 
   static fromColumns(columns: PColumnIdAndSpec[]) {
     const result: CompositeLinkerMap = new Map();
-    for (const linker of columns.filter((l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn))) {
+    for (const linker of columns.filter(
+      (l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn),
+    )) {
       const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec)); // split input axes into groups by parent links from annotation
 
       if (groups.length !== 2) {
@@ -63,12 +61,16 @@ export class LinkerMap implements LinkersData {
       //  \_ B _ D
       // and
       // E - B - D
-      const leftKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(left).map((axis) => {
-        const axes = getArrayFromAxisTree(getAxesTree(axis));
-        const key = canonicalizeJson(axes.map(getAxisId));
-        return [key, axes];
-      });
-      const rightKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(right).map((axis) => {
+      const leftKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(left).map(
+        (axis) => {
+          const axes = getArrayFromAxisTree(getAxesTree(axis));
+          const key = canonicalizeJson(axes.map(getAxisId));
+          return [key, axes];
+        },
+      );
+      const rightKeyVariants: [LinkerKey, AxisSpecNormalized[]][] = LinkerMap.getAxesRoots(
+        right,
+      ).map((axis) => {
         const axes = getArrayFromAxisTree(getAxesTree(axis));
         const key = canonicalizeJson(axes.map(getAxisId));
         return [key, axes];
@@ -157,7 +159,7 @@ export class LinkerMap implements LinkersData {
     to: AxisSpecNormalized[];
     throwWhenNoLinkExists?: boolean;
   }): PColumnIdAndSpec[] {
-  // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)
+    // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)
     const startKeys: LinkerKey[] = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
 
     return Array.from(
@@ -167,8 +169,13 @@ export class LinkerMap implements LinkersData {
           .flatMap((targetKey) => {
             const linkers = startKeys
               .map((startKey) => this.searchLinkerPath(startKey, targetKey))
-              .reduce((shortestPath, path) => (shortestPath.length && shortestPath.length < path.length) || !path.length ? shortestPath : path,
-                [] as PColumnIdAndSpec[])
+              .reduce(
+                (shortestPath, path) =>
+                  (shortestPath.length && shortestPath.length < path.length) || !path.length
+                    ? shortestPath
+                    : path,
+                [] as PColumnIdAndSpec[],
+              )
               .map((linker) => [linker.columnId, linker] as const);
             if (!linkers.length && throwWhenNoLinkExists) {
               throw Error(`Unable to find linker column for ${targetKey}`);
@@ -183,7 +190,8 @@ export class LinkerMap implements LinkersData {
   getAxesListFromKeysList(keys: LinkerKey[]): AxisSpecNormalized[] {
     return Array.from(
       new Map(
-        keys.flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
+        keys
+          .flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
           .map((axis) => [canonicalizeJson(getAxisId(axis)), axis]),
       ).values(),
     );
@@ -205,7 +213,12 @@ export class LinkerMap implements LinkersData {
             const targetKey = targetKeys[idx];
             return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);
           })
-          .flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [canonicalizeJson(getAxisId(axis)), axis])),
+          .flatMap((axis) =>
+            getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [
+              canonicalizeJson(getAxisId(axis)),
+              axis,
+            ]),
+          ),
       ).values(),
     );
     return axes;
@@ -219,11 +232,13 @@ export class LinkerMap implements LinkersData {
     let startKeys: CanonicalizedJson<AxisId[]>[] = [];
 
     if (matchAxisIdFn) {
-      const sourceAxisIdsGrouped: AxisId[][] = sourceAxes.map((axis) => getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+      const sourceAxisIdsGrouped: AxisId[][] = sourceAxes.map((axis) =>
+        getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId),
+      );
       for (const sourceAxisIdsGroup of sourceAxisIdsGrouped) {
-        const matched = this.keyAxesIds.find(
-          (keyIds: AxisId[]) => keyIds.every(
-            (linkerKeyAxisId) => sourceAxisIdsGroup.find((sourceAxisId) => matchAxisIdFn(linkerKeyAxisId, sourceAxisId)),
+        const matched = this.keyAxesIds.find((keyIds: AxisId[]) =>
+          keyIds.every((linkerKeyAxisId) =>
+            sourceAxisIdsGroup.find((sourceAxisId) => matchAxisIdFn(linkerKeyAxisId, sourceAxisId)),
           ),
         );
         if (matched) {
@@ -242,7 +257,10 @@ export class LinkerMap implements LinkersData {
     sourceAxes: AxisSpec[],
     matchAxisIdFn?: (axisIdOfLinker: AxisId, axisIdOfSource: AxisId) => boolean,
   ): AxisSpecNormalized[] {
-    return this.getReachableByLinkersAxesFromAxesNormalized(getNormalizedAxesList(sourceAxes), matchAxisIdFn);
+    return this.getReachableByLinkersAxesFromAxesNormalized(
+      getNormalizedAxesList(sourceAxes),
+      matchAxisIdFn,
+    );
   }
 
   static getLinkerKeyFromAxisSpec(axis: AxisSpecNormalized): LinkerKey {
@@ -253,24 +271,30 @@ export class LinkerMap implements LinkersData {
      There are no order inside every group. */
   static getAxesGroups(axesSpec: AxisSpecNormalized[]): AxisSpecNormalized[][] {
     switch (axesSpec.length) {
-      case 0: return [];
-      case 1: return [[axesSpec[0]]];
-      default: break;
+      case 0:
+        return [];
+      case 1:
+        return [[axesSpec[0]]];
+      default:
+        break;
     }
 
     const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
     const axisParentsIdxs = axesSpec.map(
-      (spec) => new Set(
-        spec.parentAxesSpec
-          .map((spec) => canonicalizeJson(getAxisId(spec)))
-          .map((el) => {
-            const idx = axisKeys.indexOf(el);
-            if (idx === -1) {
-              throw new Error(`malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`);
-            }
-            return idx;
-          }),
-      ),
+      (spec) =>
+        new Set(
+          spec.parentAxesSpec
+            .map((spec) => canonicalizeJson(getAxisId(spec)))
+            .map((el) => {
+              const idx = axisKeys.indexOf(el);
+              if (idx === -1) {
+                throw new Error(
+                  `malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`,
+                );
+              }
+              return idx;
+            }),
+        ),
     );
 
     const allIdxs = [...axesSpec.keys()];
@@ -304,14 +328,16 @@ export class LinkerMap implements LinkersData {
 
       groups.push([...currentGroup]);
       nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
-    };
+    }
 
     return groups.map((group) => group.map((idx) => axesSpec[idx]));
   }
 
   /** Get all axes that are not parents of any other axis */
   static getAxesRoots(axes: AxisSpecNormalized[]): AxisSpecNormalized[] {
-    const parentsSet = new Set(axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))));
+    const parentsSet = new Set(
+      axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))),
+    );
     return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));
   }
 }

package/src/drivers/pframe/pframe.ts

@@ -1,12 +1,9 @@
-import type { PObjectId } from '../../pool';
-import type { TableRange } from './data_types';
-import type { FindColumnsRequest, FindColumnsResponse } from './find_columns';
-import type { PColumnIdAndSpec, PColumnSpec } from './spec/spec';
-import type {
-  CalculateTableDataRequest,
-  CalculateTableDataResponse,
-} from './table_calculate';
-import type { UniqueValuesRequest, UniqueValuesResponse } from './unique_values';
+import type { PObjectId } from "../../pool";
+import type { TableRange } from "./data_types";
+import type { FindColumnsRequest, FindColumnsResponse } from "./find_columns";
+import type { PColumnIdAndSpec, PColumnSpec } from "./spec/spec";
+import type { CalculateTableDataRequest, CalculateTableDataResponse } from "./table_calculate";
+import type { UniqueValuesRequest, UniqueValuesResponse } from "./unique_values";
 
 /** Read interface exposed by PFrames library */
 export interface PFrame {

package/src/drivers/pframe/query/index.ts

@@ -1,2 +1,2 @@
-export * from './query_spec';
-export * from './query_data';
+export * from "./query_spec";
+export * from "./query_data";

package/src/drivers/pframe/query/query_common.ts

@@ -1,6 +1,6 @@
-import type { PObjectId } from '../../../pool';
-import type { JsonDataInfo } from '../data_info';
-import type { AxisValueType, ColumnValueType } from '../spec';
+import type { PObjectId } from "../../../pool";
+import type { JsonDataInfo } from "../data_info";
+import type { AxisValueType, ColumnValueType } from "../spec";
 
 // ============ Type Spec Types ============
 
@@ -37,7 +37,17 @@ export type TypeSpec = {
  * - `exp` - Exponential function (e^x)
  * - `negate` - Negation (-x)
  */
-export type NumericUnaryOperand = 'abs' | 'ceil' | 'floor' | 'round' | 'sqrt' | 'log' | 'log2' | 'log10' | 'exp' | 'negate';
+export type NumericUnaryOperand =
+  | "abs"
+  | "ceil"
+  | "floor"
+  | "round"
+  | "sqrt"
+  | "log"
+  | "log2"
+  | "log10"
+  | "exp"
+  | "negate";
 
 /**
  * Binary mathematical operation kinds.
@@ -52,7 +62,7 @@ export type NumericUnaryOperand = 'abs' | 'ceil' | 'floor' | 'round' | 'sqrt' |
  * - `div` - Division: left / right (division by zero returns Infinity or NaN)
  * - `mod` - Modulo: left % right
  */
-export type NumericBinaryOperand = 'add' | 'sub' | 'mul' | 'div' | 'mod';
+export type NumericBinaryOperand = "add" | "sub" | "mul" | "div" | "mod";
 
 /**
  * Numeric comparison operation kinds.
@@ -68,7 +78,7 @@ export type NumericBinaryOperand = 'add' | 'sub' | 'mul' | 'div' | 'mod';
  * - `gt` - Greater than: left > right
  * - `ge` - Greater or equal: left >= right
  */
-export type NumericComparisonOperand = 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge';
+export type NumericComparisonOperand = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
 
 // ============ Geometric Types ============
 
@@ -103,7 +113,7 @@ export type Point2D = {
  * { type: 'constant', value: true }
  */
 export type ExprConstant = {
-  type: 'constant';
+  type: "constant";
   value: string | number | boolean;
 };
 
@@ -130,7 +140,7 @@ export type ExprConstant = {
  * @see NumericUnaryOperand for available operations
  */
 export interface ExprNumericUnary<I> {
-  type: 'numericUnary';
+  type: "numericUnary";
   /** The mathematical operation to apply */
   operand: NumericUnaryOperand;
   /** Input expression (must evaluate to numeric) */
@@ -157,7 +167,7 @@ export interface ExprNumericUnary<I> {
  * @see NumericBinaryOperand for available operations
  */
 export interface ExprNumericBinary<I> {
-  type: 'numericBinary';
+  type: "numericBinary";
   /** The arithmetic operation to apply */
   operand: NumericBinaryOperand;
   /** Left operand expression */
@@ -192,7 +202,7 @@ export interface ExprNumericBinary<I> {
  * @see NumericComparisonOperand for available operations
  */
 export interface ExprNumericComparison<I> {
-  type: 'numericComparison';
+  type: "numericComparison";
   /** The comparison operation to apply */
   operand: NumericComparisonOperand;
   /** Left operand expression */
@@ -222,7 +232,7 @@ export interface ExprNumericComparison<I> {
  * { type: 'stringEquals', input: nameColumn, value: 'John', caseInsensitive: true }
  */
 export interface ExprStringEquals<I> {
-  type: 'stringEquals';
+  type: "stringEquals";
   /** Input expression (must evaluate to string) */
   input: I;
   /** Reference string to compare against */
@@ -251,7 +261,7 @@ export interface ExprStringEquals<I> {
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions | MDN Regular Expressions Guide}
  */
 export interface ExprStringRegex<I> {
-  type: 'stringRegex';
+  type: "stringRegex";
   /** Input expression (must evaluate to string) */
   input: I;
   /** Regular expression pattern */
@@ -276,7 +286,7 @@ export interface ExprStringRegex<I> {
  * { type: 'stringContains', input: descColumn, value: 'ERROR', caseInsensitive: true }
  */
 export interface ExprStringContains<I> {
-  type: 'stringContains';
+  type: "stringContains";
   /** Input expression (must evaluate to string) */
   input: I;
   /** Substring to search for */
@@ -320,7 +330,7 @@ export interface ExprStringContains<I> {
  * }
  */
 export interface ExprStringContainsFuzzy<I> {
-  type: 'stringContainsFuzzy';
+  type: "stringContainsFuzzy";
   /** Input expression (must evaluate to string) */
   input: I;
   /** Pattern to match against */
@@ -360,7 +370,7 @@ export interface ExprStringContainsFuzzy<I> {
  * { type: 'not', input: comparisonExpr }
  */
 export interface ExprLogicalUnary<I> {
-  type: 'not';
+  type: "not";
   /** Input boolean expression to negate */
   input: I;
 }
@@ -387,7 +397,7 @@ export interface ExprLogicalUnary<I> {
  */
 export interface ExprLogicalVariadic<I> {
   /** Logical operation: 'and' or 'or' */
-  type: 'and' | 'or';
+  type: "and" | "or";
   /** Array of boolean expressions to combine (minimum 2 elements) */
   input: I[];
 }
@@ -412,7 +422,7 @@ export interface ExprLogicalVariadic<I> {
  * }
  */
 export interface ExprIsIn<I, T extends string | number> {
-  type: 'isIn';
+  type: "isIn";
   /** Input expression to test */
   input: I;
   /** Set of allowed values */
@@ -437,7 +447,7 @@ export interface ExprIsIn<I, T extends string | number> {
  * { type: 'axisRef', value: 0 }
  */
 export interface ExprAxisRef<A> {
-  type: 'axisRef';
+  type: "axisRef";
   /** Axis identifier (selector or index depending on context) */
   value: A;
 }
@@ -458,20 +468,20 @@ export interface ExprAxisRef<A> {
  * { type: 'columnRef', value: 0 }
  */
 export interface ExprColumnRef<C> {
-  type: 'columnRef';
+  type: "columnRef";
   /** Column identifier (ID or index depending on context) */
   value: C;
 }
 
 export type InferBooleanExpressionUnion<E> = [
-  E extends ExprNumericComparison<unknown> ? Extract<E, { type: 'numericComparison' }> : never,
-  E extends ExprStringEquals<unknown> ? Extract<E, { type: 'stringEquals' }> : never,
-  E extends ExprStringContains<unknown> ? Extract<E, { type: 'stringContains' }> : never,
-  E extends ExprStringContainsFuzzy<unknown> ? Extract<E, { type: 'stringContainsFuzzy' }> : never,
-  E extends ExprStringRegex<unknown> ? Extract<E, { type: 'stringRegex' }> : never,
-  E extends ExprLogicalUnary<unknown> ? Extract<E, { type: 'not' }> : never,
-  E extends ExprLogicalVariadic<unknown> ? Extract<E, { type: 'and' | 'or' }> : never,
-  E extends ExprIsIn<unknown, string | number> ? Extract<E, { type: 'isIn' }> : never,
+  E extends ExprNumericComparison<unknown> ? Extract<E, { type: "numericComparison" }> : never,
+  E extends ExprStringEquals<unknown> ? Extract<E, { type: "stringEquals" }> : never,
+  E extends ExprStringContains<unknown> ? Extract<E, { type: "stringContains" }> : never,
+  E extends ExprStringContainsFuzzy<unknown> ? Extract<E, { type: "stringContainsFuzzy" }> : never,
+  E extends ExprStringRegex<unknown> ? Extract<E, { type: "stringRegex" }> : never,
+  E extends ExprLogicalUnary<unknown> ? Extract<E, { type: "not" }> : never,
+  E extends ExprLogicalVariadic<unknown> ? Extract<E, { type: "and" | "or" }> : never,
+  E extends ExprIsIn<unknown, string | number> ? Extract<E, { type: "isIn" }> : never,
 ][number];
 
 // ============ Generic Query Types ============
@@ -496,7 +506,7 @@ export type InferBooleanExpressionUnion<E> = [
  * { type: 'axis', id: 0 }
  */
 export interface QueryAxisSelector<A> {
-  type: 'axis';
+  type: "axis";
   /** Axis identifier (name or index depending on context) */
   id: A;
 }
@@ -519,7 +529,7 @@ export interface QueryAxisSelector<A> {
  * { type: 'column', id: 0 }
  */
 export interface QueryColumnSelector<C> {
-  type: 'column';
+  type: "column";
   /** Column identifier (name or index depending on context) */
   id: C;
 }
@@ -551,7 +561,7 @@ export interface QueryColumnSelector<C> {
  * // Result has all samples; annotations/metadata are null where not available
  */
 export interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
-  type: 'outerJoin';
+  type: "outerJoin";
   /** Primary query - all its records are preserved */
   primary: JE;
   /** Secondary queries - joined where keys match, null where they don't */
@@ -584,7 +594,7 @@ export interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
  * }
  */
 export interface QuerySliceAxes<Q, A extends QueryAxisSelector<unknown>> {
-  type: 'sliceAxes';
+  type: "sliceAxes";
   /** Input query to slice */
   input: Q;
   /** List of axis filters to apply (at least one required) */
@@ -617,18 +627,18 @@ export interface QuerySliceAxes<Q, A extends QueryAxisSelector<unknown>> {
  *   type: 'sort',
  *   input: dataQuery,
  *   sortBy: [
- *     { axisOrColumn: { type: 'column', id: 'score' }, ascending: false, nullsFirst: null },
- *     { axisOrColumn: { type: 'axis', id: 'name' }, ascending: true, nullsFirst: null }
+ *     { expression: { type: 'columnRef', value: 'score' }, ascending: false, nullsFirst: null },
+ *     { expression: { type: 'axisRef', value: { name: 'name' } }, ascending: true, nullsFirst: null }
  *   ]
  * }
  */
 export interface QuerySort<Q, E> {
-  type: 'sort';
+  type: "sort";
   /** Input query to sort */
   input: Q;
   /** Sort criteria in priority order (at least one required) */
   sortBy: {
-    data: E;
+    expression: E;
     /** If true, sort ascending (A-Z, 0-9); if false, descending */
     ascending: boolean;
     /**
@@ -674,7 +684,7 @@ export interface QuerySort<Q, E> {
  * }
  */
 export interface QueryFilter<Q, E> {
-  type: 'filter';
+  type: "filter";
   /** Input query to filter */
   input: Q;
   /** Boolean predicate expression - only true records pass */
@@ -695,7 +705,7 @@ export interface QueryFilter<Q, E> {
  * { type: 'column', columnId: 'col_abc123' }
  */
 export interface QueryColumn {
-  type: 'column';
+  type: "column";
   /** Unique identifier of the column to reference */
   columnId: PObjectId;
 }
@@ -720,7 +730,7 @@ export interface QueryColumn {
  * }
  */
 export interface QueryInlineColumn<T> {
-  type: 'inlineColumn';
+  type: "inlineColumn";
   /** Type specification defining axes and column types */
   spec: T;
   /** Data information containing or referencing the actual values */
@@ -753,7 +763,7 @@ export interface QueryInlineColumn<T> {
  * }
  */
 export interface QuerySparseToDenseColumn<SO> {
-  type: 'sparseToDenseColumn';
+  type: "sparseToDenseColumn";
   /** ID of the column to cross-join */
   columnId: PObjectId;
   /** Optional override for the column specification */
@@ -797,7 +807,7 @@ export interface QuerySparseToDenseColumn<SO> {
  */
 export interface QuerySymmetricJoin<JE extends QueryJoinEntry<unknown>> {
   /** 'innerJoin' for intersection, 'fullJoin' for union with nulls */
-  type: 'innerJoin' | 'fullJoin';
+  type: "innerJoin" | "fullJoin";
   /** Queries to join (at least one required) */
   entries: JE[];
 }

package/src/drivers/pframe/query/query_data.ts

@@ -1,4 +1,4 @@
-import type { PObjectId } from '../../../pool';
+import type { PObjectId } from "../../../pool";
 import type {
   ExprAxisRef,
   ExprColumnRef,
@@ -13,7 +13,8 @@ import type {
   ExprStringRegex,
   ExprNumericUnary,
   QueryAxisSelector,
-  QueryColumn, QuerySparseToDenseColumn,
+  QueryColumn,
+  QuerySparseToDenseColumn,
   QueryFilter,
   QueryInlineColumn,
   QueryJoinEntry,
@@ -23,7 +24,7 @@ import type {
   QuerySymmetricJoin,
   TypeSpec,
   InferBooleanExpressionUnion,
-} from './query_common';
+} from "./query_common";
 
 /**
  * Column identifier with type specification.
@@ -99,12 +100,18 @@ export type ExprAxisRefData = ExprAxisRef<number>;
 export type ExprColumnRefData = ExprColumnRef<number>;
 
 export type QueryExpressionData =
-  | ExprColumnRefData | ExprAxisRefData | ExprConstant
-  | ExprNumericBinary<QueryExpressionData> | ExprNumericUnary<QueryExpressionData>
-  | ExprStringEquals<QueryExpressionData> | ExprStringContains<QueryExpressionData>
-  | ExprStringRegex<QueryExpressionData> | ExprStringContainsFuzzy<QueryExpressionData>
-  | ExprLogicalUnary<QueryExpressionData> | ExprLogicalVariadic<QueryExpressionData>
-  | ExprIsIn<QueryExpressionData, string> | ExprIsIn<QueryExpressionData, number>
-  ;
+  | ExprColumnRefData
+  | ExprAxisRefData
+  | ExprConstant
+  | ExprNumericBinary<QueryExpressionData>
+  | ExprNumericUnary<QueryExpressionData>
+  | ExprStringEquals<QueryExpressionData>
+  | ExprStringContains<QueryExpressionData>
+  | ExprStringRegex<QueryExpressionData>
+  | ExprStringContainsFuzzy<QueryExpressionData>
+  | ExprLogicalUnary<QueryExpressionData>
+  | ExprLogicalVariadic<QueryExpressionData>
+  | ExprIsIn<QueryExpressionData, string>
+  | ExprIsIn<QueryExpressionData, number>;
 
 export type QueryBooleanExpressionData = InferBooleanExpressionUnion<QueryExpressionData>;

package/src/drivers/pframe/query/query_spec.ts

@@ -1,4 +1,4 @@
-import type { PObjectId } from '../../../pool';
+import type { PObjectId } from "../../../pool";
 import type {
   ExprAxisRef,
   ExprColumnRef,
@@ -13,7 +13,8 @@ import type {
   ExprStringRegex,
   ExprNumericUnary,
   QueryAxisSelector,
-  QueryColumn, QuerySparseToDenseColumn,
+  QueryColumn,
+  QuerySparseToDenseColumn,
   QueryFilter,
   QueryInlineColumn,
   QueryJoinEntry,
@@ -22,8 +23,8 @@ import type {
   QuerySort,
   QuerySymmetricJoin,
   InferBooleanExpressionUnion,
-} from './query_common';
-import type { Domain, PColumnIdAndSpec, PColumnSpec, SingleAxisSelector } from '../spec';
+} from "./query_common";
+import type { Domain, PColumnIdAndSpec, PColumnSpec, SingleAxisSelector } from "../spec";
 
 /**
  * Column identifier with specification.
@@ -108,11 +109,18 @@ export type ExprAxisRefSpec = ExprAxisRef<SingleAxisSelector>;
 export type ExprColumnRefSpec = ExprColumnRef<PObjectId>;
 
 export type QueryExpressionSpec =
-  | ExprColumnRefSpec | ExprAxisRefSpec | ExprConstant
-  | ExprNumericBinary<QueryExpressionSpec> | ExprNumericUnary<QueryExpressionSpec>
-  | ExprStringEquals<QueryExpressionSpec> | ExprStringContains<QueryExpressionSpec>
-  | ExprStringRegex<QueryExpressionSpec> | ExprStringContainsFuzzy<QueryExpressionSpec>
-  | ExprLogicalUnary<QueryExpressionSpec> | ExprLogicalVariadic<QueryExpressionSpec>
-  | ExprIsIn<QueryExpressionSpec, string> | ExprIsIn<QueryExpressionSpec, number>;
+  | ExprColumnRefSpec
+  | ExprAxisRefSpec
+  | ExprConstant
+  | ExprNumericBinary<QueryExpressionSpec>
+  | ExprNumericUnary<QueryExpressionSpec>
+  | ExprStringEquals<QueryExpressionSpec>
+  | ExprStringContains<QueryExpressionSpec>
+  | ExprStringRegex<QueryExpressionSpec>
+  | ExprStringContainsFuzzy<QueryExpressionSpec>
+  | ExprLogicalUnary<QueryExpressionSpec>
+  | ExprLogicalVariadic<QueryExpressionSpec>
+  | ExprIsIn<QueryExpressionSpec, string>
+  | ExprIsIn<QueryExpressionSpec, number>;
 
 export type QueryBooleanExpressionSpec = InferBooleanExpressionUnion<QueryExpressionSpec>;