electrodb 2.2.3 → 2.2.5

package/README.md

@@ -3419,6 +3419,8 @@ operation     | example                               | result
 `value`       | `value(rent, amount)`                 | `:rent1`                                                              | Create a reference to a particular value, can be passed to other operation that allows leveraging existing attribute values in calculating new values
 `ifNotExists` | `ifNotExists(rent, amount)`           | `#rent = if_not_exists(#rent, :rent0)`                                | Update a property's value only if that property doesn't yet exist on the record
 
+> _NOTE: Usage of `name` and `value` operations allow for some escape hatching in the case that a custom operation needs to be expressed. When used however, ElectroDB loses the context necessary to validate the expression created by the user. In practical terms, this means the `validation` function/regex on the impacted attribute will not be called._
+
 Example:
 ```javascript
 await StoreLocations
@@ -5688,6 +5690,8 @@ const person = new Entity({
 }, { table });
 ```
 
+[![Try it out!](https://img.shields.io/badge/electrodb-try_out_this_example_›-%23f9bd00?style=for-the-badge&logo=amazondynamodb&labelColor=1a212a)](https://electrodb.fun/?ssl=3&ssc=29&pln=37&pc=2#code/JYWwDg9gTgLgBAbzgUQHY2DAngGjgYQFcBnGCEAQRhimACNCYBTAFSzCbgF84AzKcnADkTADZMAxjQgATOkIDcAKCUSIqUnACqqYAEdCTANJMsAZSwg6EUQC44hXQc7FL10XAC8cC1ZsAKAEplbA4UcFEILCYmAEkAES84UlpUAHM4ADJEAG0dfUMTczcbAF17AENULC5lVXVNfOcKNKZfd3tHApcSj292gOClUM4AWXUYAAsk1EIrJigs3KbDFrbe8rgqmrqRuAAFBeJ1VDEAJRtObwQlODu4EfsRCKiYxVv70grYeIrmexSwHSynucCYqBkv2YAH4ATQgWllDwAD6ID53R7CNToKAVKTQd6g7E0PEwMwwb4wKFMOGpRHouDE3FSNCQv405Lw4FKWoqbGaCl0cRJIQAd2gAGswKI8UwAPqC8TveoaeAcKDHVAzJiilDoTBYfw3UEgWRiezG0H3cEYbBPdWa06iIQ4Bmg4gLABuwAkHLFkulspdbvunqOwHUTwAjEIGVxXaC-vCGMxiBaQ3cmC9onEZOmrQWHuwOURSOQqMnGKxiwAeZDZmIJAB8-iEgPSQkCGe4CcLWelrwW+cLoMxba5aVjI-j3d4wA1MAAchUQBzLSOMcWnu3J72N3AoEwDPOmHmHlBDHurTORzLSMvV8P92Od8H93dD8fD2eaJfuzfCwqVonw3MdZnmKAp0LACCyAuJUHGdBJjTNF3zgUU-gkSZ7ByIQ4KEUorxHTFSzIShqFoFNqw4GtEKmFshHAugFk7IjCw9GB7CCLwm0QGCNxkJheAqQhRE4uBuM8XiEH4kdWnE-w5XsOjJjwBA4K4C04PsJiFi4QIeNQtD7kPGBCCgLVRj+SYADpeEiaB-DguAAHo4CjAAmIY0K4f82I-S4QOIrcCBIMiK0oqs2Bow4NROc5LgY7ZWP-OMryBQSAA8mBQ9crUPNQoDPPKRzACUgvfOcxDPIQyrfYy7jUcAIGITAOVw-tIhzSDSm7UFZPY8qjIaqrRBq4gJXqhqmsgVr-jgDqG1zAj-OvVL+p5NSHgqIVOH0up+XgCRD3ZWIZCSIJ7HrAccwSQy8tM8ytQAAwAEgQakbNQCBRSCLhnq2Yhwhuxt4iRFQHXUBkbOOph2SNbsXLc4gOAkYAKg8CAwAqZw4GAc6Rm7TrBzO+xYdOmQglW4nuqefYqkICQ0aB-ZgAALzZiopqtOcFwfP19kmYBRGAMBudBO8lxXP0ADEoCwcX7m0uAPIAVlWgRxAqgsxxpt5VvdCkfnZaMAE5TYAdgAWgABg8q2PNNxWC3BNl5qEKNzdNq3PKtgBmGNVt8-qu1BGy0ggIJoamcF-EPYhRPgKThqtJGDyYMyLKLDggYx448fAUlT27ePE5smQ-gqGy4NiBCJmQuNAiAA)
+
 ### Opaque Keys
 If you use Opaque Keys for identifiers or other primitive types, you can use the function `CustomAttributeType` and pass it the primitive base type of your key ('string', 'number', 'boolean'). This can be useful to gain more precise control over which properties can be used as entity identifiers, create unique unit types, etc.
 
@@ -5739,6 +5743,8 @@ const person = new Entity({
 }, { table });
 ```
 
+[![Try it out!](https://img.shields.io/badge/electrodb-try_out_this_example_›-%23f9bd00?style=for-the-badge&logo=amazondynamodb&labelColor=1a212a)](https://electrodb.fun/?ssl=3&ssc=29&pln=37&pc=2#code/JYWwDg9gTgLgBAbzgUQHY2DAngGjgYQFcBnGCEAQRhimACNCYBTAFSzCbgF84AzKcnADkTADZMAxjQgATOkIDcAKCUSIqUnACqqYAEdCTANJMsAZSwg6EUQC44hXQc7FL10XAC8cC1ZsAKAEplbA4UcFEILCYmAEkAES84UlpUAHM4ADJEAG0dfUMTczcbAF17AENULC5lVXVNfOcKNKZfd3tHApcSj292gOClUM4AWXUYAAsk1EIrJigs3KbDFrbe8rgqmrqRuAAFBeJ1VDEAJRtObwQlODu4EfsRCKiYxVv70grYeIrmexSwHSynucCYqBkv2YAH4ATQgWllDwAD6ID53R7CNToKAVKTQd6g7E0PEwMwwb4wKFMOGpRHouDE3FSNCQv405Lw4FKWoqbGaCl0cRJIQAd2gAGswKI8UwAPqC8TveoaeAcKDHVAzJiilDoTBYfw3UEgWRiezG0H3cEYbBPdWa06iIQ4Bmg4gLABuwAkHLFkulspdbvunqOwHUTwAjEIGVxXaC-vCGMxiBaQ3cmC9onEZOmrQWHuwOURSOQqMnGKxiwAeZDZmIJAB8-iEgPSQkCGe4CcLWelrwW+cLoMxba5aVjI-j3d4wA1MAAchUQBzLSOMcWnu3J72N3AoEwDPOmHmHlBDHurTORzLSMvV8P92Od8H93dD8fD2eaJfuzfCwqVonw3MdZnmKAp0LACCyAuJUHGdBJjTNF3zgUU-gkSZ7ByIQ4KEUorxHTFSzIShqFoFNqw4GtEKmFshHAugFk7IjCw9GB7CCLwm0QGCNxkJheAqQhRE4uBuM8XiEH4kdWnE-w5XsOjJjwBA4K4C04PsJiFi4QIeNQtD7kPGBCCgLVRj+SYADpeEiaB-DguAAHo4CjAAmIY0K4f82I-S4QOIrcCBIMiK0oqs2Bow4NROc5LgY7ZWP-OMryBQSAA8mBQ9crUPNQoDPPKRzACUgvfOcxDPIQyrfYy7jUcAIGITAOVw-tIhzSDSm7UFZPY8qjIaqrRBq4gJXqhqmsgVr-jgDqG1zAj-OvVL+p5NSHgqIVOH0up+XgCRD3ZWIZCSIJ7HrAccwSQy8tM8ytQAAwAEgQakbNQCBRSCLhnq2Yhwhuxt4iRFQHXUBkbOOph2SNbsXLc4gOAkYAKg8CAwAqZw4GAc6Rm7TrBzO+xYdOmQglW4nuqefYqkICQ0aB-ZgAALzZiopqtOcFwfP19kmYBRGAMBudBO8lxXP0ADEoCwcX7m0uAPIAVlWgRxAqgsxxpt5VvdCkfnZaMAE5TYAdgAWgABg8q2PNNxWC3BNl5qEKNzdNq3PKtgBmGNVt8-qu1BGy0ggIJoamcF-EPYhRPgKThqtJGDyYMyLKLDggYx448fAUlT27ePE5smQ-gqGy4NiBCJmQuNAiAA)
+
 ## Exported Types
 
 The following types are exported for easier use while using ElectroDB with TypeScript. The naming convention for the types include three different kinds:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {

package/src/clauses.js

@@ -309,7 +309,16 @@ let clauses = {
 				for (const path of Object.keys(state.query.update.refs)) {
 					const operation = state.query.update.impacted[path];
 					const attribute = state.query.update.refs[path];
-					entity.model.schema.checkOperation(attribute, operation);
+					// note: keyValue will be empty if the user used `name`/`value` operations
+					// because it becomes hard to know how they are used and which attribute
+					// should validate the change. This is an edge case however, this change
+					// still improves on the existing implementation.
+					const keyValue = state.query.update.paths[path] || {};
+					if (!attribute) {
+						throw new e.ElectroAttributeValidationError(path, `Attribute "${path}" does not exist on model.`);
+					}
+
+					entity.model.schema.checkOperation(attribute, operation, keyValue.value);
 				}
 				return state;
 			} catch(err) {

package/src/entity.js

@@ -229,7 +229,7 @@ class Entity {
 		if (Array.isArray(facets)) {
 			return this._makeChain(index, this._clausesWithFilters, clauses.index).batchGet(facets);
 		} else {
-			return this._makeChain(index, clauses, clauses.index).get(facets);
+			return this._makeChain(index, this._clausesWithFilters, clauses.index).get(facets);
 		}
 	}
 

package/src/filters.js

@@ -16,6 +16,7 @@ class FilterFactory {
 			case MethodTypes.update:
 			case MethodTypes.patch:
 			case MethodTypes.delete:
+			case MethodTypes.get:
 				return ExpressionTypes.ConditionExpression
 			default:
 				return ExpressionTypes.FilterExpression

package/src/operations.js

@@ -431,24 +431,32 @@ class AttributeOperationProxy {
         return ops;
     }
 
-    static pathProxy(paths, root, target, builder) {
-        return new Proxy(() => ({paths, root, target}), {
-            get: (_, prop) => {
+    static pathProxy(build) {
+        return new Proxy(() => build(), {
+            get: (_, prop, o) => {
                 if (prop === "__is_clause__") {
-                    return AttributeProxySymbol
+                    return AttributeProxySymbol;
                 } else {
-                    const attribute = target.getChild(prop);
-                    let field;
-                    if (attribute === undefined) {
-                        throw new Error(`Invalid attribute "${prop}" at path "${paths.json}".`);
-                    } else if (attribute === root && attribute.type === AttributeTypes.any) {
-                        // This function is only called if a nested property is called. If this attribute is ultimately the root, don't use the root's field name
-                        field = prop;
-                    } else {
-                        field = attribute.field;
-                    }
-                    paths = builder.setName(paths, prop, field);
-                    return AttributeOperationProxy.pathProxy(paths, root, attribute, builder);
+                    return AttributeOperationProxy.pathProxy(() => {
+                        const { paths, root, target, builder } = build();
+                        const attribute = target.getChild(prop);
+                        let field;
+                        if (attribute === undefined) {
+                            throw new Error(`Invalid attribute "${prop}" at path "${paths.json}".`);
+                        } else if (attribute === root && attribute.type === AttributeTypes.any) {
+                            // This function is only called if a nested property is called. If this attribute is ultimately the root, don't use the root's field name
+                            field = prop;
+                        } else {
+                            field = attribute.field;
+                        }
+
+                        return {
+                            root,
+                            builder,
+                            target: attribute,
+                            paths: builder.setName(paths, prop, field),
+                        }
+                    });
                 }
             }
         });
@@ -459,8 +467,15 @@ class AttributeOperationProxy {
         for (let [name, attribute] of Object.entries(attributes)) {
             Object.defineProperty(attr, name, {
                 get: () => {
-                    const paths = builder.setName({}, attribute.name, attribute.field);
-                    return AttributeOperationProxy.pathProxy(paths, attribute, attribute, builder);
+                    return AttributeOperationProxy.pathProxy(() => {
+                        const paths = builder.setName({}, attribute.name, attribute.field);
+                        return {
+                            paths,
+                            root: attribute,
+                            target: attribute,
+                            builder,
+                        }
+                    });
                 }
             });
         }

package/src/schema.js

@@ -1,4 +1,4 @@
-const { CastTypes, ValueTypes, KeyCasing, AttributeTypes, AttributeMutationMethods, AttributeWildCard, PathTypes, TableIndex } = require("./types");
+const { CastTypes, ValueTypes, KeyCasing, AttributeTypes, AttributeMutationMethods, AttributeWildCard, PathTypes, TableIndex, ItemOperations } = require("./types");
 const AttributeTypeNames = Object.keys(AttributeTypes);
 const ValidFacetTypes = [AttributeTypes.string, AttributeTypes.number, AttributeTypes.boolean, AttributeTypes.enum];
 const e = require("./errors");
@@ -1389,16 +1389,6 @@ class Schema {
 		return record;
 	}
 
-	checkOperation(attribute, operation) {
-		if (!attribute) {
-			throw new e.ElectroAttributeValidationError(path, `Attribute "${path}" does not exist on model.`);
-		} else if (attribute.required && operation === 'remove') {
-			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Required and cannot be removed`);
-		} else if (attribute.readOnly) {
-			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Read-Only and cannot be updated`);
-		}
-	}
-
 	checkRemove(paths = []) {
 		for (const path of paths) {
 			const attribute = this.traverser.getPath(path);
@@ -1413,6 +1403,18 @@ class Schema {
 		return paths;
 	}
 
+	checkOperation(attribute, operation, value) {
+		if (attribute.required && operation === ItemOperations.remove) {
+			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Required and cannot be removed`);
+		} else if (attribute.readOnly) {
+			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Read-Only and cannot be updated`);
+		}
+
+		return value === undefined
+			? undefined
+			: attribute.getValidate(value);
+	}
+
 	checkUpdate(payload = {}) {
 		let record = {};
 		for (let [path, attribute] of this.traverser.getAll()) {

package/src/where.js

@@ -74,6 +74,7 @@ class WhereFactory {
 		case MethodTypes.patch:
 		case MethodTypes.delete:
 		case MethodTypes.remove:
+		case MethodTypes.get:
 			return ExpressionTypes.ConditionExpression
 		default:
 			return ExpressionTypes.FilterExpression