@aws-amplify/datastore 4.7.6-api-v6-models.b3abc9b.0 → 5.0.0

package/lib-esm/predicates/next.js

@@ -1,16 +1,15 @@
-import { __assign, __asyncValues, __awaiter, __generator, __read, __spread, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { PredicateInternalsKey, } from '../types';
 import { ModelPredicateCreator as FlatModelPredicateCreator, comparisonKeys, } from './index';
 import { ModelRelationship } from '../storage/relationship';
 import { asyncSome, asyncEvery } from '../util';
-var ops = __spread(comparisonKeys);
+const ops = [...comparisonKeys];
 /**
  * A map from keys (exposed to customers) to the internal predicate data
  * structures invoking code should not muck with.
  */
-var predicateInternalsMap = new Map();
+const predicateInternalsMap = new Map();
 /**
  * Creates a link between a key (and generates a key if needed) and an internal
  * `GroupCondition`, which allows us to return a key object instead of the gory
@@ -20,8 +19,8 @@ var predicateInternalsMap = new Map();
  * @param key The object DataStore will use to find the internal condition.
  * If no key is given, an empty one is created.
  */
-var registerPredicateInternals = function (condition, key) {
-    var finalKey = key || new PredicateInternalsKey();
+const registerPredicateInternals = (condition, key) => {
+    const finalKey = key || new PredicateInternalsKey();
     predicateInternalsMap.set(finalKey, condition);
     return finalKey;
 };
@@ -36,7 +35,7 @@ var registerPredicateInternals = function (condition, key) {
  *
  * @param key A key object previously returned by `registerPredicateInternals()`
  */
-export var internals = function (key) {
+export const internals = (key) => {
     if (!predicateInternalsMap.has(key)) {
         throw new Error("Invalid predicate. Terminate your predicate with a valid condition (e.g., `p => p.field.eq('value')`) or pass `Predicates.ALL`.");
     }
@@ -46,7 +45,7 @@ export var internals = function (key) {
  * Maps operators to negated operators.
  * Used to facilitate propagation of negation down a tree of conditions.
  */
-var negations = {
+const negations = {
     and: 'or',
     or: 'and',
     not: 'and',
@@ -65,8 +64,8 @@ var negations = {
  * @member operator The equality or comparison operator to use.
  * @member operands The operands for the equality/comparison check.
  */
-var FieldCondition = /** @class */ (function () {
-    function FieldCondition(field, operator, operands) {
+export class FieldCondition {
+    constructor(field, operator, operands) {
         this.field = field;
         this.operator = operator;
         this.operands = operands;
@@ -77,12 +76,12 @@ var FieldCondition = /** @class */ (function () {
      * @param extract Not used. Present only to fulfill the `UntypedCondition` interface.
      * @returns A new, identitical `FieldCondition`.
      */
-    FieldCondition.prototype.copy = function (extract) {
+    copy(extract) {
         return [
-            new FieldCondition(this.field, this.operator, __spread(this.operands)),
+            new FieldCondition(this.field, this.operator, [...this.operands]),
             undefined,
         ];
-    };
+    }
     /**
      * Produces a tree structure similar to a graphql condition. The returned
      * structure is "dumb" and is intended for another query/condition
@@ -99,16 +98,15 @@ var FieldCondition = /** @class */ (function () {
      * }
      * ```
      */
-    FieldCondition.prototype.toAST = function () {
-        var _a, _b;
-        return _a = {},
-            _a[this.field] = (_b = {},
-                _b[this.operator] = this.operator === 'between'
+    toAST() {
+        return {
+            [this.field]: {
+                [this.operator]: this.operator === 'between'
                     ? [this.operands[0], this.operands[1]]
                     : this.operands[0],
-                _b),
-            _a;
-    };
+            },
+        };
+    }
     /**
      * Produces a new condition (`FieldCondition` or `GroupCondition`) that
      * matches the opposite of this condition.
@@ -125,7 +123,7 @@ var FieldCondition = /** @class */ (function () {
      * @param model The model meta to use when construction a new `GroupCondition`
      * for cases where the negation requires multiple `FieldCondition`'s.
      */
-    FieldCondition.prototype.negated = function (model) {
+    negated(model) {
         if (this.operator === 'between') {
             return new GroupCondition(model, undefined, undefined, 'or', [
                 new FieldCondition(this.field, 'lt', [this.operands[0]]),
@@ -143,77 +141,65 @@ var FieldCondition = /** @class */ (function () {
         else {
             return new FieldCondition(this.field, negations[this.operator], this.operands);
         }
-    };
+    }
     /**
      * Not implemented. Not needed. GroupCondition instead consumes FieldConditions and
      * transforms them into legacy predicates. (*For now.*)
      * @param storage N/A. If ever implemented, the storage adapter to query.
      * @returns N/A. If ever implemented, return items from `storage` that match.
      */
-    FieldCondition.prototype.fetch = function (storage) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.reject('No implementation needed [yet].')];
-            });
-        });
-    };
+    async fetch(storage) {
+        return Promise.reject('No implementation needed [yet].');
+    }
     /**
      * Determins whether a given item matches the expressed condition.
      * @param item The item to test.
      * @returns `Promise<boolean>`, `true` if matches; `false` otherwise.
      */
-    FieldCondition.prototype.matches = function (item) {
-        return __awaiter(this, void 0, void 0, function () {
-            var v, operations, operation, result;
-            var _this = this;
-            return __generator(this, function (_a) {
-                v = item[this.field];
-                operations = {
-                    eq: function () { return v === _this.operands[0]; },
-                    ne: function () { return v !== _this.operands[0]; },
-                    gt: function () { return v > _this.operands[0]; },
-                    ge: function () { return v >= _this.operands[0]; },
-                    lt: function () { return v < _this.operands[0]; },
-                    le: function () { return v <= _this.operands[0]; },
-                    contains: function () { return (v === null || v === void 0 ? void 0 : v.indexOf(_this.operands[0])) > -1; },
-                    notContains: function () { return (!v ? true : v.indexOf(_this.operands[0]) === -1); },
-                    beginsWith: function () { return v === null || v === void 0 ? void 0 : v.startsWith(_this.operands[0]); },
-                    between: function () { return v >= _this.operands[0] && v <= _this.operands[1]; },
-                };
-                operation = operations[this.operator];
-                if (operation) {
-                    result = operation();
-                    return [2 /*return*/, result];
-                }
-                else {
-                    throw new Error("Invalid operator given: " + this.operator);
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async matches(item) {
+        const v = item[this.field];
+        const operations = {
+            eq: () => v === this.operands[0],
+            ne: () => v !== this.operands[0],
+            gt: () => v > this.operands[0],
+            ge: () => v >= this.operands[0],
+            lt: () => v < this.operands[0],
+            le: () => v <= this.operands[0],
+            contains: () => v?.indexOf(this.operands[0]) > -1,
+            notContains: () => (!v ? true : v.indexOf(this.operands[0]) === -1),
+            beginsWith: () => v?.startsWith(this.operands[0]),
+            between: () => v >= this.operands[0] && v <= this.operands[1],
+        };
+        const operation = operations[this.operator];
+        if (operation) {
+            const result = operation();
+            return result;
+        }
+        else {
+            throw new Error(`Invalid operator given: ${this.operator}`);
+        }
+    }
     /**
      * Checks `this.operands` for compatibility with `this.operator`.
      */
-    FieldCondition.prototype.validate = function () {
-        var _this = this;
+    validate() {
         /**
          * Creates a validator that checks for a particular `operands` count.
          * Throws an exception if the `count` disagrees with `operands.length`.
          * @param count The number of `operands` expected.
          */
-        var argumentCount = function (count) {
-            var argsClause = count === 1 ? 'argument is' : 'arguments are';
-            return function () {
-                if (_this.operands.length !== count) {
-                    return "Exactly " + count + " " + argsClause + " required.";
+        const argumentCount = count => {
+            const argsClause = count === 1 ? 'argument is' : 'arguments are';
+            return () => {
+                if (this.operands.length !== count) {
+                    return `Exactly ${count} ${argsClause} required.`;
                 }
             };
         };
         // NOTE: validations should return a message on failure.
         // hence, they should be "joined" together with logical OR's
         // as seen in the `between:` entry.
-        var validations = {
+        const validations = {
             eq: argumentCount(1),
             ne: argumentCount(1),
             gt: argumentCount(1),
@@ -223,34 +209,30 @@ var FieldCondition = /** @class */ (function () {
             contains: argumentCount(1),
             notContains: argumentCount(1),
             beginsWith: argumentCount(1),
-            between: function () {
-                return argumentCount(2)() ||
-                    (_this.operands[0] > _this.operands[1]
-                        ? 'The first argument must be less than or equal to the second argument.'
-                        : null);
-            },
+            between: () => argumentCount(2)() ||
+                (this.operands[0] > this.operands[1]
+                    ? 'The first argument must be less than or equal to the second argument.'
+                    : null),
         };
-        var validate = validations[this.operator];
+        const validate = validations[this.operator];
         if (validate) {
-            var e = validate();
+            const e = validate();
             if (typeof e === 'string')
-                throw new Error("Incorrect usage of `" + this.operator + "()`: " + e);
+                throw new Error(`Incorrect usage of \`${this.operator}()\`: ${e}`);
         }
         else {
-            throw new Error("Non-existent operator: `" + this.operator + "()`");
+            throw new Error(`Non-existent operator: \`${this.operator}()\``);
         }
-    };
-    return FieldCondition;
-}());
-export { FieldCondition };
+    }
+}
 /**
  * Small utility function to generate a monotonically increasing ID.
  * Used by GroupCondition to help keep track of which group is doing what,
  * when, and where during troubleshooting.
  */
-var getGroupId = (function () {
-    var seed = 1;
-    return function () { return "group_" + seed++; };
+const getGroupId = (() => {
+    let seed = 1;
+    return () => `group_${seed++}`;
 })();
 /**
  * A set of sub-conditions to operate against a model, optionally scoped to
@@ -262,8 +244,8 @@ var getGroupId = (function () {
  * @member operator How to group child conditions together.
  * @member operands The child conditions.
  */
-var GroupCondition = /** @class */ (function () {
-    function GroupCondition(
+export class GroupCondition {
+    constructor(
     /**
      * The `ModelMeta` of the model to query and/or filter against.
      * Expected to contain:
@@ -307,8 +289,7 @@ var GroupCondition = /** @class */ (function () {
      * This is used to guard against infinitely fetch -> optimize -> fetch
      * recursion.
      */
-    isOptimized) {
-        if (isOptimized === void 0) { isOptimized = false; }
+    isOptimized = false) {
         this.model = model;
         this.field = field;
         this.relationshipType = relationshipType;
@@ -325,16 +306,16 @@ var GroupCondition = /** @class */ (function () {
      * @param extract A node of interest. Its copy will *also* be returned if the node exists.
      * @returns [The full copy, the copy of `extract` | undefined]
      */
-    GroupCondition.prototype.copy = function (extract) {
-        var copied = new GroupCondition(this.model, this.field, this.relationshipType, this.operator, []);
-        var extractedCopy = extract === this ? copied : undefined;
-        this.operands.forEach(function (o) {
-            var _a = __read(o.copy(extract), 2), operandCopy = _a[0], extractedFromOperand = _a[1];
+    copy(extract) {
+        const copied = new GroupCondition(this.model, this.field, this.relationshipType, this.operator, []);
+        let extractedCopy = extract === this ? copied : undefined;
+        this.operands.forEach(o => {
+            const [operandCopy, extractedFromOperand] = o.copy(extract);
             copied.operands.push(operandCopy);
             extractedCopy = extractedCopy || extractedFromOperand;
         });
         return [copied, extractedCopy];
-    };
+    }
     /**
      * Creates a new `GroupCondition` that contains only the local field conditions,
      * omitting related model conditions. That resulting `GroupCondition` can be
@@ -344,15 +325,12 @@ var GroupCondition = /** @class */ (function () {
      * @param negate Whether the condition tree should be negated according
      * to De Morgan's law.
      */
-    GroupCondition.prototype.withFieldConditionsOnly = function (negate) {
-        var _this = this;
-        var negateChildren = negate !== (this.operator === 'not');
+    withFieldConditionsOnly(negate) {
+        const negateChildren = negate !== (this.operator === 'not');
         return new GroupCondition(this.model, undefined, undefined, (negate ? negations[this.operator] : this.operator), this.operands
-            .filter(function (o) { return o instanceof FieldCondition; })
-            .map(function (o) {
-            return negateChildren ? o.negated(_this.model) : o;
-        }));
-    };
+            .filter(o => o instanceof FieldCondition)
+            .map(o => negateChildren ? o.negated(this.model) : o));
+    }
     /**
      * Returns a version of the predicate tree with unnecessary logical groups
      * condensed and merged together. This is intended to create a dense tree
@@ -389,12 +367,8 @@ var GroupCondition = /** @class */ (function () {
      * `not` groups. `not` groups will always have a single child, so there's nothing to
      * optimize below a `not` (for now), and it makes the query logic simpler later.
      */
-    GroupCondition.prototype.optimized = function (preserveNode) {
-        var _this = this;
-        if (preserveNode === void 0) { preserveNode = true; }
-        var operands = this.operands.map(function (o) {
-            return o instanceof GroupCondition ? o.optimized(_this.operator === 'not') : o;
-        });
+    optimized(preserveNode = true) {
+        const operands = this.operands.map(o => o instanceof GroupCondition ? o.optimized(this.operator === 'not') : o);
         // we're only collapsing and/or groups that contains a single child for now,
         // because they're much more common and much more trivial to collapse. basically,
         // an `and`/`or` that contains a single child doesn't require the layer of
@@ -403,7 +377,7 @@ var GroupCondition = /** @class */ (function () {
             ['and', 'or'].includes(this.operator) &&
             !this.field &&
             operands.length === 1) {
-            var operand = operands[0];
+            const operand = operands[0];
             if (operand instanceof FieldCondition) {
                 // between conditions should NOT be passed up the chain. if they
                 // need to be *negated* later, it is important that they be properly
@@ -419,7 +393,7 @@ var GroupCondition = /** @class */ (function () {
             }
         }
         return new GroupCondition(this.model, this.field, this.relationshipType, this.operator, operands, true);
-    };
+    }
     /**
      * Fetches matching records from a given storage adapter using legacy predicates (for now).
      * @param storage The storage adapter this predicate will query against.
@@ -428,211 +402,134 @@ var GroupCondition = /** @class */ (function () {
      * @param negate Whether to match on the `NOT` of `this`.
      * @returns An `Promise` of `any[]` from `storage` matching the child conditions.
      */
-    GroupCondition.prototype.fetch = function (storage, breadcrumb, negate) {
-        if (breadcrumb === void 0) { breadcrumb = []; }
-        if (negate === void 0) { negate = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var resultGroups, operator, negateChildren, groups, conditions, groups_1, groups_1_1, g, relatives, relationship, allJoinConditions, relatives_1, relatives_1_1, relative, relativeConditions, i, predicate, _a, _b, e_1_1, predicate, _c, _d, _e, _f, getPKValue, resultIndex, resultGroups_1, resultGroups_1_1, group, intersectWith, _g, _h, k, resultGroups_2, resultGroups_2_1, group, group_1, group_1_1, item;
-            var e_1, _j, e_2, _k, _l, e_3, _m, e_4, _o, e_5, _p, e_6, _q;
-            var _this = this;
-            return __generator(this, function (_r) {
-                switch (_r.label) {
-                    case 0:
-                        if (!this.isOptimized) {
-                            return [2 /*return*/, this.optimized().fetch(storage)];
-                        }
-                        resultGroups = [];
-                        operator = (negate ? negations[this.operator] : this.operator);
-                        negateChildren = negate !== (this.operator === 'not');
-                        groups = this.operands.filter(function (op) { return op instanceof GroupCondition; });
-                        conditions = this.operands.filter(function (op) { return op instanceof FieldCondition; });
-                        _r.label = 1;
-                    case 1:
-                        _r.trys.push([1, 10, 11, 12]);
-                        groups_1 = __values(groups), groups_1_1 = groups_1.next();
-                        _r.label = 2;
-                    case 2:
-                        if (!!groups_1_1.done) return [3 /*break*/, 9];
-                        g = groups_1_1.value;
-                        return [4 /*yield*/, g.fetch(storage, __spread(breadcrumb, [this.groupId]), negateChildren)];
-                    case 3:
-                        relatives = _r.sent();
-                        // no relatives -> no need to attempt to perform a "join" query for
-                        // candidate results:
-                        //
-                        // select a.* from a,b where b.id in EMPTY_SET ==> EMPTY_SET
-                        //
-                        // Additionally, the entire (sub)-query can be short-circuited if
-                        // the operator is `AND`. Illustrated in SQL:
-                        //
-                        // select a.* from a where
-                        //   id in [a,b,c]
-                        //     AND                        <
-                        //   id in EMTPY_SET            <<< Look!
-                        //     AND                        <
-                        //   id in [x,y,z]
-                        //
-                        // YIELDS: EMPTY_SET           // <-- Easy peasy. Lemon squeezy.
-                        //
-                        if (relatives.length === 0) {
-                            // aggressively short-circuit as soon as we know the group condition will fail
-                            if (operator === 'and') {
-                                return [2 /*return*/, []];
-                            }
-                            // less aggressive short-circuit if we know the relatives will produce no
-                            // candidate results; but aren't sure yet how this affects the group condition.
-                            resultGroups.push([]);
-                            return [3 /*break*/, 8];
-                        }
-                        if (!g.field) return [3 /*break*/, 7];
-                        relationship = ModelRelationship.from(this.model, g.field);
-                        if (!relationship) return [3 /*break*/, 5];
-                        allJoinConditions = [];
-                        try {
-                            for (relatives_1 = (e_2 = void 0, __values(relatives)), relatives_1_1 = relatives_1.next(); !relatives_1_1.done; relatives_1_1 = relatives_1.next()) {
-                                relative = relatives_1_1.value;
-                                relativeConditions = [];
-                                for (i = 0; i < relationship.localJoinFields.length; i++) {
-                                    relativeConditions.push((_l = {},
-                                        _l[relationship.localJoinFields[i]] = {
-                                            eq: relative[relationship.remoteJoinFields[i]],
-                                        },
-                                        _l));
-                                }
-                                allJoinConditions.push({ and: relativeConditions });
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (relatives_1_1 && !relatives_1_1.done && (_k = relatives_1.return)) _k.call(relatives_1);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        predicate = FlatModelPredicateCreator.createFromAST(this.model.schema, {
-                            or: allJoinConditions,
-                        });
-                        _b = (_a = resultGroups).push;
-                        return [4 /*yield*/, storage.query(this.model.builder, predicate)];
-                    case 4:
-                        _b.apply(_a, [_r.sent()]);
-                        return [3 /*break*/, 6];
-                    case 5: throw new Error('Missing field metadata.');
-                    case 6: return [3 /*break*/, 8];
-                    case 7:
-                        // relatives are not actually relatives. they're candidate results.
-                        resultGroups.push(relatives);
-                        _r.label = 8;
-                    case 8:
-                        groups_1_1 = groups_1.next();
-                        return [3 /*break*/, 2];
-                    case 9: return [3 /*break*/, 12];
-                    case 10:
-                        e_1_1 = _r.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 12];
-                    case 11:
-                        try {
-                            if (groups_1_1 && !groups_1_1.done && (_j = groups_1.return)) _j.call(groups_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 12:
-                        if (!(conditions.length > 0)) return [3 /*break*/, 14];
-                        predicate = this.withFieldConditionsOnly(negateChildren).toStoragePredicate();
-                        _d = (_c = resultGroups).push;
-                        return [4 /*yield*/, storage.query(this.model.builder, predicate)];
-                    case 13:
-                        _d.apply(_c, [_r.sent()]);
-                        return [3 /*break*/, 16];
-                    case 14:
-                        if (!(conditions.length === 0 && resultGroups.length === 0)) return [3 /*break*/, 16];
-                        _f = (_e = resultGroups).push;
-                        return [4 /*yield*/, storage.query(this.model.builder)];
-                    case 15:
-                        _f.apply(_e, [_r.sent()]);
-                        _r.label = 16;
-                    case 16:
-                        getPKValue = function (item) {
-                            return JSON.stringify(_this.model.pkField.map(function (name) { return item[name]; }));
-                        };
-                        if (operator === 'and') {
-                            if (resultGroups.length === 0) {
-                                return [2 /*return*/, []];
-                            }
-                            try {
-                                // for each group, we intersect, removing items from the result index
-                                // that aren't present in each subsequent group.
-                                for (resultGroups_1 = __values(resultGroups), resultGroups_1_1 = resultGroups_1.next(); !resultGroups_1_1.done; resultGroups_1_1 = resultGroups_1.next()) {
-                                    group = resultGroups_1_1.value;
-                                    if (resultIndex === undefined) {
-                                        resultIndex = new Map(group.map(function (item) { return [getPKValue(item), item]; }));
-                                    }
-                                    else {
-                                        intersectWith = new Map(group.map(function (item) { return [getPKValue(item), item]; }));
-                                        try {
-                                            for (_g = (e_4 = void 0, __values(resultIndex.keys())), _h = _g.next(); !_h.done; _h = _g.next()) {
-                                                k = _h.value;
-                                                if (!intersectWith.has(k)) {
-                                                    resultIndex.delete(k);
-                                                }
-                                            }
-                                        }
-                                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                        finally {
-                                            try {
-                                                if (_h && !_h.done && (_o = _g.return)) _o.call(_g);
-                                            }
-                                            finally { if (e_4) throw e_4.error; }
-                                        }
-                                    }
-                                }
-                            }
-                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                            finally {
-                                try {
-                                    if (resultGroups_1_1 && !resultGroups_1_1.done && (_m = resultGroups_1.return)) _m.call(resultGroups_1);
-                                }
-                                finally { if (e_3) throw e_3.error; }
-                            }
+    async fetch(storage, breadcrumb = [], negate = false) {
+        if (!this.isOptimized) {
+            return this.optimized().fetch(storage);
+        }
+        const resultGroups = [];
+        const operator = (negate ? negations[this.operator] : this.operator);
+        const negateChildren = negate !== (this.operator === 'not');
+        /**
+         * Conditions that must be branched out and used to generate a base, "candidate"
+         * result set.
+         *
+         * If `field` is populated, these groups select *related* records, and the base,
+         * candidate results are selected to match those.
+         */
+        const groups = this.operands.filter(op => op instanceof GroupCondition);
+        /**
+         * Simple conditions that must match the target model of `this`.
+         */
+        const conditions = this.operands.filter(op => op instanceof FieldCondition);
+        for (const g of groups) {
+            const relatives = await g.fetch(storage, [...breadcrumb, this.groupId], negateChildren);
+            // no relatives -> no need to attempt to perform a "join" query for
+            // candidate results:
+            //
+            // select a.* from a,b where b.id in EMPTY_SET ==> EMPTY_SET
+            //
+            // Additionally, the entire (sub)-query can be short-circuited if
+            // the operator is `AND`. Illustrated in SQL:
+            //
+            // select a.* from a where
+            //   id in [a,b,c]
+            //     AND                        <
+            //   id in EMTPY_SET            <<< Look!
+            //     AND                        <
+            //   id in [x,y,z]
+            //
+            // YIELDS: EMPTY_SET           // <-- Easy peasy. Lemon squeezy.
+            //
+            if (relatives.length === 0) {
+                // aggressively short-circuit as soon as we know the group condition will fail
+                if (operator === 'and') {
+                    return [];
+                }
+                // less aggressive short-circuit if we know the relatives will produce no
+                // candidate results; but aren't sure yet how this affects the group condition.
+                resultGroups.push([]);
+                continue;
+            }
+            if (g.field) {
+                // `relatives` are actual relatives. We'll skim them for FK query values.
+                // Use the relatives to add candidate result sets (`resultGroups`)
+                const relationship = ModelRelationship.from(this.model, g.field);
+                if (relationship) {
+                    const allJoinConditions = [];
+                    for (const relative of relatives) {
+                        const relativeConditions = [];
+                        for (let i = 0; i < relationship.localJoinFields.length; i++) {
+                            relativeConditions.push({
+                                [relationship.localJoinFields[i]]: {
+                                    eq: relative[relationship.remoteJoinFields[i]],
+                                },
+                            });
                         }
-                        else if (operator === 'or' || operator === 'not') {
-                            // it's OK to handle NOT here, because NOT must always only negate
-                            // a single child predicate. NOT logic will have been distributed down
-                            // to the leaf conditions already.
-                            resultIndex = new Map();
-                            try {
-                                // just merge the groups, performing DISTINCT-ification by ID.
-                                for (resultGroups_2 = __values(resultGroups), resultGroups_2_1 = resultGroups_2.next(); !resultGroups_2_1.done; resultGroups_2_1 = resultGroups_2.next()) {
-                                    group = resultGroups_2_1.value;
-                                    try {
-                                        for (group_1 = (e_6 = void 0, __values(group)), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
-                                            item = group_1_1.value;
-                                            resultIndex.set(getPKValue(item), item);
-                                        }
-                                    }
-                                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                                    finally {
-                                        try {
-                                            if (group_1_1 && !group_1_1.done && (_q = group_1.return)) _q.call(group_1);
-                                        }
-                                        finally { if (e_6) throw e_6.error; }
-                                    }
-                                }
-                            }
-                            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                            finally {
-                                try {
-                                    if (resultGroups_2_1 && !resultGroups_2_1.done && (_p = resultGroups_2.return)) _p.call(resultGroups_2);
-                                }
-                                finally { if (e_5) throw e_5.error; }
-                            }
+                        allJoinConditions.push({ and: relativeConditions });
+                    }
+                    const predicate = FlatModelPredicateCreator.createFromAST(this.model.schema, {
+                        or: allJoinConditions,
+                    });
+                    resultGroups.push(await storage.query(this.model.builder, predicate));
+                }
+                else {
+                    throw new Error('Missing field metadata.');
+                }
+            }
+            else {
+                // relatives are not actually relatives. they're candidate results.
+                resultGroups.push(relatives);
+            }
+        }
+        // if conditions is empty at this point, child predicates found no matches.
+        // i.e., we can stop looking and return empty.
+        if (conditions.length > 0) {
+            const predicate = this.withFieldConditionsOnly(negateChildren).toStoragePredicate();
+            resultGroups.push(await storage.query(this.model.builder, predicate));
+        }
+        else if (conditions.length === 0 && resultGroups.length === 0) {
+            resultGroups.push(await storage.query(this.model.builder));
+        }
+        // PK might be a single field, like `id`, or it might be several fields.
+        // so, we'll need to extract the list of PK fields from an object
+        // and stringify the list for easy comparison / merging.
+        const getPKValue = item => JSON.stringify(this.model.pkField.map(name => item[name]));
+        // will be used for intersecting or unioning results
+        let resultIndex;
+        if (operator === 'and') {
+            if (resultGroups.length === 0) {
+                return [];
+            }
+            // for each group, we intersect, removing items from the result index
+            // that aren't present in each subsequent group.
+            for (const group of resultGroups) {
+                if (resultIndex === undefined) {
+                    resultIndex = new Map(group.map(item => [getPKValue(item), item]));
+                }
+                else {
+                    const intersectWith = new Map(group.map(item => [getPKValue(item), item]));
+                    for (const k of resultIndex.keys()) {
+                        if (!intersectWith.has(k)) {
+                            resultIndex.delete(k);
                         }
-                        return [2 /*return*/, Array.from((resultIndex === null || resultIndex === void 0 ? void 0 : resultIndex.values()) || [])];
+                    }
                 }
-            });
-        });
-    };
+            }
+        }
+        else if (operator === 'or' || operator === 'not') {
+            // it's OK to handle NOT here, because NOT must always only negate
+            // a single child predicate. NOT logic will have been distributed down
+            // to the leaf conditions already.
+            resultIndex = new Map();
+            // just merge the groups, performing DISTINCT-ification by ID.
+            for (const group of resultGroups) {
+                for (const item of group) {
+                    resultIndex.set(getPKValue(item), item);
+                }
+            }
+        }
+        return Array.from(resultIndex?.values() || []);
+    }
     /**
      * Determines whether a single item matches the conditions of `this`.
      * When checking the target `item`'s properties, each property will be `await`'d
@@ -642,112 +539,67 @@ var GroupCondition = /** @class */ (function () {
      * (Used for iterating over children on HAS_MANY checks.)
      * @returns A boolean (promise): `true` if matched, `false` otherwise.
      */
-    GroupCondition.prototype.matches = function (item, ignoreFieldName) {
-        if (ignoreFieldName === void 0) { ignoreFieldName = false; }
-        var e_7, _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var itemToCheck, _b, itemToCheck_1, itemToCheck_1_1, singleItem, e_7_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(this.field && !ignoreFieldName)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, item[this.field]];
-                    case 1:
-                        _b = _c.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _b = item;
-                        _c.label = 3;
-                    case 3:
-                        itemToCheck = _b;
-                        // if there is no item to check, we can stop recursing immediately.
-                        // a condition cannot match against an item that does not exist. this
-                        // can occur when `item.field` is optional in the schema.
-                        if (!itemToCheck) {
-                            return [2 /*return*/, false];
-                        }
-                        if (!(this.relationshipType === 'HAS_MANY' &&
-                            typeof itemToCheck[Symbol.asyncIterator] === 'function')) return [3 /*break*/, 17];
-                        _c.label = 4;
-                    case 4:
-                        _c.trys.push([4, 10, 11, 16]);
-                        itemToCheck_1 = __asyncValues(itemToCheck);
-                        _c.label = 5;
-                    case 5: return [4 /*yield*/, itemToCheck_1.next()];
-                    case 6:
-                        if (!(itemToCheck_1_1 = _c.sent(), !itemToCheck_1_1.done)) return [3 /*break*/, 9];
-                        singleItem = itemToCheck_1_1.value;
-                        return [4 /*yield*/, this.matches(singleItem, true)];
-                    case 7:
-                        if (_c.sent()) {
-                            return [2 /*return*/, true];
-                        }
-                        _c.label = 8;
-                    case 8: return [3 /*break*/, 5];
-                    case 9: return [3 /*break*/, 16];
-                    case 10:
-                        e_7_1 = _c.sent();
-                        e_7 = { error: e_7_1 };
-                        return [3 /*break*/, 16];
-                    case 11:
-                        _c.trys.push([11, , 14, 15]);
-                        if (!(itemToCheck_1_1 && !itemToCheck_1_1.done && (_a = itemToCheck_1.return))) return [3 /*break*/, 13];
-                        return [4 /*yield*/, _a.call(itemToCheck_1)];
-                    case 12:
-                        _c.sent();
-                        _c.label = 13;
-                    case 13: return [3 /*break*/, 15];
-                    case 14:
-                        if (e_7) throw e_7.error;
-                        return [7 /*endfinally*/];
-                    case 15: return [7 /*endfinally*/];
-                    case 16: return [2 /*return*/, false];
-                    case 17:
-                        if (!(this.operator === 'or')) return [3 /*break*/, 18];
-                        return [2 /*return*/, asyncSome(this.operands, function (c) { return c.matches(itemToCheck); })];
-                    case 18:
-                        if (!(this.operator === 'and')) return [3 /*break*/, 19];
-                        return [2 /*return*/, asyncEvery(this.operands, function (c) { return c.matches(itemToCheck); })];
-                    case 19:
-                        if (!(this.operator === 'not')) return [3 /*break*/, 21];
-                        if (this.operands.length !== 1) {
-                            throw new Error('Invalid arguments! `not()` accepts exactly one predicate expression.');
-                        }
-                        return [4 /*yield*/, this.operands[0].matches(itemToCheck)];
-                    case 20: return [2 /*return*/, !(_c.sent())];
-                    case 21: throw new Error('Invalid group operator!');
+    async matches(item, ignoreFieldName = false) {
+        const itemToCheck = this.field && !ignoreFieldName ? await item[this.field] : item;
+        // if there is no item to check, we can stop recursing immediately.
+        // a condition cannot match against an item that does not exist. this
+        // can occur when `item.field` is optional in the schema.
+        if (!itemToCheck) {
+            return false;
+        }
+        if (this.relationshipType === 'HAS_MANY' &&
+            typeof itemToCheck[Symbol.asyncIterator] === 'function') {
+            for await (const singleItem of itemToCheck) {
+                if (await this.matches(singleItem, true)) {
+                    return true;
                 }
-            });
-        });
-    };
+            }
+            return false;
+        }
+        if (this.operator === 'or') {
+            return asyncSome(this.operands, c => c.matches(itemToCheck));
+        }
+        else if (this.operator === 'and') {
+            return asyncEvery(this.operands, c => c.matches(itemToCheck));
+        }
+        else if (this.operator === 'not') {
+            if (this.operands.length !== 1) {
+                throw new Error('Invalid arguments! `not()` accepts exactly one predicate expression.');
+            }
+            return !(await this.operands[0].matches(itemToCheck));
+        }
+        else {
+            throw new Error('Invalid group operator!');
+        }
+    }
     /**
      * Tranfsorm to a AppSync GraphQL compatible AST.
      * (Does not support filtering in nested types.)
      */
-    GroupCondition.prototype.toAST = function () {
-        var _a;
+    toAST() {
         if (this.field)
             throw new Error('Nested type conditions are not supported!');
-        return _a = {},
-            _a[this.operator] = this.operands.map(function (operand) { return operand.toAST(); }),
-            _a;
-    };
+        return {
+            [this.operator]: this.operands.map(operand => operand.toAST()),
+        };
+    }
     /**
      * Turn this predicate group into something a storage adapter
      * understands how to use.
      */
-    GroupCondition.prototype.toStoragePredicate = function () {
+    toStoragePredicate() {
         return FlatModelPredicateCreator.createFromAST(this.model.schema, this.toAST());
-    };
+    }
     /**
      * A JSON representation that's good for debugging.
      */
-    GroupCondition.prototype.toJSON = function () {
-        return __assign(__assign({}, this), { model: this.model.schema.name });
-    };
-    return GroupCondition;
-}());
-export { GroupCondition };
+    toJSON() {
+        return {
+            ...this,
+            model: this.model.schema.name,
+        };
+    }
+}
 /**
  * Creates a "seed" predicate that can be used to build an executable condition.
  * This is used in `query()`, for example, to seed customer- E.g.,
@@ -775,49 +627,48 @@ export { GroupCondition };
  * @returns A ModelPredicate (builder) that customers can create queries with.
  * (As shown in function description.)
  */
-export function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
-    if (allowRecursion === void 0) { allowRecursion = true; }
+export function recursivePredicateFor(ModelType, allowRecursion = true, field, query, tail) {
     // to be used if we don't have a base query or tail to build onto
-    var starter = new GroupCondition(ModelType, field, undefined, 'and', []);
-    var baseCondition = query && tail ? query : starter;
-    var tailCondition = query && tail ? tail : starter;
+    const starter = new GroupCondition(ModelType, field, undefined, 'and', []);
+    const baseCondition = query && tail ? query : starter;
+    const tailCondition = query && tail ? tail : starter;
     // our eventual return object, which can be built upon.
     // next steps will be to add or(), and(), not(), and field.op() methods.
-    var link = {};
+    const link = {};
     // so it can be looked up later with in the internals when processing conditions.
     registerPredicateInternals(baseCondition, link);
-    var copyLink = function () {
-        var _a = __read(baseCondition.copy(tailCondition), 2), query = _a[0], newTail = _a[1];
-        var newLink = recursivePredicateFor(ModelType, allowRecursion, undefined, query, newTail);
-        return { query: query, newTail: newTail, newLink: newLink };
+    const copyLink = () => {
+        const [query, newTail] = baseCondition.copy(tailCondition);
+        const newLink = recursivePredicateFor(ModelType, allowRecursion, undefined, query, newTail);
+        return { query, newTail, newLink };
     };
     // Adds .or() and .and() methods to the link.
     // TODO: If revisiting this code, consider writing a Proxy instead.
-    ['and', 'or'].forEach(function (op) {
-        link[op] = function (builder) {
+    ['and', 'or'].forEach(op => {
+        link[op] = (builder) => {
             // or() and and() will return a copy of the original link
             // to head off mutability concerns.
-            var _a = copyLink(), query = _a.query, newTail = _a.newTail;
-            var childConditions = builder(recursivePredicateFor(ModelType, allowRecursion));
+            const { query, newTail } = copyLink();
+            const childConditions = builder(recursivePredicateFor(ModelType, allowRecursion));
             if (!Array.isArray(childConditions)) {
-                throw new Error("Invalid predicate. `" + op + "` groups must return an array of child conditions.");
+                throw new Error(`Invalid predicate. \`${op}\` groups must return an array of child conditions.`);
             }
             // the customer will supply a child predicate, which apply to the `model.field`
             // of the tail GroupCondition.
-            newTail === null || newTail === void 0 ? void 0 : newTail.operands.push(new GroupCondition(ModelType, field, undefined, op, childConditions.map(function (c) { return internals(c); })));
+            newTail?.operands.push(new GroupCondition(ModelType, field, undefined, op, childConditions.map(c => internals(c))));
             // FinalPredicate
             return registerPredicateInternals(query);
         };
     });
     // TODO: If revisiting this code, consider proxy.
-    link.not = function (builder) {
+    link.not = (builder) => {
         // not() will return a copy of the original link
         // to head off mutability concerns.
-        var _a = copyLink(), query = _a.query, newTail = _a.newTail;
+        const { query, newTail } = copyLink();
         // unlike and() and or(), the customer will supply a "singular" child predicate.
         // the difference being: not() does not accept an array of predicate-like objects.
         // it negates only a *single* predicate subtree.
-        newTail === null || newTail === void 0 ? void 0 : newTail.operands.push(new GroupCondition(ModelType, field, undefined, 'not', [
+        newTail?.operands.push(new GroupCondition(ModelType, field, undefined, 'not', [
             internals(builder(recursivePredicateFor(ModelType, allowRecursion))),
         ]));
         // A `FinalModelPredicate`.
@@ -825,39 +676,42 @@ export function recursivePredicateFor(ModelType, allowRecursion, field, query, t
         // or query storage: `.__query.fetch(storage)`.
         return registerPredicateInternals(query);
     };
-    var _loop_1 = function (fieldName) {
+    // For each field on the model schema, we want to add a getter
+    // that creates the appropriate new `link` in the query chain.
+    // TODO: If revisiting, consider a proxy.
+    for (const fieldName in ModelType.schema.allFields) {
         Object.defineProperty(link, fieldName, {
             enumerable: true,
-            get: function () {
-                var def = ModelType.schema.allFields[fieldName];
+            get: () => {
+                const def = ModelType.schema.allFields[fieldName];
                 if (!def.association) {
                     // we're looking at a value field. we need to return a
                     // "field matcher object", which contains all of the comparison
                     // functions ('eq', 'ne', 'gt', etc.), scoped to operate
                     // against the target field (fieldName).
-                    return ops.reduce(function (fieldMatcher, operator) {
-                        var _a;
-                        return __assign(__assign({}, fieldMatcher), (_a = {}, _a[operator] = function () {
-                            var operands = [];
-                            for (var _i = 0; _i < arguments.length; _i++) {
-                                operands[_i] = arguments[_i];
-                            }
-                            // build off a fresh copy of the existing `link`, just in case
-                            // the same link is being used elsewhere by the customer.
-                            var _a = copyLink(), query = _a.query, newTail = _a.newTail;
-                            // normalize operands. if any of the values are `undefiend`, use
-                            // `null` instead, because that's what will be stored cross-platform.
-                            var normalizedOperands = operands.map(function (o) {
-                                return o === undefined ? null : o;
-                            });
-                            // add the given condition to the link's TAIL node.
-                            // remember: the base link might go N nodes deep! e.g.,
-                            newTail === null || newTail === void 0 ? void 0 : newTail.operands.push(new FieldCondition(fieldName, operator, normalizedOperands));
-                            // A `FinalModelPredicate`.
-                            // Return a thing that can no longer be extended, but instead used to `async filter(items)`
-                            // or query storage: `.__query.fetch(storage)`.
-                            return registerPredicateInternals(query);
-                        }, _a));
+                    return ops.reduce((fieldMatcher, operator) => {
+                        return {
+                            ...fieldMatcher,
+                            // each operator on the fieldMatcher objcect is a function.
+                            // when the customer calls the function, it returns a new link
+                            // in the chain -- for now -- this is the "leaf" link that
+                            // cannot be further extended.
+                            [operator]: (...operands) => {
+                                // build off a fresh copy of the existing `link`, just in case
+                                // the same link is being used elsewhere by the customer.
+                                const { query, newTail } = copyLink();
+                                // normalize operands. if any of the values are `undefiend`, use
+                                // `null` instead, because that's what will be stored cross-platform.
+                                const normalizedOperands = operands.map(o => o === undefined ? null : o);
+                                // add the given condition to the link's TAIL node.
+                                // remember: the base link might go N nodes deep! e.g.,
+                                newTail?.operands.push(new FieldCondition(fieldName, operator, normalizedOperands));
+                                // A `FinalModelPredicate`.
+                                // Return a thing that can no longer be extended, but instead used to `async filter(items)`
+                                // or query storage: `.__query.fetch(storage)`.
+                                return registerPredicateInternals(query);
+                            },
+                        };
                     }, {});
                 }
                 else {
@@ -869,20 +723,20 @@ export function recursivePredicateFor(ModelType, allowRecursion, field, query, t
                         def.association.connectionType === 'HAS_MANY') {
                         // the use has just typed '.someRelatedModel'. we need to given them
                         // back a predicate chain.
-                        var relatedMeta = def.type.modelConstructor;
+                        const relatedMeta = def.type.modelConstructor;
                         if (!relatedMeta) {
                             throw new Error('Related model metadata is missing. This is a bug! Please report it.');
                         }
                         // `Model.reletedModelField` returns a copy of the original link,
                         // and will contains copies of internal GroupConditions
                         // to head off mutability concerns.
-                        var _a = __read(baseCondition.copy(tailCondition), 2), newquery = _a[0], oldtail = _a[1];
-                        var newtail = new GroupCondition(relatedMeta, fieldName, def.association.connectionType, 'and', []);
+                        const [newquery, oldtail] = baseCondition.copy(tailCondition);
+                        const newtail = new GroupCondition(relatedMeta, fieldName, def.association.connectionType, 'and', []);
                         // `oldtail` here refers to the *copy* of the old tail.
                         // so, it's safe to modify at this point. and we need to modify
                         // it to push the *new* tail onto the end of it.
                         oldtail.operands.push(newtail);
-                        var newlink = recursivePredicateFor(relatedMeta, allowRecursion, undefined, newquery, newtail);
+                        const newlink = recursivePredicateFor(relatedMeta, allowRecursion, undefined, newquery, newtail);
                         return newlink;
                     }
                     else {
@@ -891,12 +745,6 @@ export function recursivePredicateFor(ModelType, allowRecursion, field, query, t
                 }
             },
         });
-    };
-    // For each field on the model schema, we want to add a getter
-    // that creates the appropriate new `link` in the query chain.
-    // TODO: If revisiting, consider a proxy.
-    for (var fieldName in ModelType.schema.allFields) {
-        _loop_1(fieldName);
     }
     return link;
 }
@@ -905,4 +753,3 @@ export function predicateFor(ModelType) {
     // the recursive type.
     return recursivePredicateFor(ModelType, false);
 }
-//# sourceMappingURL=next.js.map