grafeo-ogm 2.5.2 → 2.5.4

package/dist/cjs/compilers/selection.compiler.d.ts

@@ -58,6 +58,23 @@ export interface SelectionNode {
      * can't honour them throw instead of dropping them.
      */
     hasArguments?: boolean;
+    /**
+     * v2.5.3 — the same response key selected on DIFFERENT fields by sibling
+     * inline fragments (`... on A { x: title } ... on B { x: body }`): the
+     * field each fragment type selected. Projected as a per-type CASE.
+     */
+    fieldByType?: Record<string, string>;
+    /**
+     * Connection only (v2.5.3): selectionSet aliases of the connection's own
+     * keys. Pre-2.5.3 they were ignored and the keys always came back as
+     * `edges`, `node`, `properties` and `totalCount`.
+     */
+    connectionAliases?: {
+        totalCount?: string;
+        edges?: string;
+        node?: string;
+        properties?: string;
+    };
 }
 /**
  * Compiles a selection set (parsed SelectionNode[]) into a Cypher RETURN map projection.
@@ -132,8 +149,22 @@ export declare class SelectionCompiler {
      * when the abstract type declares the field as `@cypher` itself, when a
      * condition isn't a concrete type, or when no fragment type declares it
      * as `@cypher`.
+     *
+     * v2.5.4 — under a policy context, each `@cypher` branch is also guarded
+     * by that member's own `read` clause (`WHEN n:B AND <B read> THEN …`),
+     * so a member's statement only projects for a node that passes the
+     * member's policy. The node filter (`compileTargetPolicyClause`) already
+     * requires every carried member's clause; this is defense in depth.
+     * Without a policy context the branches are unchanged.
      */
     private compileFragmentScalar;
+    /**
+     * ` AND <member read clause>` guarding a fragment `@cypher` branch
+     * (v2.5.4); `''` without a policy context, when the member has no read
+     * clause, or when that clause needs `@cypher` preludes a projection
+     * cannot host (the node filter still enforces it).
+     */
+    private memberReadGuard;
     /**
      * Parse a GraphQL selection set string into SelectionNode[].
      *
@@ -149,6 +180,22 @@ export declare class SelectionCompiler {
      * Parse the children of a connection field, extracting node and edge children.
      */
     private parseConnectionChildren;
+    /**
+     * Keep the selectionSet alias of a connection key (v2.5.3). The first
+     * alias given for a key wins.
+     */
+    private recordConnectionAlias;
+    /**
+     * Compile a relationship or connection field selected through inline
+     * fragments on an abstract type that does not declare it (v2.5.3):
+     * `CASE WHEN n:D THEN <D's projection> … END`, each branch compiled
+     * against the implementer — with its arguments and the target type's
+     * read policy. Pre-2.5.3 the field was looked up on the abstract type,
+     * not found, and silently dropped together with its arguments.
+     *
+     * Returns `null` (unchanged behaviour) when no fragment type declares it.
+     */
+    private compileFragmentRelationship;
     /**
      * Compile a relationship field into a Cypher pattern comprehension.
      */

package/dist/cjs/compilers/selection.compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.compiler.d.ts","sourceRoot":"","sources":["../../../src/compilers/selection.compiler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"selection.compiler.d.ts","sourceRoot":"","sources":["../../../src/compilers/selection.compiler.ts"],"names":[],"mappings":"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"}

package/dist/cjs/compilers/selection.compiler.js

@@ -8,6 +8,92 @@ const utils_1 = require("../schema/utils");
 const cypher_field_projection_1 = require("../utils/cypher-field-projection");
 const validation_1 = require("../utils/validation");
 const where_compiler_1 = require("./where.compiler");
