@lossless.org/client 1.14.0 → 1.16.0

package/ts/nosqldb/classes.doc.ts

@@ -222,6 +222,13 @@ export interface SvDbOptions {
    * below this persisted field.
    */
   atomicPaths?: readonly string[];
+  /**
+   * Explicit relative nested paths below this persisted field that hold
+   * arrays. Each one is a declared nested path exactly like an `atomicPaths`
+   * entry, and in addition the array operators `$push`, `$addToSet` and
+   * `$pull` and the grouped-totals `unwind` may target it.
+   */
+  arrayPaths?: readonly string[];
   /**
    * Declares this persisted top-level field as numeric for strict atomic
    * expression references.
@@ -286,6 +293,13 @@ export function svDb(options?: SvDbOptions) {
                 : options.atomicPaths,
             }
           : {}),
+        ...(options.arrayPaths !== undefined
+          ? {
+              arrayPaths: Array.isArray(options.arrayPaths)
+                ? [...options.arrayPaths]
+                : options.arrayPaths,
+            }
+          : {}),
       }
     : undefined;
   return (value: undefined, context: ClassFieldDecoratorContext) => {
@@ -777,16 +791,52 @@ export interface ISmartdataAtomicNumericExpression<T> {
   ];
 }
 
-export interface ISmartdataGroupedTotalsOptions<T> {
+/**
+ * A path grouped totals may group by or sum: a declared top-level field or a
+ * nested path declared through `@svDb({ atomicPaths })` or
+ * `@svDb({ arrayPaths })`.
+ */
+export type TSmartdataGroupedTotalsPath<T> = TSmartdataAtomicDocumentPath<T>;
+
+/**
+ * A path grouped totals may unwind: a declared top-level array field or a
+ * nested path declared through `@svDb({ arrayPaths })`.
+ */
+export type TSmartdataGroupedTotalsUnwindPath<T> =
+  | TSmartdataAtomicArrayPath<T>
+  | TSmartdataAtomicNestedDocumentPath<T>;
+
+export interface ISmartdataGroupedTotalsOptions<
+  T,
+  TUnwind extends TSmartdataGroupedTotalsUnwindPath<T> = never,
+> {
   /**
-   * One or two declared top-level fields whose distinct value combinations
-   * form the groups.
+   * One or two distinct declared paths whose value combinations form the
+   * groups: declared top-level fields or nested paths declared through
+   * `@svDb({ atomicPaths })` or `@svDb({ arrayPaths })`.
    */
-  groupBy: ReadonlyArray<TSmartdataDocumentPath<T>>;
+  groupBy: ReadonlyArray<TSmartdataGroupedTotalsPath<T>>;
   /**
-   * Declared numeric top-level fields to sum per group.
+   * Aggregates per element of one array instead of per document: names a
+   * declared top-level array field or a nested path declared through
+   * `@svDb({ arrayPaths })`, which is itself a `groupBy` or `sums` path or
+   * holds the element fields that `groupBy` and `sums` paths name below it
+   * (`lines.accountNumber` below `unwind: 'lines'`). Element fields are
+   * declared nested paths like any other, through `@svDb({ atomicPaths })`
+   * on the array's field. Every element contributes on its own, so `count`
+   * counts elements and a document contributes its `sums` once per element;
+   * a document whose array is missing, null or empty contributes nothing.
+   * The `filter` still selects whole documents before the array is unwound,
+   * and no `groupBy` or `sums` path may contain the unwound array.
    */
-  sums?: ReadonlyArray<TSmartdataNumericDocumentPath<T>>;
+  unwind?: TUnwind;
+  /**
+   * Declared numeric top-level fields, or declared nested paths holding
+   * numbers, to sum per group.
+   */
+  sums?: ReadonlyArray<
+    TSmartdataNumericDocumentPath<T> | TSmartdataAtomicNestedDocumentPath<T>
+  >;
   filter?: MongoFilter<T>;
   /**
    * Required bound on the number of returned groups (1..10000). The group
@@ -807,18 +857,37 @@ export interface ISmartdataGroupedTotalsOptions<T> {
   session?: TSmartdataOrdinarySession;
 }
 
-export interface ISmartdataGroupedTotalsRow<T> {
+export interface ISmartdataGroupedTotalsRow<
+  T,
+  TUnwind extends TSmartdataGroupedTotalsUnwindPath<T> = never,
+> {
   /**
-   * The group's key values. Documents missing a group field and documents
-   * holding an explicit null merge into one group reported as null.
+   * The group's key values, keyed by the `groupBy` paths as given. Documents
+   * missing a group path and documents holding an explicit null merge into
+   * one group reported as null. An unwound top-level array reports the
+   * element; nested paths report the stored value untyped.
    */
-  group: { [TKey in TSmartdataDocumentPath<T>]?: T[TKey] | null };
+  group:
+    & {
+      [TKey in TSmartdataDocumentPath<T>]?:
+        | (TKey extends TUnwind ? TSmartdataAtomicArrayElement<T[TKey]> : T[TKey])
+        | null;
+    }
+    & Partial<Record<TSmartdataAtomicNestedDocumentPath<T>, unknown>>;
   count: number;
-  sums: Partial<Record<TSmartdataNumericDocumentPath<T>, number>>;
+  sums: Partial<
+    Record<
+      TSmartdataNumericDocumentPath<T> | TSmartdataAtomicNestedDocumentPath<T>,
+      number
+    >
+  >;
 }
 
-export interface ISmartdataGroupedTotalsPage<T> {
-  rows: Array<ISmartdataGroupedTotalsRow<T>>;
+export interface ISmartdataGroupedTotalsPage<
+  T,
+  TUnwind extends TSmartdataGroupedTotalsUnwindPath<T> = never,
+> {
+  rows: Array<ISmartdataGroupedTotalsRow<T, TUnwind>>;
   hasMore: boolean;
 }
 
@@ -830,12 +899,19 @@ export type TSmartdataAtomicArrayPath<T> = {
 type TSmartdataAtomicArrayElement<TValue> =
   NonNullable<TValue> extends ReadonlyArray<infer TElement> ? TElement : never;
 
-type TSmartdataAtomicArrayOperation<T> = Partial<{
-  [TKey in TSmartdataAtomicArrayPath<T>]: TSmartdataAtomicArrayElement<T[TKey]>;
-}>;
+/**
+ * Array operators take a declared top-level array field, typed by its element,
+ * or a nested path below a declared field. A nested path is accepted at run
+ * time only when the model declares it through `@svDb({ arrayPaths })`.
+ */
+type TSmartdataAtomicArrayOperation<T> =
+  & Partial<{
+    [TKey in TSmartdataAtomicArrayPath<T>]: TSmartdataAtomicArrayElement<T[TKey]>;
+  }>
+  & Partial<Record<TSmartdataAtomicNestedDocumentPath<T>, unknown>>;
 
-type TSmartdataAtomicPullScalar<TValue> = Extract<
-  TValue,
+/** The scalar equality operands `$pull` accepts. */
+type TSmartdataAtomicPullScalarValue =
   | string
   | number
   | boolean
@@ -847,14 +923,22 @@ type TSmartdataAtomicPullScalar<TValue> = Extract<
   | plugins.mongodb.Long
   | plugins.mongodb.Int32
   | plugins.mongodb.Double
-  | plugins.mongodb.Timestamp
+  | plugins.mongodb.Timestamp;
+
+type TSmartdataAtomicPullScalar<TValue> = Extract<
+  TValue,
+  TSmartdataAtomicPullScalarValue
 >;
 
-type TSmartdataAtomicArrayPullOperation<T> = Partial<{
-  [TKey in TSmartdataAtomicArrayPath<T>]: TSmartdataAtomicPullScalar<
-    TSmartdataAtomicArrayElement<T[TKey]>
+type TSmartdataAtomicArrayPullOperation<T> =
+  & Partial<{
+    [TKey in TSmartdataAtomicArrayPath<T>]: TSmartdataAtomicPullScalar<
+      TSmartdataAtomicArrayElement<T[TKey]>
+    >;
+  }>
+  & Partial<
+    Record<TSmartdataAtomicNestedDocumentPath<T>, TSmartdataAtomicPullScalarValue>
   >;
-}>;
 
 export interface ISmartdataAtomicUpdate<T> {
   $set?: TSmartdataAtomicSet<T>;
@@ -876,19 +960,21 @@ export interface ISmartdataAtomicUpdate<T> {
   $min?: TSmartdataAtomicMonotonic<T>;
   $setOnInsert?: TSmartdataAtomicSet<T>;
   /**
-   * Appends one element to a declared top-level array field. Modifier
-   * documents ($each, $position, $slice, $sort) are rejected.
+   * Appends one element to a declared top-level array field or a nested
+   * path declared through `@svDb({ arrayPaths })`. Modifier documents
+   * ($each, $position, $slice, $sort) are rejected.
    */
   $push?: TSmartdataAtomicArrayOperation<T>;
   /**
-   * Adds one element to a declared top-level array field unless an equal
-   * element is already present. Modifier documents are rejected.
+   * Adds one element to a declared top-level array field or a declared
+   * nested array path unless an equal element is already present. Modifier
+   * documents are rejected.
    */
   $addToSet?: TSmartdataAtomicArrayOperation<T>;
   /**
    * Removes every element equal to a scalar operand from a declared
-   * top-level array field. Operator documents, plain objects, arrays, and
-   * regular expressions are rejected.
+   * top-level array field or a declared nested array path. Operator
+   * documents, plain objects, arrays, and regular expressions are rejected.
    */
   $pull?: TSmartdataAtomicArrayPullOperation<T>;
 }
@@ -3051,6 +3137,8 @@ const normalizeAtomicUpdate = <T>(
   updateArg: ISmartdataAtomicUpdate<T>,
   declaredRootsArg: Set<string>,
   declaredNestedPathsArg: Set<string>,
+  /** Nested paths declared through `@svDb({ arrayPaths })`; array operators may target them. */
+  declaredArrayPathsArg: Set<string>,
   uniqueRootsArg: Set<string>,
   serializedRootsArg: Set<string>,
   /**
@@ -3164,10 +3252,13 @@ const normalizeAtomicUpdate = <T>(
       }
       occupiedPaths.push({ path, operator });
       if (arrayOperators.has(operator)) {
-        if (path !== root) {
+        if (path !== root && !declaredArrayPathsArg.has(path)) {
+          // The shape of a nested value is known only from its declaration, so
+          // a nested path that is not declared as an array is refused rather
+          // than left to fail on the stored value.
           throw new SmartdataPersistenceError(
             'invalid_argument',
-            `${operator} may only target declared top-level array fields; "${path}" is a nested path.`,
+            `${operator} may only target a declared top-level array field or a nested path declared through @svDb({ arrayPaths }); "${path}" is not a declared array path.`,
           );
         }
         if (value === undefined) {
@@ -3903,21 +3994,41 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     return keySets;
   }
 
+  /**
+   * Every nested path the model declares below a persisted field, through
+   * `@svDb({ atomicPaths })` or `@svDb({ arrayPaths })`.
+   */
   private static getDeclaredAtomicPaths(): Set<string> {
+    return new Set([
+      ...(this as any).readDeclaredNestedPaths('atomicPaths') as Set<string>,
+      ...(this as any).readDeclaredNestedPaths('arrayPaths') as Set<string>,
+    ]);
+  }
+
+  /** The nested paths declared through `@svDb({ arrayPaths })` as holding arrays. */
+  private static getDeclaredArrayPaths(): Set<string> {
+    return (this as any).readDeclaredNestedPaths('arrayPaths') as Set<string>;
+  }
+
+  private static readDeclaredNestedPaths(
+    declarationArg: 'atomicPaths' | 'arrayPaths',
+  ): Set<string> {
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
     const uniqueRoots = (this as any).getDeclaredUniqueRoots() as Set<string>;
     const options = (this as any)._svDbOptions as
       | Record<string, SvDbOptions>
       | undefined;
-    const atomicPaths = new Set<string>();
+    const label = declarationArg === 'atomicPaths' ? 'Atomic' : 'Array';
+    const nestedPaths = new Set<string>();
     for (const [root, fieldOptions] of Object.entries(options || {})) {
-      if (fieldOptions.atomicPaths === undefined) {
+      const relativePaths = fieldOptions[declarationArg];
+      if (relativePaths === undefined) {
         continue;
       }
-      if (!Array.isArray(fieldOptions.atomicPaths)) {
+      if (!Array.isArray(relativePaths)) {
         throw new SmartdataPersistenceError(
           'invalid_configuration',
-          `Atomic paths for persisted field "${root}" must be an array.`,
+          `${label} paths for persisted field "${root}" must be an array.`,
         );
       }
       if (
@@ -3926,20 +4037,20 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       ) {
         throw new SmartdataPersistenceError(
           'invalid_configuration',
-          `Serialized persisted field "${root}" may not declare atomic nested paths.`,
+          `Serialized persisted field "${root}" may not declare ${label.toLowerCase()} nested paths.`,
         );
       }
       if (uniqueRoots.has(root)) {
         throw new SmartdataPersistenceError(
           'invalid_configuration',
-          `Immutable @unI() field "${root}" may not declare atomic nested paths.`,
+          `Immutable @unI() field "${root}" may not declare ${label.toLowerCase()} nested paths.`,
         );
       }
-      for (const relativePath of fieldOptions.atomicPaths) {
+      for (const relativePath of relativePaths) {
         if (typeof relativePath !== 'string' || relativePath.length === 0) {
           throw new SmartdataPersistenceError(
             'invalid_configuration',
-            `Atomic paths for persisted field "${root}" must be non-empty strings.`,
+            `${label} paths for persisted field "${root}" must be non-empty strings.`,
           );
         }
         const fullPath = `${root}.${relativePath}`;
@@ -3947,20 +4058,20 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
           requireDeclaredPath(
             fullPath,
             declaredRoots,
-            'Atomic path declaration',
+            `${label} path declaration`,
             new Set([fullPath]),
           );
         } catch (errorArg) {
           throw new SmartdataPersistenceError(
             'invalid_configuration',
-            `Atomic path declaration "${fullPath}" is invalid.`,
+            `${label} path declaration "${fullPath}" is invalid.`,
             { cause: errorArg },
           );
         }
-        atomicPaths.add(fullPath);
+        nestedPaths.add(fullPath);
       }
     }
-    return atomicPaths;
+    return nestedPaths;
   }
 
   private static getSerializedPersistedRoots(): Set<string> {
@@ -4297,6 +4408,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     }
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
     const declaredAtomicPaths = (this as any).getDeclaredAtomicPaths() as Set<string>;
+    const declaredArrayPaths = (this as any).getDeclaredArrayPaths() as Set<string>;
     const identityValueTypes = (this as any).getDeclaredIdentityValueTypes() as Map<
       string,
       TSmartdataIdentityValueType
@@ -4332,6 +4444,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       updateArg,
       declaredRoots,
       declaredAtomicPaths,
+      declaredArrayPaths,
       uniqueRoots,
       serializedRoots,
       upserting ? { identityValueTypes } : undefined,
@@ -4407,6 +4520,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     const policy = getOrdinaryPersistencePolicy(this);
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
     const declaredAtomicPaths = (this as any).getDeclaredAtomicPaths() as Set<string>;
+    const declaredArrayPaths = (this as any).getDeclaredArrayPaths() as Set<string>;
     const identityValueTypes = (this as any).getDeclaredIdentityValueTypes() as Map<
       string,
       TSmartdataIdentityValueType
@@ -4433,6 +4547,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       updateArg,
       declaredRoots,
       declaredAtomicPaths,
+      declaredArrayPaths,
       uniqueRoots,
       serializedRoots,
       normalizedOptions.upsert ? { identityValueTypes } : undefined,
@@ -4763,6 +4878,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     const timeoutMS = requireBoundedInteger(opts?.timeoutMS, 'Atomic update-many timeoutMS', 120_000);
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
     const declaredAtomicPaths = (this as any).getDeclaredAtomicPaths() as Set<string>;
+    const declaredArrayPaths = (this as any).getDeclaredArrayPaths() as Set<string>;
     const uniqueRoots = (this as any).getDeclaredUniqueRoots() as Set<string>;
     const identityValueTypes = (this as any).getDeclaredIdentityValueTypes() as Map<
       string,
@@ -4783,6 +4899,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       updateArg,
       declaredRoots,
       declaredAtomicPaths,
+      declaredArrayPaths,
       uniqueRoots,
       serializedRoots,
     );
@@ -4873,6 +4990,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     );
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
     const declaredAtomicPaths = (this as any).getDeclaredAtomicPaths() as Set<string>;
+    const declaredArrayPaths = (this as any).getDeclaredArrayPaths() as Set<string>;
     const identityValueTypes = (this as any).getDeclaredIdentityValueTypes() as Map<
       string,
       TSmartdataIdentityValueType
@@ -4921,6 +5039,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         operation.update as ISmartdataAtomicUpdate<T>,
         declaredRoots,
         declaredAtomicPaths,
+        declaredArrayPaths,
         uniqueRoots,
         serializedRoots,
         { identityValueTypes },
@@ -4976,18 +5095,25 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
 
   /**
    * Computes bounded grouped counts and optional numeric sums server-side.
-   * Groups by one or two declared top-level fields, always returns a `count`
-   * per group, and sums only declared numeric fields. The `$limit` follows
-   * the group stage without a sort, so when more groups exist than the limit
-   * the returned subset is arbitrary. Use `getGroupedTotalsPage()` when the
-   * caller must detect overflow. The aggregation cursor never leaves SmartData.
+   * Groups by one or two declared paths — top-level fields or nested paths
+   * declared through `@svDb({ atomicPaths })` or `@svDb({ arrayPaths })` —
+   * optionally per element of one declared array (`unwind`), whose element
+   * fields `groupBy` and `sums` may then name, always returns a `count` per
+   * group, and sums only declared numeric paths. The
+   * `$limit` follows the group stage without a sort, so when more groups
+   * exist than the limit the returned subset is arbitrary. Use
+   * `getGroupedTotalsPage()` when the caller must detect overflow. The
+   * aggregation cursor never leaves SmartData.
    */
-  public static async getGroupedTotals<T>(
+  public static async getGroupedTotals<
+    T,
+    TUnwind extends TSmartdataGroupedTotalsUnwindPath<T> = never,
+  >(
     this: plugins.tsclass.typeFest.Class<T>,
-    optionsArg: ISmartdataGroupedTotalsOptions<T>,
-  ): Promise<Array<ISmartdataGroupedTotalsRow<T>>> {
+    optionsArg: ISmartdataGroupedTotalsOptions<T, TUnwind>,
+  ): Promise<Array<ISmartdataGroupedTotalsRow<T, TUnwind>>> {
     const page = await (this as any).getGroupedTotalsPage(optionsArg) as
-      ISmartdataGroupedTotalsPage<T>;
+      ISmartdataGroupedTotalsPage<T, TUnwind>;
     return page.rows;
   }
 
@@ -4996,10 +5122,13 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
    * reports whether at least one additional group exists beyond the requested
    * row limit.
    */
-  public static async getGroupedTotalsPage<T>(
+  public static async getGroupedTotalsPage<
+    T,
+    TUnwind extends TSmartdataGroupedTotalsUnwindPath<T> = never,
+  >(
     this: plugins.tsclass.typeFest.Class<T>,
-    optionsArg: ISmartdataGroupedTotalsOptions<T>,
-  ): Promise<ISmartdataGroupedTotalsPage<T>> {
+    optionsArg: ISmartdataGroupedTotalsOptions<T, TUnwind>,
+  ): Promise<ISmartdataGroupedTotalsPage<T, TUnwind>> {
     if ((this as any)[exactPersistencePolicySymbol]) {
       throw new SmartdataPersistenceError(
         'unsupported_operation',
@@ -5019,6 +5148,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     }
     const allowedKeys = new Set([
       'groupBy',
+      'unwind',
       'sums',
       'filter',
       'limit',
@@ -5047,6 +5177,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       }
     }
     const groupByOption = optionsArg.groupBy;
+    const unwindOption = optionsArg.unwind;
     const sumsOption = optionsArg.sums;
     const filterOption = optionsArg.filter;
     const limitOption = optionsArg.limit;
@@ -5059,6 +5190,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     signalOption?.throwIfAborted();
     const sessionOption = optionsArg.session;
     const declaredRoots = (this as any).getDeclaredPersistedRoots() as Set<string>;
+    const declaredNestedPaths = (this as any).getDeclaredAtomicPaths() as Set<string>;
     const serializedRoots = (this as any).getSerializedPersistedRoots() as Set<string>;
     const requireDeclaredGroupField = (
       fieldArg: unknown,
@@ -5067,23 +5199,22 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       if (typeof fieldArg !== 'string') {
         throw new SmartdataPersistenceError(
           'invalid_argument',
-          `${labelArg} must name a declared top-level field.`,
-        );
-      }
-      const root = requireDeclaredPath(fieldArg, declaredRoots, labelArg);
-      if (root !== fieldArg) {
-        throw new SmartdataPersistenceError(
-          'invalid_argument',
-          `${labelArg} must name a declared top-level field, not a nested path.`,
+          `${labelArg} must name a declared top-level field or a declared nested path.`,
         );
       }
+      const root = requireDeclaredPath(
+        fieldArg,
+        declaredRoots,
+        labelArg,
+        declaredNestedPaths,
+      );
       if (serializedRoots.has(root)) {
         throw new SmartdataPersistenceError(
           'unsupported_operation',
           `${labelArg} cannot target serialized field "${root}".`,
         );
       }
-      return root;
+      return fieldArg;
     };
     if (
       !Array.isArray(groupByOption)
@@ -5101,11 +5232,14 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     if (
       groupByFields.length < 1
       || groupByFields.length > 2
-      || new Set(groupByFields).size !== groupByFields.length
+      || (
+        groupByFields.length === 2
+        && pathsConflict(groupByFields[0], groupByFields[1])
+      )
     ) {
       throw new SmartdataPersistenceError(
         'invalid_argument',
-        'Grouped totals groupBy fields must be one or two distinct fields.',
+        'Grouped totals groupBy fields must be one or two distinct fields, neither nested in the other.',
       );
     }
     if (sumsOption !== undefined && !Array.isArray(sumsOption)) {
@@ -5123,6 +5257,53 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         'Grouped totals sum fields must be distinct.',
       );
     }
+    let unwindField: string | undefined;
+    if (unwindOption !== undefined) {
+      if (typeof unwindOption !== 'string') {
+        throw new SmartdataPersistenceError(
+          'invalid_argument',
+          'Grouped totals unwind must name a declared array path.',
+        );
+      }
+      requireDeclaredGroupField(unwindOption, 'Grouped totals unwind path');
+      const aggregatedFields = [...groupByFields, ...sumFields];
+      // The unwound array either is a groupBy or sum path, or holds the
+      // element fields a groupBy or sum path names below it.
+      if (
+        !aggregatedFields.some((fieldArg) =>
+          fieldArg === unwindOption || fieldArg.startsWith(unwindOption + '.'),
+        )
+      ) {
+        throw new SmartdataPersistenceError(
+          'invalid_argument',
+          'Grouped totals unwind must name a groupBy or sum path, or the array holding one of them.',
+        );
+      }
+      // A path that contains the unwound array would read a document whose
+      // array has been replaced by one element: neither the document's value
+      // nor the element's.
+      const containingField = aggregatedFields.find((fieldArg) =>
+        unwindOption.startsWith(fieldArg + '.'),
+      );
+      if (containingField !== undefined) {
+        throw new SmartdataPersistenceError(
+          'invalid_argument',
+          `Grouped totals path "${containingField}" contains the unwound array "${unwindOption}".`,
+        );
+      }
+      if (
+        unwindOption.includes('.')
+        && !((this as any).getDeclaredArrayPaths() as Set<string>).has(unwindOption)
+      ) {
+        // A nested value's shape is known only from its declaration; unwinding
+        // a path not declared as an array would count scalars as elements.
+        throw new SmartdataPersistenceError(
+          'invalid_argument',
+          `Grouped totals unwind path "${unwindOption}" is not declared through @svDb({ arrayPaths }).`,
+        );
+      }
+      unwindField = unwindOption;
+    }
     const limit = requireBoundedInteger(
       limitOption,
       'Grouped totals limit',
@@ -5154,11 +5335,17 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         + `call, such as groupBy: ["${groupByFields[0]}"].`,
       );
     }
+    // A composite key names its members by position: a group path may be
+    // dotted, and an expression object's field names may not contain a dot.
+    const compositeKeyName = (indexArg: number): string => 'k' + indexArg;
     const groupStage: Record<string, unknown> = {
       _id: groupByFields.length === 1
         ? '$' + groupByFields[0]
         : Object.fromEntries(
-            groupByFields.map((fieldArg) => [fieldArg, '$' + fieldArg]),
+            groupByFields.map((fieldArg, indexArg) => [
+              compositeKeyName(indexArg),
+              '$' + fieldArg,
+            ]),
           ),
       __groupedTotalsCount: { $sum: 1 },
     };
@@ -5176,6 +5363,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         ...(maxTimeMS !== undefined ? { maxTimeMS } : {}),
         ...(timeoutMS !== undefined ? { timeoutMS } : {}),
         ...(signalOption !== undefined ? { signal: signalOption } : {}),
+        ...(unwindField !== undefined ? { unwindPath: unwindField } : {}),
       },
     );
     const hasMore = rows.length > limit;
@@ -5198,10 +5386,10 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         group[groupByFields[0]] = rowArg._id ?? null;
       } else {
         const compoundKey = (rowArg._id ?? {}) as Record<string, unknown>;
-        for (const fieldArg of groupByFields) {
+        for (const [index, fieldArg] of groupByFields.entries()) {
           // Missing and explicit-null values merge into one group that is
           // reported as null in both the single-field and compound shapes.
-          group[fieldArg] = compoundKey[fieldArg] ?? null;
+          group[fieldArg] = compoundKey[compositeKeyName(index)] ?? null;
         }
       }
       const sums: Record<string, number> = {};
@@ -5218,7 +5406,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
           'Grouped totals count',
         ),
         sums,
-      } as ISmartdataGroupedTotalsRow<T>;
+      } as ISmartdataGroupedTotalsRow<T, TUnwind>;
     });
     return {
       rows: mappedRows,