@effect-app/infra 4.0.0-beta.23 → 4.0.0-beta.231

package/src/Model/query/dsl.ts

@@ -1,8 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Data, flow, type Option, Pipeable, type S } from "effect-app"
+import type * as Option from "effect-app/Option"
+import type * as S from "effect-app/Schema"
 import type { NonNegativeInt } from "effect-app/Schema"
+import * as Data from "effect/Data"
+import { flow } from "effect/Function"
+import * as Pipeable from "effect/Pipeable"
 import type { Covariant } from "effect/Types"
 import type { Ops } from "../filter/filterApi.js"
 import type { FieldValues } from "../filter/types.js"
@@ -54,7 +58,7 @@ type ExtractFieldValuesRefined<T> = T extends QueryTogether<any, infer TFieldVal
 
 export type RelationDirection = "some" | "every"
 export type Relation = { relation: RelationDirection }
-export type Query<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, TFieldValues, false, "initial">
+export type Query<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, TFieldValues>
 export type QueryWhere<
   TFieldValues extends FieldValues,
   TFieldValuesRefined extends TFieldValues = TFieldValues,
@@ -97,6 +101,121 @@ export type QueryProjection<
   R,
   TType
 >
+
+export type ComputedProjectionOperation = (q: Query<any>) => QueryWhere<any, any, any>
+
+export type ComputedProjectionMathExpression =
+  | {
+    readonly _tag: "field"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "mul"
+    readonly left: ComputedProjectionMathExpression
+    readonly right: ComputedProjectionMathExpression
+  }
+
+export type ComputedProjectionExpression =
+  | {
+    readonly _tag: "relation-count"
+    readonly path: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-any"
+    readonly path: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-every"
+    readonly path: string
+    readonly operation: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-distinct-count"
+    readonly path: string
+    readonly field: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum"
+    readonly path: string
+    readonly field: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum-expr"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum-expr-by"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly unit: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum-expr-normalized"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly unit: string
+    readonly toBase: string
+    readonly factors: Readonly<Record<string, number>>
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-collect"
+    readonly path: string
+    readonly field: string
+    readonly distinct: boolean
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-collect-fields"
+    readonly path: string
+    readonly fields: readonly string[]
+    readonly distinct: boolean
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-length"
+    readonly path: string
+  }
+
+/**
+ * An expression that aggregates values across documents (for use with {@link aggregate}).
+ * `agg-field` references a document field to group by; other tags are aggregate functions.
+ */
+export type AggregateExpression =
+  | {
+    readonly _tag: "agg-field"
+    readonly path: string
+  }
+  | {
+    readonly _tag: "agg-count"
+  }
+  | {
+    readonly _tag: "agg-count-when"
+    readonly operation: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "agg-sum"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "agg-min"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "agg-max"
+    readonly field: string
+  }
+
+export type AggregateMap = Readonly<Record<string, AggregateExpression>>
+
+export type ComputedProjectionMap = Readonly<Record<string, ComputedProjectionExpression>>
 export type Q<TFieldValues extends FieldValues> =
   | Initial<TFieldValues>
   | Where<TFieldValues>
@@ -210,7 +329,9 @@ export class Project<A, TFieldValues extends FieldValues, R, TType extends "one"
   extends Data.TaggedClass("project")<{
     current: Query<TFieldValues> | QueryWhere<any, TFieldValues> | QueryEnd<TFieldValues, TType>
     schema: S.Codec<A, TFieldValues, R>
-    mode: "collect" | "project" | "transform"
+    mode: "collect" | "project" | "transform" | "aggregate"
+    computed?: ComputedProjectionMap
+    aggregateMap?: AggregateMap
   }>
   implements QueryProjection<TFieldValues, A, R>
 {
@@ -299,6 +420,35 @@ export const count: {
   ): QueryProjection<ExtractFieldValuesRefined<Q>, NonNegativeInt, never, "count", ExtractExclusiveness<Q>>
 } = (current) => new Count({ current })
 
