@platforma-sdk/model 1.53.15 → 1.54.8

package/src/filters/converters/filterToQuery.test.ts

@@ -0,0 +1,417 @@
+import { describe, expect, it } from "vitest";
+import type { FilterSpec, FilterSpecLeaf } from "@milaboratories/pl-model-common";
+import { filterSpecToSpecQueryExpr } from "./filterToQuery";
+
+type QFilterSpec = FilterSpec<FilterSpecLeaf<string>>;
+
+/** Helper: creates a CanonicalizedJson<PTableColumnId> for a regular column. */
+function colRef(id: string): string {
+  return JSON.stringify({ type: "column", id });
+}
+
+/** Helper: creates a CanonicalizedJson<PTableColumnId> for an axis. */
+function axisRef(id: string): string {
+  return JSON.stringify({ type: "axis", id });
+}
+
+describe("filterSpecToSpecQueryExpr", () => {
+  // --- logical combinators ---
+
+  it('should convert "and" filter', () => {
+    const filter: QFilterSpec = {
+      type: "and",
+      filters: [
+        { type: "equal", column: colRef("c1"), x: 1 },
+        { type: "equal", column: colRef("c2"), x: 2 },
+      ],
+    };
+    const result = filterSpecToSpecQueryExpr(filter);
+    expect(result.type).toBe("and");
+    if (result.type === "and") {
+      expect(result.input).toHaveLength(2);
+    }
+  });
+
+  it('should convert "or" filter', () => {
+    const filter: QFilterSpec = {
+      type: "or",
+      filters: [
+        { type: "equal", column: colRef("c1"), x: 1 },
+        { type: "equal", column: colRef("c2"), x: 2 },
+      ],
+    };
+    const result = filterSpecToSpecQueryExpr(filter);
+    expect(result.type).toBe("or");
+    if (result.type === "or") {
+      expect(result.input).toHaveLength(2);
+    }
+  });
+
+  it('should convert "not" filter', () => {
+    const filter: QFilterSpec = {
+      type: "not",
+      filter: { type: "equal", column: colRef("c1"), x: 5 },
+    };
+    const result = filterSpecToSpecQueryExpr(filter);
+    expect(result.type).toBe("not");
+    if (result.type === "not") {
+      expect(result.input.type).toBe("numericComparison");
+    }
+  });
+
+  it("should skip filters with undefined type in and/or", () => {
+    const filter: QFilterSpec = {
+      type: "and",
+      filters: [{ type: undefined }, { type: "equal", column: colRef("c1"), x: 1 }],
+    };
+    const result = filterSpecToSpecQueryExpr(filter);
+    expect(result.type).toBe("and");
+    if (result.type === "and") {
+      expect(result.input).toHaveLength(1);
+      expect(result.input[0].type).toBe("numericComparison");
+    }
+  });
+
+  it("should throw for empty and filter (after skipping undefined)", () => {
+    const filter: QFilterSpec = {
+      type: "and",
+      filters: [{ type: undefined }],
+    };
+    expect(() => filterSpecToSpecQueryExpr(filter)).toThrow(
+      "AND filter requires at least one operand",
+    );
+  });
+
+  it("should throw for empty or filter", () => {
+    const filter: QFilterSpec = { type: "or", filters: [] };
+    expect(() => filterSpecToSpecQueryExpr(filter)).toThrow(
+      "OR filter requires at least one operand",
+    );
+  });
+
+  // --- string filters ---
+
+  it('should convert "patternEquals" filter', () => {
+    const filter: QFilterSpec = {
+      type: "patternEquals",
+      column: colRef("col1"),
+      value: "abc",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "stringEquals",
+      input: { type: "columnRef", value: "col1" },
+      value: "abc",
+      caseInsensitive: false,
+    });
+  });
+
+  it('should convert "patternNotEquals" filter', () => {
+    const filter: QFilterSpec = {
+      type: "patternNotEquals",
+      column: colRef("col1"),
+      value: "abc",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "not",
+      input: {
+        type: "stringEquals",
+        input: { type: "columnRef", value: "col1" },
+        value: "abc",
+        caseInsensitive: false,
+      },
+    });
+  });
+
+  it('should convert "patternContainSubsequence" filter', () => {
+    const filter: QFilterSpec = {
+      type: "patternContainSubsequence",
+      column: colRef("col1"),
+      value: "sub",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "stringContains",
+      input: { type: "columnRef", value: "col1" },
+      value: "sub",
+      caseInsensitive: false,
+    });
+  });
+
+  it('should convert "patternNotContainSubsequence" filter', () => {
+    const filter: QFilterSpec = {
+      type: "patternNotContainSubsequence",
+      column: colRef("col1"),
+      value: "sub",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "not",
+      input: {
+        type: "stringContains",
+        input: { type: "columnRef", value: "col1" },
+        value: "sub",
+        caseInsensitive: false,
+      },
+    });
+  });
+
+  it('should convert "patternMatchesRegularExpression" filter', () => {
+    const filter: QFilterSpec = {
+      type: "patternMatchesRegularExpression",
+      column: colRef("col1"),
+      value: "^abc.*",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "stringRegex",
+      input: { type: "columnRef", value: "col1" },
+      value: "^abc.*",
+    });
+  });
+
+  it('should convert "patternFuzzyContainSubsequence" filter with defaults', () => {
+    const filter: QFilterSpec = {
+      type: "patternFuzzyContainSubsequence",
+      column: colRef("col1"),
+      value: "fuz",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "stringContainsFuzzy",
+      input: { type: "columnRef", value: "col1" },
+      value: "fuz",
+      maxEdits: 1,
+      caseInsensitive: false,
+      substitutionsOnly: false,
+      wildcard: null,
+    });
+  });
+
+  it('should convert "patternFuzzyContainSubsequence" filter with custom options', () => {
+    const filter: QFilterSpec = {
+      type: "patternFuzzyContainSubsequence",
+      column: colRef("col1"),
+      value: "fuz",
+      maxEdits: 3,
+      substitutionsOnly: true,
+      wildcard: "?",
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "stringContainsFuzzy",
+      input: { type: "columnRef", value: "col1" },
+      value: "fuz",
+      maxEdits: 3,
+      caseInsensitive: false,
+      substitutionsOnly: true,
+      wildcard: "?",
+    });
+  });
+
+  // --- numeric comparison filters ---
+
+  it("should convert numeric comparison filters", () => {
+    const testCases = [
+      { type: "equal" as const, operand: "eq" },
+      { type: "notEqual" as const, operand: "ne" },
+      { type: "lessThan" as const, operand: "lt" },
+      { type: "greaterThan" as const, operand: "gt" },
+      { type: "lessThanOrEqual" as const, operand: "le" },
+      { type: "greaterThanOrEqual" as const, operand: "ge" },
+    ];
+
+    testCases.forEach(({ type, operand }) => {
+      const filter: QFilterSpec = { type, column: colRef("num"), x: 42 };
+      expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+        type: "numericComparison",
+        operand,
+        left: { type: "columnRef", value: "num" },
+        right: { type: "constant", value: 42 },
+      });
+    });
+  });
+
+  // --- column-to-column comparisons ---
+
+  it('should convert "equalToColumn" filter', () => {
+    const filter: QFilterSpec = {
+      type: "equalToColumn",
+      column: colRef("c1"),
+      rhs: colRef("c2"),
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "numericComparison",
+      operand: "eq",
+      left: { type: "columnRef", value: "c1" },
+      right: { type: "columnRef", value: "c2" },
+    });
+  });
+
+  it("should convert column comparison filters without minDiff", () => {
+    const cases = [
+      { type: "lessThanColumn" as const, operand: "lt" },
+      { type: "greaterThanColumn" as const, operand: "gt" },
+      { type: "lessThanColumnOrEqual" as const, operand: "le" },
+      { type: "greaterThanColumnOrEqual" as const, operand: "ge" },
+    ];
+
+    cases.forEach(({ type, operand }) => {
+      const filter: QFilterSpec = { type, column: colRef("c1"), rhs: colRef("c2") };
+      expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+        type: "numericComparison",
+        operand,
+        left: { type: "columnRef", value: "c1" },
+        right: { type: "columnRef", value: "c2" },
+      });
+    });
+  });
+
+  it("should convert column comparison filters with minDiff", () => {
+    const cases = [
+      { type: "lessThanColumn" as const, operand: "lt" },
+      { type: "greaterThanColumn" as const, operand: "gt" },
+      { type: "lessThanColumnOrEqual" as const, operand: "le" },
+      { type: "greaterThanColumnOrEqual" as const, operand: "ge" },
+    ];
+
+    cases.forEach(({ type, operand }) => {
+      const filter: QFilterSpec = { type, column: colRef("c1"), rhs: colRef("c2"), minDiff: 5 };
+      expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+        type: "numericComparison",
+        operand,
+        left: {
+          type: "numericBinary",
+          operand: "add",
+          left: { type: "columnRef", value: "c1" },
+          right: { type: "constant", value: 5 },
+        },
+        right: { type: "columnRef", value: "c2" },
+      });
+    });
+  });
+
+  it("should treat minDiff=0 as no minDiff", () => {
+    const filter: QFilterSpec = {
+      type: "lessThanColumn",
+      column: colRef("c1"),
+      rhs: colRef("c2"),
+      minDiff: 0,
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "numericComparison",
+      operand: "lt",
+      left: { type: "columnRef", value: "c1" },
+      right: { type: "columnRef", value: "c2" },
+    });
+  });
+
+  // --- set filters ---
+
+  it('should convert "inSet" filter', () => {
+    const filter: QFilterSpec = {
+      type: "inSet",
+      column: colRef("col1"),
+      value: ["a", "b", "c"],
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "isIn",
+      input: { type: "columnRef", value: "col1" },
+      set: ["a", "b", "c"],
+    });
+  });
+
+  it('should convert "notInSet" filter', () => {
+    const filter: QFilterSpec = {
+      type: "notInSet",
+      column: colRef("col1"),
+      value: ["x"],
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "not",
+      input: {
+        type: "isIn",
+        input: { type: "columnRef", value: "col1" },
+        set: ["x"],
+      },
+    });
+  });
+
+  // --- axis references ---
+
+  it("should resolve axis column references", () => {
+    const filter: QFilterSpec = {
+      type: "equal",
+      column: axisRef("pl7.app/sampleId"),
+      x: 10,
+    };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "numericComparison",
+      operand: "eq",
+      left: { type: "axisRef", value: "pl7.app/sampleId" },
+      right: { type: "constant", value: 10 },
+    });
+  });
+
+  // --- null check filters ---
+
+  it('should convert "isNA" filter', () => {
+    const filter: QFilterSpec = { type: "isNA", column: colRef("c1") };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "isNull",
+      input: { type: "columnRef", value: "c1" },
+    });
+  });
+
+  it('should convert "isNotNA" filter', () => {
+    const filter: QFilterSpec = { type: "isNotNA", column: colRef("c1") };
+    expect(filterSpecToSpecQueryExpr(filter)).toEqual({
+      type: "not",
+      input: {
+        type: "isNull",
+        input: { type: "columnRef", value: "c1" },
+      },
+    });
+  });
+
+  // --- unsupported types ---
+
+  it("should throw for topN filter", () => {
+    const filter: QFilterSpec = { type: "topN", column: colRef("c1"), n: 5 };
+    expect(() => filterSpecToSpecQueryExpr(filter)).toThrow('Filter type "topN" is not supported');
+  });
+
+  it("should throw for bottomN filter", () => {
+    const filter: QFilterSpec = { type: "bottomN", column: colRef("c1"), n: 3 };
+    expect(() => filterSpecToSpecQueryExpr(filter)).toThrow(
+      'Filter type "bottomN" is not supported',
+    );
+  });
+
+  it("should throw for undefined filter type", () => {
+    const filter: QFilterSpec = { type: undefined };
+    expect(() => filterSpecToSpecQueryExpr(filter)).toThrow("Filter type is undefined");
+  });
+
+  // --- nested ---
+
+  it("should convert nested and/or/not filters", () => {
+    const filter: QFilterSpec = {
+      type: "and",
+      filters: [
+        {
+          type: "or",
+          filters: [
+            { type: "patternEquals", column: colRef("col1"), value: "a" },
+            { type: "patternEquals", column: colRef("col1"), value: "b" },
+          ],
+        },
+        {
+          type: "not",
+          filter: { type: "greaterThan", column: colRef("num"), x: 100 },
+        },
+      ],
+    };
+    const result = filterSpecToSpecQueryExpr(filter);
+    expect(result.type).toBe("and");
+    if (result.type === "and") {
+      expect(result.input).toHaveLength(2);
+      expect(result.input[0].type).toBe("or");
+      expect(result.input[1].type).toBe("not");
+    }
+  });
+});