+/**
+ * v2.5.3 — the printed arguments of a parsed selectionSet field, so a
+ * response key selected twice merges its sub-selections only when both
+ * selections carry the same arguments.
+ */
+const argumentKeys = new WeakMap();
+function sameArguments(a, b) {
+    return (argumentKeys.get(a) ?? '') === (argumentKeys.get(b) ?? '');
+}
+/**
+ * Merge `incoming` into `list` by response key (v2.5.3), as GraphQL merges
+ * a field selected more than once: sub-selections are unioned. Pre-2.5.3
+ * the second selection of a key was dropped with its sub-fields.
+ *
+ * - Same field, same arguments: children, edge children and `totalCount`
+ *   merge recursively.
+ * - Same field, different arguments: the first selection wins (unchanged).
+ * - Different fields under one key, each selected by inline fragments on
+ *   different types: recorded in `fieldByType` for a per-type projection.
+ * - A selection outside any fragment makes the field unconditional.
+ */
+function mergeSelection(list, seen, incoming) {
+    const key = incoming.alias ?? incoming.fieldName;
+    const existing = seen.get(key);
+    if (!existing) {
+        seen.set(key, incoming);
+        list.push(incoming);
+        return;
+    }
+    if (existing.fieldName !== incoming.fieldName || existing.fieldByType) {
+        mergeFragmentField(existing, incoming);
+        return;
+    }
+    if (existing.typeConditions && incoming.typeConditions)
+        existing.typeConditions = [
+            ...new Set([...existing.typeConditions, ...incoming.typeConditions]),
+        ];
+    // Also selected outside any fragment → unconditional.
+    else
+        delete existing.typeConditions;
+    if (!sameArguments(existing, incoming))
+        return;
+    if (incoming.children)
+        existing.children = mergeSelectionLists(existing.children, incoming.children);
+    if (incoming.edgeChildren)
+        existing.edgeChildren = mergeSelectionLists(existing.edgeChildren, incoming.edgeChildren);
+    if (existing.isConnection) {
+        if (incoming.totalCount)
+            existing.totalCount = true;
+        if (existing.totalCountOnly && !incoming.totalCountOnly)
+            delete existing.totalCountOnly;
+        if (incoming.connectionAliases)
+            existing.connectionAliases = {
+                ...incoming.connectionAliases,
+                ...existing.connectionAliases,
+            };
+    }
+}
+/** Two scalars under one key, from fragments on different types (v2.5.3). */
+function mergeFragmentField(existing, incoming) {
+    // Only scalars selected by inline fragments can differ per type; any
+    // other clash keeps the first selection (unchanged).
+    if (!existing.isScalar ||
+        !incoming.isScalar ||
+        !existing.typeConditions ||
+        !incoming.typeConditions)
+        return;
+    const byType = existing.fieldByType ?? {};
+    if (!existing.fieldByType)
+        for (const t of existing.typeConditions)
+            byType[t] = existing.fieldName;
+    for (const t of incoming.typeConditions)
+        if (byType[t] === undefined)
+            byType[t] = incoming.fieldName;
+    existing.fieldByType = byType;
+    existing.typeConditions = [
+        ...new Set([...existing.typeConditions, ...incoming.typeConditions]),
+    ];
+}
+function mergeSelectionLists(base, extra) {
+    const list = [];
+    const seen = new Map();
+    for (const node of [...(base ?? []), ...extra])
+        mergeSelection(list, seen, node);
+    return list;
+}
 /** selectionSet field arguments the OGM honours, by field kind (v2.5.0). */
 const RELATIONSHIP_ARGUMENTS = new Set(['where', 'options']);
 const CONNECTION_ARGUMENTS = new Set(['where']);