+/**
+ * Attach a projection schema to a query.
+ *
+ * The `select` clause sent to the store is derived from the schema's encoded
+ * AST property names (top-level + per-array sub-keys), so a projection always
+ * narrows what is read from the store. The repository augments that select
+ * with `id` and `_etag` for change tracking. See {@link toFilter} and the
+ * dispatch in `Repository/internal/internal.ts`.
+ *
+ * Modes — pick based on shape of the decoded value and on whether the
+ * persistence-model (PM) reverse-mapping is needed:
+ *
+ * - `"transform"` (default when `mode` omitted): goes through the repo's
+ *   `parseMany` pipeline. The raw row is reverse-mapped via the
+ *   etag/PM cache (re-injecting `_etag` and any PM-shape state) before
+ *   decoding. Decode failures `orDie` (error channel = `never`). Use when
+ *   the schema operates on the full PM shape (e.g. full-entity reads that
+ *   must preserve etag tracking).
+ *
+ * - `"project"`: decodes the raw encoded row directly with the supplied
+ *   schema. No PM reverse-mapping, no etag cache merge. Decode failures
+ *   surface as `S.SchemaError`. Use for slim DTOs / aggregations that do not
+ *   need etag tracking and whose schema input is a plain subset of `Encoded`.
+ *
+ * - `"collect"`: like `"project"`, but the schema yields `Option<A>` and
+ *   `None` values are dropped post-decode (`Array.getSomes`). Use to filter
+ *   rows during decode (e.g. discriminated-union narrowing where some rows
+ *   should not appear in the result).
+ */
 export const project: {
   <
     Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
@@ -356,6 +506,292 @@ export const project: {
   ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
 } = (schema: any, mode = "transform") => (current: any) => new Project({ current, schema, mode } as any)
 
+export const relation = <TFieldValues extends FieldValues>(
+  path: FieldPath<TFieldValues>
+) => ({
+  length: (): ComputedProjectionExpression => ({
+    _tag: "relation-length",
+    path: path as string
+  }),
+  count: (operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-count",
+        path: path as string,
+        operation
+      }
+      : {
+        _tag: "relation-count",
+        path: path as string
+      },
+  any: (operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-any",
+        path: path as string,
+        operation
+      }
+      : {
+        _tag: "relation-any",
+        path: path as string
+      },
+  every: (operation: ComputedProjectionOperation): ComputedProjectionExpression => ({
+    _tag: "relation-every",
+    path: path as string,
+    operation
+  }),
+  distinctCount: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-distinct-count",
+        path: path as string,
+        field,
+        operation
+      }
+      : {
+        _tag: "relation-distinct-count",
+        path: path as string,
+        field
+      },
+  sum: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum",
+        path: path as string,
+        field,
+        operation
+      }
+      : {
+        _tag: "relation-sum",
+        path: path as string,
+        field
+      },
+  sumExpr: (
+    expression: ComputedProjectionMathExpression,
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr",
+        path: path as string,
+        expression,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr",
+        path: path as string,
+        expression
+      },
+  sumExprBy: (
+    expression: ComputedProjectionMathExpression,
+    options: { unit: string },
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr-by",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr-by",
+        path: path as string,
+        expression,
+        unit: options.unit
+      },
+  sumExprNormalized: (
+    expression: ComputedProjectionMathExpression,
+    options: { unit: string; toBase: string; factors: Readonly<Record<string, number>> },
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr-normalized",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        toBase: options.toBase,
+        factors: options.factors,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr-normalized",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        toBase: options.toBase,
+        factors: options.factors
+      },
+  collect: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: false,
+        operation
+      }
+      : {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: false
+      },
+  collectDistinct: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: true,
+        operation
+      }
+      : {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: true
+      },
+  collectFields: (fields: readonly string[], operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect-fields",
+        path: path as string,
+        fields,
+        distinct: false,
+        operation
+      }
+      : {
+        _tag: "relation-collect-fields",
+        path: path as string,
+        fields,
+        distinct: false
+      },
+  collectDistinctFields: (
+    fields: readonly string[],
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect-fields",
+        path: path as string,
+        fields,
+        distinct: true,
+        operation
+      }
+      : {
+        _tag: "relation-collect-fields",
+        path: path as string,
+        fields,
+        distinct: true
+      }
+})
+
+export const expr = {
+  field: (field: string): ComputedProjectionMathExpression => ({ _tag: "field", field }),
+  mul: (
+    left: ComputedProjectionMathExpression,
+    right: ComputedProjectionMathExpression
+  ): ComputedProjectionMathExpression => ({ _tag: "mul", left, right })
+} as const
+
+export const computed = <T extends ComputedProjectionMap>(value: T): T => value
+
+export const projectComputed: {
+  <
+    Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
+    I extends Record<string, unknown>,
+    A = ExtractFieldValuesRefined<Q>,
+    R = never,
+    E extends boolean = ExtractExclusiveness<Q>
+  >(
+    schema: S.Codec<Option.Option<A>, I, R>,
+    computedProjection: ComputedProjectionMap,
+    mode: "collect"
+  ): (
+    current: Q
+  ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
+
+  <
+    Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
+    I extends Record<string, unknown>,
+    A = ExtractFieldValuesRefined<Q>,
+    R = never,
+    E extends boolean = ExtractExclusiveness<Q>
+  >(
+    schema: S.Codec<A, I, R>,
+    computedProjection: ComputedProjectionMap,
+    mode?: "project"
+  ): (
+    current: Q
+  ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
+} = (schema: any, computedProjection: ComputedProjectionMap, mode = "project") => (current: any) =>
+  new Project({ current, schema, mode, computed: computedProjection } as any)
+
+/**
+ * DSL helpers for building aggregate expressions used with {@link aggregate}.
+ *
+ * - `agg.field(path)` — references a document field for GROUP BY (with optional output alias)
+ * - `agg.count()` — COUNT(*) across all rows in the group
+ * - `agg.countWhen(op)` — COUNT of rows matching the filter operation
+ * - `agg.sum(field)` — SUM of a numeric document field
+ * - `agg.min(field)` / `agg.max(field)` — MIN/MAX of a document field
+ */
+export const agg = {
+  field: (path: string): AggregateExpression => ({ _tag: "agg-field", path }),
+  count: (): AggregateExpression => ({ _tag: "agg-count" }),
+  countWhen: (operation: ComputedProjectionOperation): AggregateExpression => ({
+    _tag: "agg-count-when",
+    operation
+  }),
+  sum: (field: string): AggregateExpression => ({ _tag: "agg-sum", field }),
+  min: (field: string): AggregateExpression => ({ _tag: "agg-min", field }),
+  max: (field: string): AggregateExpression => ({ _tag: "agg-max", field })
+} as const
+
+/**
+ * Attach an aggregate projection to a query, performing GROUP BY + aggregate functions at the
+ * database level instead of fetching all rows and grouping in memory.
+ *
+ * The `aggregateMap` maps each output field name to either:
+ * - `agg.field(path)` — a group-by field (document path → output alias)
+ * - `agg.count()` / `agg.countWhen(op)` / `agg.sum(f)` / `agg.min(f)` / `agg.max(f)` — an aggregate
+ *
+ * The output is decoded directly with `schema` (no PM reverse-mapping, no etag tracking).
+ * Decode failures surface as `S.SchemaError`.
+ *
+ * @example
+ * ```ts
+ * repo.query(
+ *   where("status", "active"),
+ *   aggregate(
+ *     S.Struct({ city: S.String, count: S.Number }),
+ *     {
+ *       city: agg.field("address.city"),
+ *       count: agg.countWhen((q) => q.pipe(where("active", true)))
+ *     }
+ *   )
+ * )
+ * ```
+ */
+export const aggregate: {
+  <
+    Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
+    I extends Record<string, unknown>,
+    A = ExtractFieldValuesRefined<Q>,
+    R = never,
+    E extends boolean = ExtractExclusiveness<Q>
+  >(
+    schema: S.Codec<A, I, R>,
+    aggregateMap: AggregateMap
+  ): (
+    current: Q
+  ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
+} = (schema: any, aggregateMap: AggregateMap) => (current: any) =>
+  new Project({ current, schema, mode: "aggregate", aggregateMap } as any)
+
 type GetArV<T> = T extends readonly (infer R)[] ? R : never
 
 export type FilterContinuations<IsCurrentInitial extends boolean = false> = {
@@ -1538,7 +1974,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues, TFieldValuesRefined2, E2>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2>
 
   <
     TFieldValues extends FieldValues,
@@ -1555,7 +1991,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined3, E3>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined3, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined3>
 
   <
     TFieldValues extends FieldValues,
@@ -1577,7 +2013,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined4, E4>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined4, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined4>
 
   <
     TFieldValues extends FieldValues,
@@ -1604,7 +2040,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined5, E5>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined5, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined5>
 
   <
     TFieldValues extends FieldValues,
@@ -1636,7 +2072,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined6, E6>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined6, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined6>
 
   <
     TFieldValues extends FieldValues,
@@ -1673,7 +2109,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined7, E7>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined7, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined7>
 
   <
     TFieldValues extends FieldValues,
@@ -1715,7 +2151,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined8, E8>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2>
 
   <
     TFieldValues extends FieldValues,
@@ -1762,7 +2198,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined9, E9>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined9, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined9>
 
   <
     TFieldValues extends FieldValues,
@@ -1814,7 +2250,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined10, E10>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined10, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined10>
 
   <
     TFieldValues extends FieldValues,
@@ -1871,7 +2307,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined11, E11>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined11, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined11>
 
   <
     TFieldValues extends FieldValues,
@@ -1933,7 +2369,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined12, E12>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined12, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined12>
 
   <
     TFieldValues extends FieldValues,
@@ -2000,7 +2436,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined13, E13>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined13, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined13>
 
   <
     TFieldValues extends FieldValues,
@@ -2072,7 +2508,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined14, E14>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined14, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined14>
 }
 
 export type FilterWhere =
@@ -2099,12 +2535,12 @@ export type WhereEveryOrSome =
       subPath: TFieldName,
       dude: (
         current: Query<TFieldValues[TFieldName][number]>
-      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>,
+      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>,
       ...dudes: ((
-        current: QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>
-      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>)[]
+        current: QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>
+      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>)[]
     ): (
       current: Query<TFieldValues>
-    ) => QueryWhere<TFieldValues, TFieldValues, false>
+    ) => QueryWhere<TFieldValues, TFieldValues>
   }
   & FilterContinuationsWithSubpath