@aws-amplify/datastore 4.7.5 → 5.0.1-console-preview.4432977.0

package/lib/predicates/next.js

@@ -1,13 +1,103 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+exports.predicateFor = exports.recursivePredicateFor = exports.GroupCondition = exports.FieldCondition = exports.internals = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 var types_1 = require("../types");
 var index_1 = require("./index");
 var relationship_1 = require("../storage/relationship");
 var util_1 = require("../util");
-var ops = tslib_1.__spread(index_1.comparisonKeys);
+var ops = __spreadArray([], __read(index_1.comparisonKeys), false);
 /**
  * A map from keys (exposed to customers) to the internal predicate data
  * structures invoking code should not muck with.
@@ -38,12 +128,13 @@ var registerPredicateInternals = function (condition, key) {
  *
  * @param key A key object previously returned by `registerPredicateInternals()`
  */
-exports.internals = function (key) {
+var internals = function (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`.");
     }
     return predicateInternalsMap.get(key);
 };
+exports.internals = internals;
 /**
  * Maps operators to negated operators.
  * Used to facilitate propagation of negation down a tree of conditions.
@@ -81,7 +172,7 @@ var FieldCondition = /** @class */ (function () {
      */
     FieldCondition.prototype.copy = function (extract) {
         return [
-            new FieldCondition(this.field, this.operator, tslib_1.__spread(this.operands)),
+            new FieldCondition(this.field, this.operator, __spreadArray([], __read(this.operands), false)),
             undefined,
         ];
     };
@@ -153,8 +244,8 @@ var FieldCondition = /** @class */ (function () {
      * @returns N/A. If ever implemented, return items from `storage` that match.
      */
     FieldCondition.prototype.fetch = function (storage) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
                 return [2 /*return*/, Promise.reject('No implementation needed [yet].')];
             });
         });
@@ -165,10 +256,10 @@ var FieldCondition = /** @class */ (function () {
      * @returns `Promise<boolean>`, `true` if matches; `false` otherwise.
      */
     FieldCondition.prototype.matches = function (item) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return __awaiter(this, void 0, void 0, function () {
             var v, operations, operation, result;
             var _this = this;
-            return tslib_1.__generator(this, function (_a) {
+            return __generator(this, function (_a) {
                 v = item[this.field];
                 operations = {
                     eq: function () { return v === _this.operands[0]; },
@@ -188,7 +279,7 @@ var FieldCondition = /** @class */ (function () {
                     return [2 /*return*/, result];
                 }
                 else {
-                    throw new Error("Invalid operator given: " + this.operator);
+                    throw new Error("Invalid operator given: ".concat(this.operator));
                 }
                 return [2 /*return*/];
             });
@@ -208,7 +299,7 @@ var FieldCondition = /** @class */ (function () {
             var argsClause = count === 1 ? 'argument is' : 'arguments are';
             return function () {
                 if (_this.operands.length !== count) {
-                    return "Exactly " + count + " " + argsClause + " required.";
+                    return "Exactly ".concat(count, " ").concat(argsClause, " required.");
                 }
             };
         };
@@ -236,10 +327,10 @@ var FieldCondition = /** @class */ (function () {
         if (validate) {
             var e = validate();
             if (typeof e === 'string')
-                throw new Error("Incorrect usage of `" + this.operator + "()`: " + e);
+                throw new Error("Incorrect usage of `".concat(this.operator, "()`: ").concat(e));
         }
         else {
-            throw new Error("Non-existent operator: `" + this.operator + "()`");
+            throw new Error("Non-existent operator: `".concat(this.operator, "()`"));
         }
     };
     return FieldCondition;
@@ -252,7 +343,7 @@ exports.FieldCondition = FieldCondition;
  */
 var getGroupId = (function () {
     var seed = 1;
-    return function () { return "group_" + seed++; };
+    return function () { return "group_".concat(seed++); };
 })();
 /**
  * A set of sub-conditions to operate against a model, optionally scoped to
@@ -331,7 +422,7 @@ var GroupCondition = /** @class */ (function () {
         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 = tslib_1.__read(o.copy(extract), 2), operandCopy = _a[0], extractedFromOperand = _a[1];
+            var _a = __read(o.copy(extract), 2), operandCopy = _a[0], extractedFromOperand = _a[1];
             copied.operands.push(operandCopy);
             extractedCopy = extractedCopy || extractedFromOperand;
         });
@@ -433,11 +524,11 @@ var GroupCondition = /** @class */ (function () {
     GroupCondition.prototype.fetch = function (storage, breadcrumb, negate) {
         if (breadcrumb === void 0) { breadcrumb = []; }
         if (negate === void 0) { negate = false; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
+        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 tslib_1.__generator(this, function (_r) {
+            return __generator(this, function (_r) {
                 switch (_r.label) {
                     case 0:
                         if (!this.isOptimized) {
@@ -451,12 +542,12 @@ var GroupCondition = /** @class */ (function () {
                         _r.label = 1;
                     case 1:
                         _r.trys.push([1, 10, 11, 12]);
-                        groups_1 = tslib_1.__values(groups), groups_1_1 = groups_1.next();
+                        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, tslib_1.__spread(breadcrumb, [this.groupId]), negateChildren)];
+                        return [4 /*yield*/, g.fetch(storage, __spreadArray(__spreadArray([], __read(breadcrumb), false), [this.groupId], false), negateChildren)];
                     case 3:
                         relatives = _r.sent();
                         // no relatives -> no need to attempt to perform a "join" query for
@@ -491,7 +582,7 @@ var GroupCondition = /** @class */ (function () {
                         if (!relationship) return [3 /*break*/, 5];
                         allJoinConditions = [];
                         try {
-                            for (relatives_1 = (e_2 = void 0, tslib_1.__values(relatives)), relatives_1_1 = relatives_1.next(); !relatives_1_1.done; relatives_1_1 = relatives_1.next()) {
+                            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++) {
@@ -565,7 +656,7 @@ var GroupCondition = /** @class */ (function () {
                             try {
                                 // for each group, we intersect, removing items from the result index
                                 // that aren't present in each subsequent group.
-                                for (resultGroups_1 = tslib_1.__values(resultGroups), resultGroups_1_1 = resultGroups_1.next(); !resultGroups_1_1.done; resultGroups_1_1 = resultGroups_1.next()) {
+                                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]; }));
@@ -573,7 +664,7 @@ var GroupCondition = /** @class */ (function () {
                                     else {
                                         intersectWith = new Map(group.map(function (item) { return [getPKValue(item), item]; }));
                                         try {
-                                            for (_g = (e_4 = void 0, tslib_1.__values(resultIndex.keys())), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                            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);
@@ -605,10 +696,10 @@ var GroupCondition = /** @class */ (function () {
                             resultIndex = new Map();
                             try {
                                 // just merge the groups, performing DISTINCT-ification by ID.
-                                for (resultGroups_2 = tslib_1.__values(resultGroups), resultGroups_2_1 = resultGroups_2.next(); !resultGroups_2_1.done; resultGroups_2_1 = resultGroups_2.next()) {
+                                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, tslib_1.__values(group)), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
+                                        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);
                                         }
@@ -645,23 +736,23 @@ var GroupCondition = /** @class */ (function () {
      * @returns A boolean (promise): `true` if matched, `false` otherwise.
      */
     GroupCondition.prototype.matches = function (item, ignoreFieldName) {
+        var _a, e_7, _b, _c;
         if (ignoreFieldName === void 0) { ignoreFieldName = false; }
-        var e_7, _a;
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var itemToCheck, _b, itemToCheck_1, itemToCheck_1_1, singleItem, e_7_1;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
+        return __awaiter(this, void 0, void 0, function () {
+            var itemToCheck, _d, _e, itemToCheck_1, itemToCheck_1_1, singleItem, e_7_1;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         if (!(this.field && !ignoreFieldName)) return [3 /*break*/, 2];
                         return [4 /*yield*/, item[this.field]];
                     case 1:
-                        _b = _c.sent();
+                        _d = _f.sent();
                         return [3 /*break*/, 3];
                     case 2:
-                        _b = item;
-                        _c.label = 3;
+                        _d = item;
+                        _f.label = 3;
                     case 3:
-                        itemToCheck = _b;
+                        itemToCheck = _d;
                         // 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.
@@ -669,55 +760,63 @@ var GroupCondition = /** @class */ (function () {
                             return [2 /*return*/, false];
                         }
                         if (!(this.relationshipType === 'HAS_MANY' &&
-                            typeof itemToCheck[Symbol.asyncIterator] === 'function')) return [3 /*break*/, 17];
-                        _c.label = 4;
+                            typeof itemToCheck[Symbol.asyncIterator] === 'function')) return [3 /*break*/, 19];
+                        _f.label = 4;
                     case 4:
-                        _c.trys.push([4, 10, 11, 16]);
-                        itemToCheck_1 = tslib_1.__asyncValues(itemToCheck);
-                        _c.label = 5;
+                        _f.trys.push([4, 12, 13, 18]);
+                        _e = true, itemToCheck_1 = __asyncValues(itemToCheck);
+                        _f.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)];
+                        if (!(itemToCheck_1_1 = _f.sent(), _a = itemToCheck_1_1.done, !_a)) return [3 /*break*/, 11];
+                        _c = itemToCheck_1_1.value;
+                        _e = false;
+                        _f.label = 7;
                     case 7:
-                        if (_c.sent()) {
+                        _f.trys.push([7, , 9, 10]);
+                        singleItem = _c;
+                        return [4 /*yield*/, this.matches(singleItem, true)];
+                    case 8:
+                        if (_f.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)];
+                        return [3 /*break*/, 10];
+                    case 9:
+                        _e = true;
+                        return [7 /*endfinally*/];
+                    case 10: return [3 /*break*/, 5];
+                    case 11: return [3 /*break*/, 18];
                     case 12:
-                        _c.sent();
-                        _c.label = 13;
-                    case 13: return [3 /*break*/, 15];
+                        e_7_1 = _f.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 18];
+                    case 13:
+                        _f.trys.push([13, , 16, 17]);
+                        if (!(!_e && !_a && (_b = itemToCheck_1.return))) return [3 /*break*/, 15];
+                        return [4 /*yield*/, _b.call(itemToCheck_1)];
                     case 14:
+                        _f.sent();
+                        _f.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
                         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*/, util_1.asyncSome(this.operands, function (c) { return c.matches(itemToCheck); })];
-                    case 18:
-                        if (!(this.operator === 'and')) return [3 /*break*/, 19];
-                        return [2 /*return*/, util_1.asyncEvery(this.operands, function (c) { return c.matches(itemToCheck); })];
+                    case 17: return [7 /*endfinally*/];
+                    case 18: return [2 /*return*/, false];
                     case 19:
-                        if (!(this.operator === 'not')) return [3 /*break*/, 21];
+                        if (!(this.operator === 'or')) return [3 /*break*/, 20];
+                        return [2 /*return*/, (0, util_1.asyncSome)(this.operands, function (c) { return c.matches(itemToCheck); })];
+                    case 20:
+                        if (!(this.operator === 'and')) return [3 /*break*/, 21];
+                        return [2 /*return*/, (0, util_1.asyncEvery)(this.operands, function (c) { return c.matches(itemToCheck); })];
+                    case 21:
+                        if (!(this.operator === 'not')) return [3 /*break*/, 23];
                         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!');
+                    case 22: return [2 /*return*/, !(_f.sent())];
+                    case 23: throw new Error('Invalid group operator!');
                 }
             });
         });
@@ -745,7 +844,7 @@ var GroupCondition = /** @class */ (function () {
      * A JSON representation that's good for debugging.
      */
     GroupCondition.prototype.toJSON = function () {
-        return tslib_1.__assign(tslib_1.__assign({}, this), { model: this.model.schema.name });
+        return __assign(__assign({}, this), { model: this.model.schema.name });
     };
     return GroupCondition;
 }());
@@ -789,7 +888,7 @@ function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
     // so it can be looked up later with in the internals when processing conditions.
     registerPredicateInternals(baseCondition, link);
     var copyLink = function () {
-        var _a = tslib_1.__read(baseCondition.copy(tailCondition), 2), query = _a[0], newTail = _a[1];
+        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 };
     };
@@ -802,11 +901,11 @@ function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
             var _a = copyLink(), query = _a.query, newTail = _a.newTail;
             var 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. `".concat(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 exports.internals(c); })));
+            newTail === null || newTail === void 0 ? void 0 : newTail.operands.push(new GroupCondition(ModelType, field, undefined, op, childConditions.map(function (c) { return (0, exports.internals)(c); })));
             // FinalPredicate
             return registerPredicateInternals(query);
         };
@@ -820,7 +919,7 @@ function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
         // 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', [
-            exports.internals(builder(recursivePredicateFor(ModelType, allowRecursion))),
+            (0, exports.internals)(builder(recursivePredicateFor(ModelType, allowRecursion))),
         ]));
         // A `FinalModelPredicate`.
         // Return a thing that can no longer be extended, but instead used to `async filter(items)`
