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

package/lib-esm/index.d.ts

@@ -9,7 +9,7 @@ export declare const utils: {
         item: T;
         instance: T;
     }[];
-    validatePredicate: <T_2 extends Readonly<Record<string, any>>>(model: T_2, groupType: "and" | "or" | "not", predicatesOrGroups: (import("./types").PredicateObject<T_2> | import("./types").PredicatesGroup<T_2>)[]) => any;
+    validatePredicate: <T_2 extends Readonly<Record<string, any>>>(model: T_2, groupType: keyof import("./types").PredicateGroups<T_2>, predicatesOrGroups: (import("./types").PredicateObject<T_2> | import("./types").PredicatesGroup<T_2>)[]) => any;
     isNonModelConstructor: (obj: any) => obj is import("./types").NonModelTypeConstructor<any>;
     isModelConstructor: <T_3 extends Readonly<Record<string, any>>>(obj: any) => obj is import("./types").PersistentModelConstructor<T_3>;
 };

package/lib-esm/index.js

@@ -4,12 +4,11 @@ export { DataStore, DataStoreClass, initSchema, AsyncCollection, AsyncItem, } fr
 export { Predicates, ModelPredicateCreator, ModelSortPredicateCreator, } from './predicates';
 import { traverseModel, validatePredicate, USER, isNonModelConstructor, isModelConstructor, } from './util';
 export { NAMESPACES } from './util';
