@aws-amplify/datastore 4.7.5 → 5.0.1-console-preview.4208d73.0

package/lib-esm/predicates/index.js

@@ -1,4 +1,39 @@
-import { __assign, __read, __spread } from "tslib";
+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 __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));
+};
 import { extractPrimaryKeyFieldNames, extractPrimaryKeyValues } from '../util';
 export { ModelSortPredicateCreator } from './sort';
 var predicatesAllSet = new WeakSet();
@@ -23,7 +58,7 @@ var groupKeys = new Set(['and', 'or', 'not']);
  * @param o The object to test.
  */
 var isGroup = function (o) {
-    var keys = __spread(Object.keys(o));
+    var keys = __spreadArray([], __read(Object.keys(o)), false);
     return keys.length === 1 && groupKeys.has(keys[0]);
 };
 /**
@@ -58,7 +93,7 @@ export var comparisonKeys = new Set([
  * @param o The object to test.
  */
 var isComparison = function (o) {
-    var keys = __spread(Object.keys(o));
+    var keys = __spreadArray([], __read(Object.keys(o)), false);
     return !Array.isArray(o) && keys.length === 1 && comparisonKeys.has(keys[0]);
 };
 /**
@@ -85,13 +120,13 @@ var Predicates = /** @class */ (function () {
             predicatesAllSet.add(predicate);
             return predicate;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     return Predicates;
 }());
 export { Predicates };
-var ModelPredicateCreator = /** @class */ (function () {
+export var ModelPredicateCreator = /** @class */ (function () {
     function ModelPredicateCreator() {
     }
     /**
@@ -250,5 +285,3 @@ var ModelPredicateCreator = /** @class */ (function () {
     ModelPredicateCreator.predicateGroupsMap = new WeakMap();
     return ModelPredicateCreator;
 }());
-export { ModelPredicateCreator };
-//# sourceMappingURL=index.js.map

package/lib-esm/predicates/next.d.ts

@@ -1,7 +1,7 @@
 import { PersistentModel, ModelMeta, ModelPredicate as StoragePredicate, PredicateInternalsKey, V5ModelPredicate as ModelPredicate, RecursiveModelPredicate } from '../types';
 import { ExclusiveStorage as StorageAdapter } from '../storage/storage';
-declare type GroupOperator = 'and' | 'or' | 'not';
-declare type UntypedCondition = {
+type GroupOperator = 'and' | 'or' | 'not';
+type UntypedCondition = {
     fetch: (storage: StorageAdapter) => Promise<Record<string, any>[]>;
     matches: (item: Record<string, any>) => Promise<boolean>;
     copy(extract?: GroupCondition): [UntypedCondition, GroupCondition | undefined];

package/lib-esm/predicates/next.js

@@ -1,11 +1,100 @@
-import { __assign, __asyncValues, __awaiter, __generator, __read, __spread, __values } from "tslib";
+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.");
+};
 // 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);
+var ops = __spreadArray([], __read(comparisonKeys), false);
 /**
  * A map from keys (exposed to customers) to the internal predicate data
  * structures invoking code should not muck with.
@@ -79,7 +168,7 @@ var FieldCondition = /** @class */ (function () {
      */
     FieldCondition.prototype.copy = function (extract) {
         return [
-            new FieldCondition(this.field, this.operator, __spread(this.operands)),
+            new FieldCondition(this.field, this.operator, __spreadArray([], __read(this.operands), false)),
             undefined,
         ];
     };
@@ -186,7 +275,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*/];
             });
@@ -206,7 +295,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.");
                 }
             };
         };
@@ -234,10 +323,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;
@@ -250,7 +339,7 @@ export { 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
@@ -454,7 +543,7 @@ var GroupCondition = /** @class */ (function () {
                     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)];
+                        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
@@ -643,23 +732,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 __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) {
+            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.
@@ -667,55 +756,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 = __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];
+                    case 17: return [7 /*endfinally*/];
+                    case 18: return [2 /*return*/, false];
+                    case 19:
+                        if (!(this.operator === 'or')) return [3 /*break*/, 20];
                         return [2 /*return*/, asyncSome(this.operands, function (c) { return c.matches(itemToCheck); })];
-                    case 18:
-                        if (!(this.operator === 'and')) return [3 /*break*/, 19];
+                    case 20:
+                        if (!(this.operator === 'and')) return [3 /*break*/, 21];
                         return [2 /*return*/, asyncEvery(this.operands, function (c) { return c.matches(itemToCheck); })];
-                    case 19:
-                        if (!(this.operator === 'not')) return [3 /*break*/, 21];
+                    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!');
                 }
             });
         });
@@ -800,7 +897,7 @@ export function recursivePredicateFor(ModelType, allowRecursion, field, query, t
             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.
@@ -905,4 +1002,3 @@ export function predicateFor(ModelType) {
     // the recursive type.
     return recursivePredicateFor(ModelType, false);
 }
-//# sourceMappingURL=next.js.map

package/lib-esm/predicates/sort.js

@@ -1,4 +1,4 @@
-var ModelSortPredicateCreator = /** @class */ (function () {
+export var ModelSortPredicateCreator = /** @class */ (function () {
     function ModelSortPredicateCreator() {
     }
     ModelSortPredicateCreator.createPredicateBuilder = function (modelDefinition) {
@@ -9,7 +9,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;
@@ -50,5 +50,3 @@ var ModelSortPredicateCreator = /** @class */ (function () {
     ModelSortPredicateCreator.sortPredicateGroupsMap = new WeakMap();
     return ModelSortPredicateCreator;
 }());
-export { ModelSortPredicateCreator };
-//# sourceMappingURL=sort.js.map

package/lib-esm/ssr/index.js

@@ -11,4 +11,3 @@ export function deserializeModel(Model, init) {
 export function serializeModel(model) {
     return JSON.parse(JSON.stringify(model));
 }
-//# sourceMappingURL=index.js.map