@@ -839,7 +938,7 @@ function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
                     // against the target field (fieldName).
                     return ops.reduce(function (fieldMatcher, operator) {
                         var _a;
-                        return tslib_1.__assign(tslib_1.__assign({}, fieldMatcher), (_a = {}, _a[operator] = function () {
+                        return __assign(__assign({}, fieldMatcher), (_a = {}, _a[operator] = function () {
                             var operands = [];
                             for (var _i = 0; _i < arguments.length; _i++) {
                                 operands[_i] = arguments[_i];
@@ -878,7 +977,7 @@ function recursivePredicateFor(ModelType, allowRecursion, field, query, tail) {
                         // `Model.reletedModelField` returns a copy of the original link,
                         // and will contains copies of internal GroupConditions
                         // to head off mutability concerns.
-                        var _a = tslib_1.__read(baseCondition.copy(tailCondition), 2), newquery = _a[0], oldtail = _a[1];
+                        var _a = __read(baseCondition.copy(tailCondition), 2), newquery = _a[0], oldtail = _a[1];
                         var 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
@@ -909,4 +1008,3 @@ function predicateFor(ModelType) {
     return recursivePredicateFor(ModelType, false);
 }
 exports.predicateFor = predicateFor;
-//# sourceMappingURL=next.js.map

package/lib/predicates/sort.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var ModelSortPredicateCreator = /** @class */ (function () {
+exports.ModelSortPredicateCreator = void 0;
+var ModelSortPredicateCreator = exports.ModelSortPredicateCreator = /** @class */ (function () {
     function ModelSortPredicateCreator() {
     }
     ModelSortPredicateCreator.createPredicateBuilder = function (modelDefinition) {
@@ -11,7 +12,7 @@ var ModelSortPredicateCreator = /** @class */ (function () {
             get: function (_target, propertyKey, receiver) {
                 var field = propertyKey;
                 if (!fieldNames.has(field)) {
-                    throw new Error("Invalid field for model. field: " + field + ", model: " + modelName);
+                    throw new Error("Invalid field for model. field: ".concat(String(field), ", model: ").concat(modelName));
                 }
                 var result = function (sortDirection) {
                     var _a;
@@ -52,5 +53,3 @@ var ModelSortPredicateCreator = /** @class */ (function () {
     ModelSortPredicateCreator.sortPredicateGroupsMap = new WeakMap();
     return ModelSortPredicateCreator;
 }());
-exports.ModelSortPredicateCreator = ModelSortPredicateCreator;
-//# sourceMappingURL=sort.js.map

package/lib/ssr/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeModel = exports.deserializeModel = void 0;
 // Helper for converting JSON back into DataStore models (while respecting IDs)
 function deserializeModel(Model, init) {
     if (Array.isArray(init)) {
@@ -15,4 +16,3 @@ function serializeModel(model) {
     return JSON.parse(JSON.stringify(model));
 }
 exports.serializeModel = serializeModel;
-//# sourceMappingURL=index.js.map