@@ -202,7 +288,7 @@ class SelectionCompiler {
                 }
                 (0, validation_1.assertSafeIdentifier)(node.fieldName, 'selection field');
                 if (isAbstract && node.typeConditions) {
-                    const conditional = this.compileFragmentScalar(node, key, nodeVar, nodeDef, cypherScope);
+                    const conditional = this.compileFragmentScalar(node, key, nodeVar, nodeDef, cypherScope, params, paramCounter, policyContext);
                     if (conditional) {
                         parts.push(conditional);
                         continue;
@@ -229,6 +315,21 @@ class SelectionCompiler {
                     : `.${(0, validation_1.escapeIdentifier)(node.fieldName)}`);
                 continue;
             }
+            // v2.5.3 — a relationship / connection field selected through an
+            // inline fragment on an abstract type that doesn't declare it.
+            // (Union relationship fields keep their per-member CASE below.)
+            if (isAbstract &&
+                node.typeConditions &&
+                (node.isConnection || !(unionMembers && unionMembers.length > 0)) &&
+                !nodeDef.relationships.has(node.isConnection
+                    ? node.fieldName.replace(/Connection$/, '')
+                    : node.fieldName)) {
+                const fragmentCypher = this.compileFragmentRelationship(node, nodeVar, maxDepth, currentDepth, params, paramCounter, policyContext);
+                if (fragmentCypher) {
+                    parts.push(`${key}: ${fragmentCypher}`);
+                    continue;
+                }
+            }
             if (node.isConnection) {
                 const connectionCypher = this.compileConnection(node, nodeVar, nodeDef, maxDepth, currentDepth, params, paramCounter, policyContext);
                 if (connectionCypher)
@@ -263,33 +364,64 @@ class SelectionCompiler {
      * when the abstract type declares the field as `@cypher` itself, when a
      * condition isn't a concrete type, or when no fragment type declares it
      * as `@cypher`.
+     *
+     * v2.5.4 — under a policy context, each `@cypher` branch is also guarded
+     * by that member's own `read` clause (`WHEN n:B AND <B read> THEN …`),
+     * so a member's statement only projects for a node that passes the
+     * member's policy. The node filter (`compileTargetPolicyClause`) already
+     * requires every carried member's clause; this is defense in depth.
+     * Without a policy context the branches are unchanged.
      */
-    compileFragmentScalar(node, key, nodeVar, nodeDef, cypherScope) {
-        if (nodeDef.properties.get(node.fieldName)?.isCypher)
+    compileFragmentScalar(node, key, nodeVar, nodeDef, cypherScope, params, paramCounter, policyContext = null) {
+        // v2.5.3 — `fieldByType`: sibling fragments selected different fields
+        // under this key, so each type projects its own field.
+        const perType = node.fieldByType;
+        if (!perType && nodeDef.properties.get(node.fieldName)?.isCypher)
             return null;
         const members = [];
         for (const typeName of node.typeConditions ?? []) {
             const def = this.schema.nodes.get(typeName);
             if (!def)
                 return null;
-            const prop = def.properties.get(node.fieldName);
+            const field = perType?.[typeName] ?? node.fieldName;
+            (0, validation_1.assertSafeIdentifier)(field, 'selection field');
+            const prop = def.properties.get(field);
             if (prop)
-                members.push({ def, prop });
+                members.push({ def, prop, field });
         }
-        if (!members.some((m) => m.prop.isCypher && m.prop.cypherStatement))
+        if (!perType &&
+            !members.some((m) => m.prop.isCypher && m.prop.cypherStatement))
             return null;
-        const branches = members.map(({ def, prop }) => {
+        const branches = members.map(({ def, prop, field }) => {
             let expr;
             if (prop.isCypher && prop.cypherStatement)
                 expr = cypherScope
-                    ? cypherScope.register(node.fieldName, prop, def.label)
-                    : (0, cypher_field_projection_1.buildInlineCypherFieldExpr)(prop.cypherStatement, nodeVar, `${def.typeName}.${node.fieldName}`);
+                    ? cypherScope.register(field, prop, def.label)
+                    : (0, cypher_field_projection_1.buildInlineCypherFieldExpr)(prop.cypherStatement, nodeVar, `${def.typeName}.${field}`);
             else
-                expr = `${nodeVar}.${(0, validation_1.escapeIdentifier)(node.fieldName)}`;
-            return `WHEN ${nodeVar}:${(0, validation_1.escapeIdentifier)(def.label)} THEN ${expr}`;
+                expr = `${nodeVar}.${(0, validation_1.escapeIdentifier)(field)}`;
+            const guard = prop.isCypher && prop.cypherStatement
+                ? this.memberReadGuard(def, nodeVar, params, paramCounter, policyContext)
+                : '';
+            return `WHEN ${nodeVar}:${(0, validation_1.escapeIdentifier)(def.label)}${guard} THEN ${expr}`;
         });
         return `${(0, validation_1.escapeIdentifier)(key)}: CASE ${branches.join(' ')} END`;
     }
+    /**
+     * ` AND <member read clause>` guarding a fragment `@cypher` branch
+     * (v2.5.4); `''` without a policy context, when the member has no read
+     * clause, or when that clause needs `@cypher` preludes a projection
+     * cannot host (the node filter still enforces it).
+     */
+    memberReadGuard(def, nodeVar, params, paramCounter, policyContext) {
+        if (!policyContext || !this.whereCompiler || !params || !paramCounter)
+            return '';
+        const clause = this.whereCompiler.compileTargetPolicyClause(def.typeName, nodeVar, 'read', policyContext, paramCounter);
+        if (clause.cypher === null || clause.preludes.length > 0)
+            return '';
+        (0, validation_1.mergeParams)(params, clause.params);
+        return ` AND ${clause.cypher}`;
+    }
     /**
      * Parse a GraphQL selection set string into SelectionNode[].
      *
@@ -351,23 +483,8 @@ class SelectionCompiler {
                 const fragment = sel;
                 const condition = fragment.typeCondition?.name.value ?? typeCondition;
                 if (fragment.selectionSet)
-                    for (const merged of this.convertSelectionSet(fragment.selectionSet, condition)) {
-                        const mergedKey = merged.alias ?? merged.fieldName;
-                        const existing = seen.get(mergedKey);
-                        if (!existing) {
-                            seen.set(mergedKey, merged);
-                            nodes.push(merged);
-                        }
-                        else if (existing.typeConditions)
-                            existing.typeConditions = merged.typeConditions
-                                ? [
-                                    ...new Set([
-                                        ...existing.typeConditions,
-                                        ...merged.typeConditions,
-                                    ]),
-                                ]
-                                : undefined;
-                    }
+                    for (const merged of this.convertSelectionSet(fragment.selectionSet, condition))
+                        mergeSelection(nodes, seen, merged);
                 continue;
             }
             if (sel.kind !== graphql_1.Kind.FIELD)
@@ -377,14 +494,9 @@ class SelectionCompiler {
             // v2.5.0 — fields are keyed by their OUTPUT name, so the same field
             // under two aliases (`a: kids { .. } b: kids { .. }`) stays two
             // selections. Pre-2.5.0 they collapsed into one.
-            const outputKey = field.alias?.value ?? fieldName;
-            const existing = seen.get(outputKey);
-            if (existing) {
-                // Also selected outside any fragment → unconditional.
-                if (typeCondition === undefined)
-                    delete existing.typeConditions;
-                continue;
-            }
+            // v2.5.3 — a key selected twice is merged (see `mergeSelection`);
+            // the repeat's arguments are compared, not re-validated.
+            const existing = seen.get(field.alias?.value ?? fieldName);
             const hasChildren = !!field.selectionSet;
             const isConnection = fieldName.endsWith('Connection');
             const node = {
@@ -396,16 +508,18 @@ class SelectionCompiler {
             };
             if (typeCondition !== undefined)
                 node.typeConditions = [typeCondition];
-            seen.set(outputKey, node);
-            if (field.arguments && field.arguments.length > 0)
-                applyFieldArguments(field, node);
+            if (field.arguments && field.arguments.length > 0) {
+                argumentKeys.set(node, field.arguments.map((a) => (0, graphql_1.print)(a)).join(','));
+                if (!existing)
+                    applyFieldArguments(field, node);
+            }
             if (hasChildren && field.selectionSet)
                 if (isConnection)
                     // For connections, parse edges -> node and edges -> properties
                     this.parseConnectionChildren(field.selectionSet, node);
                 else
                     node.children = this.convertSelectionSet(field.selectionSet);
-            nodes.push(node);
+            mergeSelection(nodes, seen, node);
         }
         return nodes;
     }
@@ -419,25 +533,81 @@ class SelectionCompiler {
                 continue;
             const field = sel;
             assertNoArguments(field, `${parentNode.fieldName}.${field.name.value}`);
-            if (field.name.value === 'totalCount')
+            if (field.name.value === 'totalCount') {
                 parentNode.totalCount = true;
-            if (field.name.value === 'edges')
+                this.recordConnectionAlias(parentNode, 'totalCount', field);
+            }
+            if (field.name.value === 'edges') {
                 selectsEdges = true;
+                this.recordConnectionAlias(parentNode, 'edges', field);
+            }
             if (field.name.value === 'edges' && field.selectionSet)
                 for (const edgeSel of field.selectionSet.selections) {
                     if (edgeSel.kind !== graphql_1.Kind.FIELD)
                         continue;
                     const edgeField = edgeSel;
                     assertNoArguments(edgeField, `${parentNode.fieldName}.edges.${edgeField.name.value}`);
-                    if (edgeField.name.value === 'node' && edgeField.selectionSet)
-                        parentNode.children = this.convertSelectionSet(edgeField.selectionSet);
-                    if (edgeField.name.value === 'properties' && edgeField.selectionSet)
-                        parentNode.edgeChildren = this.convertSelectionSet(edgeField.selectionSet);
+                    // v2.5.3 — a repeated `edges { node { … } }` merges its
+                    // sub-selections; pre-2.5.3 the last one replaced the others.
+                    if (edgeField.name.value === 'node' && edgeField.selectionSet) {
+                        this.recordConnectionAlias(parentNode, 'node', edgeField);
+                        parentNode.children = mergeSelectionLists(parentNode.children, this.convertSelectionSet(edgeField.selectionSet));
+                    }
+                    if (edgeField.name.value === 'properties' && edgeField.selectionSet) {
+                        this.recordConnectionAlias(parentNode, 'properties', edgeField);
+                        parentNode.edgeChildren = mergeSelectionLists(parentNode.edgeChildren, this.convertSelectionSet(edgeField.selectionSet));
+                    }
                 }
         }
         if (parentNode.totalCount && !selectsEdges)
             parentNode.totalCountOnly = true;
     }
+    /**
+     * Keep the selectionSet alias of a connection key (v2.5.3). The first
+     * alias given for a key wins.
+     */
+    recordConnectionAlias(node, key, field) {
+        var _a;
+        const alias = field.alias?.value;
+        if (alias === undefined || alias === key)
+            return;
+        (0, validation_1.assertSafeIdentifier)(alias, 'selection alias');
+        node.connectionAliases ?? (node.connectionAliases = {});
+        (_a = node.connectionAliases)[key] ?? (_a[key] = alias);
+    }
+    /**
+     * Compile a relationship or connection field selected through inline
+     * fragments on an abstract type that does not declare it (v2.5.3):
+     * `CASE WHEN n:D THEN <D's projection> … END`, each branch compiled
+     * against the implementer — with its arguments and the target type's
+     * read policy. Pre-2.5.3 the field was looked up on the abstract type,
+     * not found, and silently dropped together with its arguments.
+     *
+     * Returns `null` (unchanged behaviour) when no fragment type declares it.
+     */
+    compileFragmentRelationship(node, nodeVar, maxDepth, currentDepth, params, paramCounter, policyContext = null) {
+        const relField = node.isConnection
+            ? node.fieldName.replace(/Connection$/, '')
+            : node.fieldName;
+        const branches = [];
+        let singular = node.isConnection;
+        for (const typeName of node.typeConditions ?? []) {
+            const def = this.schema.nodes.get(typeName);
+            const relDef = def?.relationships.get(relField);
+            if (!def || !relDef)
+                continue;
+            if (!relDef.isArray)
+                singular = true;
+            const expr = node.isConnection
+                ? this.compileConnection(node, nodeVar, def, maxDepth, currentDepth, params, paramCounter, policyContext)
+                : this.compileRelationship(node, nodeVar, def, maxDepth, currentDepth, params, paramCounter, policyContext);
+            if (expr)
+                branches.push(`WHEN ${nodeVar}:${(0, validation_1.escapeIdentifier)(def.label)} THEN ${expr}`);
+        }
+        if (branches.length === 0)
+            return null;
+        return `CASE ${branches.join(' ')} ELSE ${singular ? 'null' : '[]'} END`;
+    }
     /**
      * Compile a relationship field into a Cypher pattern comprehension.
      */
@@ -502,9 +672,15 @@ class SelectionCompiler {
             params[name] = (0, neo4j_driver_1.int)(value);
             return `$${name}`;
         };
-        const start = node.offset ?? 0;
+        // v2.5.3 — a list slice bound must fit in 32 bits (and a JS number
+        // past 2^63 overflows the driver's Integer). No list is that long, so
+        // clamping keeps the result; pre-2.5.3 the query failed.
+        const INT32_MAX = 2147483647;
+        const start = Math.min(node.offset ?? 0, INT32_MAX);
         const startRef = node.offset !== undefined ? bind(start) : '';
-        const endRef = node.limit !== undefined ? bind(start + node.limit) : '';
+        const endRef = node.limit !== undefined
+            ? bind(Math.min(start + node.limit, INT32_MAX))
+            : '';
         return `[${startRef}..${endRef}]`;
     }
     /**
@@ -632,20 +808,36 @@ class SelectionCompiler {
         });
         const mapParts = [];
         const projectionKeys = [];
+        // v2.5.3 — selectionSet aliases of the connection keys (validated when
+        // parsed); unaliased output is byte-identical.
+        const aliases = node.connectionAliases ?? {};
+        const nodeKey = aliases.node ? (0, validation_1.escapeIdentifier)(aliases.node) : 'node';
+        const propertiesKey = aliases.properties
+            ? (0, validation_1.escapeIdentifier)(aliases.properties)
+            : 'properties';
+        const edgesKey = aliases.edges ? (0, validation_1.escapeIdentifier)(aliases.edges) : 'edges';
+        const totalCountKey = aliases.totalCount
+            ? (0, validation_1.escapeIdentifier)(aliases.totalCount)
+            : 'totalCount';
         // Compile node projection
         if (node.children && node.children.length > 0) {
             const nodeProjection = this.compile(node.children, childVar, targetDef, maxDepth, currentDepth + 1, params, paramCounter, null, policyContext);
-            mapParts.push(`node: ${nodeProjection}`);
-            projectionKeys.push('node');
+            mapParts.push(`${nodeKey}: ${nodeProjection}`);
+            projectionKeys.push(nodeKey);
         }
         // Compile edge properties projection
         if (node.edgeChildren && node.edgeChildren.length > 0) {
             const edgeFields = node.edgeChildren
                 .filter((c) => c.isScalar)
-                .map((c) => `.${(0, validation_1.escapeIdentifier)(c.fieldName)}`)
+                .map((c) => {
+                if (c.alias === undefined || c.alias === c.fieldName)
+                    return `.${(0, validation_1.escapeIdentifier)(c.fieldName)}`;
+                (0, validation_1.assertSafeIdentifier)(c.alias, 'selection alias');
+                return `${(0, validation_1.escapeIdentifier)(c.alias)}: ${edgeVar}.${(0, validation_1.escapeIdentifier)(c.fieldName)}`;
+            })
                 .join(', ');
-            mapParts.push(`properties: ${edgeVar} { ${edgeFields} }`);
-            projectionKeys.push('properties');
+            mapParts.push(`${propertiesKey}: ${edgeVar} { ${edgeFields} }`);
+            projectionKeys.push(propertiesKey);
         }
         // Inject synthetic sort scalars at the top level of the edge map so
         // apoc.coll.sortMulti (which only accepts top-level keys) can order the
@@ -789,19 +981,19 @@ class SelectionCompiler {
         // (same pattern, same `where`, same target `read` policy), so it can
         // never count a node the caller cannot see. Pre-2.4.8 it was dropped.
         const totalCount = node.totalCount
-            ? `totalCount: size([${pattern}${whereClause} | 1])`
+            ? `${totalCountKey}: size([${pattern}${whereClause} | 1])`
             : '';
         if (node.totalCountOnly)
             return `{ ${totalCount} }`;
         const withTotal = totalCount ? `, ${totalCount}` : '';
         if (sortKeyTokens.length === 0)
-            return `{ edges: [${pattern}${whereClause} | ${innerMap}]${withTotal} }`;
+            return `{ ${edgesKey}: [${pattern}${whereClause} | ${innerMap}]${withTotal} }`;
         // Re-project only the user-facing keys so synthetic __skN scalars don't
         // leak out of the projection.
         const outerProjection = projectionKeys.length > 0
             ? `{ ${projectionKeys.map((k) => `${k}: x.${k}`).join(', ')} }`
             : `{}`;
-        return `{ edges: [x IN apoc.coll.sortMulti([${pattern}${whereClause} | ${innerMap}], [${sortKeyTokens.join(', ')}]) | ${outerProjection}]${withTotal} }`;
+        return `{ ${edgesKey}: [x IN apoc.coll.sortMulti([${pattern}${whereClause} | ${innerMap}], [${sortKeyTokens.join(', ')}]) | ${outerProjection}]${withTotal} }`;
     }
     /**
      * AND-combine an optional user where (`select.where` / `connectionWhere`)