package/src/filters/converters/filterToQuery.ts

@@ -0,0 +1,258 @@
+import { assertNever } from "@milaboratories/pl-model-common";
+import type {
+  FilterSpec,
+  FilterSpecLeaf,
+  PTableColumnId,
+  SingleAxisSelector,
+  SpecQueryExpression,
+} from "@milaboratories/pl-model-common";
+
+/** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */
+function resolveColumnRef(columnStr: string): SpecQueryExpression {
+  const parsed = JSON.parse(columnStr) as PTableColumnId;
+  if (parsed.type === "axis") {
+    return { type: "axisRef", value: parsed.id as SingleAxisSelector };
+  }
+  return { type: "columnRef", value: parsed.id };
+}
+
+/** Converts a FilterSpec tree into a SpecQueryExpression. */
+export function filterSpecToSpecQueryExpr(
+  filter: FilterSpec<FilterSpecLeaf<string>>,
+): SpecQueryExpression {
+  switch (filter.type) {
+    case "and":
+    case "or": {
+      const inputs = filter.filters
+        .filter((f) => f.type !== undefined)
+        .map(filterSpecToSpecQueryExpr);
+      if (inputs.length === 0) {
+        throw new Error(`${filter.type.toUpperCase()} filter requires at least one operand`);
+      }
+      return { type: filter.type, input: inputs };
+    }
+    case "not":
+      return { type: "not", input: filterSpecToSpecQueryExpr(filter.filter) };
+
+    case "patternEquals":
+      return {
+        type: "stringEquals",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        caseInsensitive: false,
+      };
+    case "patternNotEquals":
+      return {
+        type: "not",
+        input: {
+          type: "stringEquals",
+          input: resolveColumnRef(filter.column),
+          value: filter.value,
+          caseInsensitive: false,
+        },
+      };
+    case "patternContainSubsequence":
+      return {
+        type: "stringContains",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        caseInsensitive: false,
+      };
+    case "patternNotContainSubsequence":
+      return {
+        type: "not",
+        input: {
+          type: "stringContains",
+          input: resolveColumnRef(filter.column),
+          value: filter.value,
+          caseInsensitive: false,
+        },
+      };
+    case "patternMatchesRegularExpression":
+      return {
+        type: "stringRegex",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+      };
+    case "patternFuzzyContainSubsequence":
+      return {
+        type: "stringContainsFuzzy",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        maxEdits: filter.maxEdits ?? 1,
+        caseInsensitive: false,
+        substitutionsOnly: filter.substitutionsOnly ?? false,
+        wildcard: filter.wildcard ?? null,
+      };
+
+    case "equal":
+      return {
+        type: "numericComparison",
+        operand: "eq",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "notEqual":
+      return {
+        type: "numericComparison",
+        operand: "ne",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "lessThan":
+      return {
+        type: "numericComparison",
+        operand: "lt",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "greaterThan":
+      return {
+        type: "numericComparison",
+        operand: "gt",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "lessThanOrEqual":
+      return {
+        type: "numericComparison",
+        operand: "le",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "greaterThanOrEqual":
+      return {
+        type: "numericComparison",
+        operand: "ge",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+
+    case "equalToColumn":
+      return {
+        type: "numericComparison",
+        operand: "eq",
+        left: resolveColumnRef(filter.column),
+        right: resolveColumnRef(filter.rhs),
+      };
+    case "lessThanColumn": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "lt",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "lt", left, right };
+    }
+    case "greaterThanColumn": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "gt",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "gt", left, right };
+    }
+    case "lessThanColumnOrEqual": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "le",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "le", left, right };
+    }
+    case "greaterThanColumnOrEqual": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "ge",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "ge", left, right };
+    }
+
+    case "inSet":
+      return {
+        type: "isIn",
+        input: resolveColumnRef(filter.column),
+        set: filter.value,
+      };
+    case "notInSet":
+      return {
+        type: "not",
+        input: {
+          type: "isIn",
+          input: resolveColumnRef(filter.column),
+          set: filter.value,
+        },
+      };
+
+    case "isNA":
+      return {
+        type: "isNull",
+        input: resolveColumnRef(filter.column),
+      };
+    case "isNotNA":
+      return {
+        type: "not",
+        input: {
+          type: "isNull",
+          input: resolveColumnRef(filter.column),
+        },
+      };
+
+    case "ifNa":
+      return {
+        type: "ifNull",
+        input: resolveColumnRef(filter.column),
+        replacement: { type: "constant", value: filter.replacement },
+      };
+
+    case "topN":
+    case "bottomN":
+      throw new Error(`Filter type "${filter.type}" is not supported in query expressions`);
+
+    case undefined:
+      throw new Error("Filter type is undefined");
+
+    default:
+      assertNever(filter);
+  }
+}