-export var utils = {
-    USER: USER,
-    traverseModel: traverseModel,
-    validatePredicate: validatePredicate,
-    isNonModelConstructor: isNonModelConstructor,
-    isModelConstructor: isModelConstructor,
+export const utils = {
+    USER,
+    traverseModel,
+    validatePredicate,
+    isNonModelConstructor,
+    isModelConstructor,
 };
 export * from './types';
-//# sourceMappingURL=index.js.map

package/lib-esm/predicates/index.js

@@ -1,14 +1,13 @@
-import { __assign, __read, __spread } from "tslib";
 import { extractPrimaryKeyFieldNames, extractPrimaryKeyValues } from '../util';
 export { ModelSortPredicateCreator } from './sort';
-var predicatesAllSet = new WeakSet();
+const predicatesAllSet = new WeakSet();
 export function isPredicatesAll(predicate) {
     return predicatesAllSet.has(predicate);
 }
 /**
  * The valid logical grouping keys for a predicate group.
  */
-var groupKeys = new Set(['and', 'or', 'not']);
+const groupKeys = new Set(['and', 'or', 'not']);
 /**
  * Determines whether an object is a GraphQL style predicate "group", which must be an
  * object containing a single "group key", which then contains the child condition(s).
@@ -22,8 +21,8 @@ var groupKeys = new Set(['and', 'or', 'not']);
  *
  * @param o The object to test.
  */
-var isGroup = function (o) {
-    var keys = __spread(Object.keys(o));
+const isGroup = o => {
+    const keys = [...Object.keys(o)];
     return keys.length === 1 && groupKeys.has(keys[0]);
 };
 /**
@@ -32,13 +31,13 @@ var isGroup = function (o) {
  *
  * @param o The object to test.
  */
-var isEmpty = function (o) {
+const isEmpty = o => {
     return !Array.isArray(o) && Object.keys(o).length === 0;
 };
 /**
  * The valid comparison operators that can be used as keys in a predicate comparison object.
  */
-export var comparisonKeys = new Set([
+export const comparisonKeys = new Set([
     'eq',
     'ne',
     'gt',
@@ -57,8 +56,8 @@ export var comparisonKeys = new Set([
  *
  * @param o The object to test.
  */
-var isComparison = function (o) {
-    var keys = __spread(Object.keys(o));
+const isComparison = o => {
+    const keys = [...Object.keys(o)];
     return !Array.isArray(o) && keys.length === 1 && comparisonKeys.has(keys[0]);
 };
 /**
@@ -66,43 +65,33 @@ var isComparison = function (o) {
  *
  * @param o The object to test.
  */
-var isValid = function (o) {
+const isValid = o => {
     if (Array.isArray(o)) {
-        return o.every(function (v) { return isValid(v); });
+        return o.every(v => isValid(v));
     }
     else {
         return Object.keys(o).length <= 1;
     }
 };
 // This symbol is not used at runtime, only its type (unique symbol)
-export var PredicateAll = Symbol('A predicate that matches all records');
-var Predicates = /** @class */ (function () {
-    function Predicates() {
-    }
-    Object.defineProperty(Predicates, "ALL", {
-        get: function () {
-            var predicate = (function (c) { return c; });
-            predicatesAllSet.add(predicate);
-            return predicate;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Predicates;
-}());
-export { Predicates };
-var ModelPredicateCreator = /** @class */ (function () {
-    function ModelPredicateCreator() {
+export const PredicateAll = Symbol('A predicate that matches all records');
+export class Predicates {
+    static get ALL() {
+        const predicate = (c => c);
+        predicatesAllSet.add(predicate);
+        return predicate;
     }
+}
+class ModelPredicateCreator {
     /**
      * Determines whether the given storage predicate (lookup key) is a predicate
      * key that DataStore recognizes.
      *
      * @param predicate The storage predicate (lookup key) to test.
      */
-    ModelPredicateCreator.isValidPredicate = function (predicate) {
+    static isValidPredicate(predicate) {
         return ModelPredicateCreator.predicateGroupsMap.has(predicate);
-    };
+    }
     /**
      * Looks for the storage predicate AST that corresponds to a given storage
      * predicate key.
@@ -114,13 +103,12 @@ var ModelPredicateCreator = /** @class */ (function () {
      * @param throwOnInvalid Whether to throw an exception if the predicate
      * isn't a valid DataStore predicate.
      */
-    ModelPredicateCreator.getPredicates = function (predicate, throwOnInvalid) {
-        if (throwOnInvalid === void 0) { throwOnInvalid = true; }
+    static getPredicates(predicate, throwOnInvalid = true) {
         if (throwOnInvalid && !ModelPredicateCreator.isValidPredicate(predicate)) {
             throw new Error('The predicate is not valid');
         }
         return ModelPredicateCreator.predicateGroupsMap.get(predicate);
-    };
+    }
     /**
      * using the PK values from the given `model` (which can be a partial of T
      * Creates a predicate that matches an instance described by `modelDefinition`
@@ -129,18 +117,17 @@ var ModelPredicateCreator = /** @class */ (function () {
      * @param modelDefinition The model definition to create a predicate for.
      * @param model The model instance to extract value equalities from.
      */
-    ModelPredicateCreator.createForPk = function (modelDefinition, model) {
-        var keyFields = extractPrimaryKeyFieldNames(modelDefinition);
-        var keyValues = extractPrimaryKeyValues(model, keyFields);
-        var predicate = this.createFromAST(modelDefinition, {
-            and: keyFields.map(function (field, idx) {
-                var _a;
-                var operand = keyValues[idx];
-                return _a = {}, _a[field] = { eq: operand }, _a;
+    static createForPk(modelDefinition, model) {
+        const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+        const keyValues = extractPrimaryKeyValues(model, keyFields);
+        const predicate = this.createFromAST(modelDefinition, {
+            and: keyFields.map((field, idx) => {
+                const operand = keyValues[idx];
+                return { [field]: { eq: operand } };
             }),
         });
         return predicate;
-    };
+    }
     /**
      * Searches a `Model` table for records matching the given equalities object.
      *
@@ -150,16 +137,12 @@ var ModelPredicateCreator = /** @class */ (function () {
      * @param modelDefinition The model we need a predicate for.
      * @param flatEqualities An object holding field equalities to search for.
      */
-    ModelPredicateCreator.createFromFlatEqualities = function (modelDefinition, flatEqualities) {
-        var ast = {
-            and: Object.entries(flatEqualities).map(function (_a) {
-                var _b;
-                var _c = __read(_a, 2), k = _c[0], v = _c[1];
-                return (_b = {}, _b[k] = { eq: v }, _b);
-            }),
+    static createFromFlatEqualities(modelDefinition, flatEqualities) {
+        const ast = {
+            and: Object.entries(flatEqualities).map(([k, v]) => ({ [k]: { eq: v } })),
         };
         return this.createFromAST(modelDefinition, ast);
-    };
+    }
     /**
      * Accepts a GraphQL style filter predicate tree and transforms it into an
      * AST that can be used for a storage adapter predicate. Example input:
@@ -181,8 +164,7 @@ var ModelPredicateCreator = /** @class */ (function () {
      *
      * @param gql GraphQL style filter node.
      */
-    ModelPredicateCreator.transformGraphQLFilterNodeToPredicateAST = function (gql) {
-        var _this = this;
+    static transformGraphQLFilterNodeToPredicateAST(gql) {
         if (!isValid(gql)) {
             throw new Error('Invalid GraphQL Condition or subtree: ' + JSON.stringify(gql));
         }
@@ -193,15 +175,15 @@ var ModelPredicateCreator = /** @class */ (function () {
             };
         }
         else if (isGroup(gql)) {
-            var groupkey = Object.keys(gql)[0];
-            var children = this.transformGraphQLFilterNodeToPredicateAST(gql[groupkey]);
+            const groupkey = Object.keys(gql)[0];
+            const children = this.transformGraphQLFilterNodeToPredicateAST(gql[groupkey]);
             return {
                 type: groupkey,
                 predicates: Array.isArray(children) ? children : [children],
             };
         }
         else if (isComparison(gql)) {
-            var operatorKey = Object.keys(gql)[0];
+            const operatorKey = Object.keys(gql)[0];
             return {
                 operator: operatorKey,
                 operand: gql[operatorKey],
@@ -209,14 +191,17 @@ var ModelPredicateCreator = /** @class */ (function () {
         }
         else {
             if (Array.isArray(gql)) {
-                return gql.map(function (o) { return _this.transformGraphQLFilterNodeToPredicateAST(o); });
+                return gql.map(o => this.transformGraphQLFilterNodeToPredicateAST(o));
             }
             else {
-                var fieldKey = Object.keys(gql)[0];
-                return __assign({ field: fieldKey }, this.transformGraphQLFilterNodeToPredicateAST(gql[fieldKey]));
+                const fieldKey = Object.keys(gql)[0];
+                return {
+                    field: fieldKey,
+                    ...this.transformGraphQLFilterNodeToPredicateAST(gql[fieldKey]),
+                };
             }
         }
-    };
+    }
     /**
      * Accepts a GraphQL style filter predicate tree and transforms it into a predicate
      * that storage adapters understand. Example input:
@@ -239,16 +224,14 @@ var ModelPredicateCreator = /** @class */ (function () {
      * @param modelDefinition The model that the AST/predicate must be compatible with.
      * @param ast The graphQL style AST that should specify conditions for `modelDefinition`.
      */
-    ModelPredicateCreator.createFromAST = function (modelDefinition, ast) {
-        var key = {};
+    static createFromAST(modelDefinition, ast) {
+        const key = {};
         ModelPredicateCreator.predicateGroupsMap.set(key, this.transformGraphQLFilterNodeToPredicateAST(ast));
         return key;
-    };
-    /**
-     * Map of storage predicates (key objects) to storage predicate AST's.
-     */
-    ModelPredicateCreator.predicateGroupsMap = new WeakMap();
-    return ModelPredicateCreator;
-}());
+    }
+}
+/**
+ * Map of storage predicates (key objects) to storage predicate AST's.
+ */
+ModelPredicateCreator.predicateGroupsMap = new WeakMap();
 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];