package/src/filters/{converter.test.ts → converters/filterUiToExpressionImpl.test.ts}

@@ -1,7 +1,7 @@
 import type { SUniversalPColumnId } from "@milaboratories/pl-model-common";
 import { describe, expect, it } from "vitest";
-import { convertFilterUiToExpressions } from "./converter";
-import { FilterSpec } from "./types";
+import { convertFilterUiToExpressions } from "./filterUiToExpressionImpl";
+import { FilterSpec } from "../types";
 
 describe("convertFilterUiToExpressions", () => {
   it('should compile "or" filter to ptabler expression', () => {

package/src/filters/{converter.ts → converters/filterUiToExpressionImpl.ts}

@@ -8,7 +8,7 @@ import {
   type Expression,
   type ExpressionImpl,
 } from "@milaboratories/ptabler-expression-js";
-import type { FilterSpec } from "../filters";
+import type { FilterSpec } from "../types";
 
 export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionImpl {
   if (value.type === "or") {
@@ -127,7 +127,8 @@ export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionIm
     value.type === "patternMatchesRegularExpression" ||
     value.type === "patternFuzzyContainSubsequence" ||
     value.type === "inSet" ||
-    value.type === "notInSet"
+    value.type === "notInSet" ||
+    value.type === "ifNa"
   ) {
     throw new Error("Not implemented filter type: " + value.type);
   }

package/src/filters/converters/index.ts

@@ -0,0 +1,2 @@
+export * from "./filterToQuery";
+export * from "./filterUiToExpressionImpl";