electrodb 2.2.4 → 2.2.6

package/package.json

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

package/src/entity.js

@@ -54,7 +54,7 @@ class Entity {
 		this._whereBuilder = new WhereFactory(this.model.schema.attributes, FilterOperations);
 		this._clausesWithFilters = this._filterBuilder.injectFilterClauses(clauses, this.model.filters);
 		this._clausesWithFilters = this._whereBuilder.injectWhereClauses(this._clausesWithFilters);
-		this.scan = this._makeChain(TableIndex, this._clausesWithFilters, clauses.index, {_isPagination: true}).scan();
+
 		this.query = {};
 		for (let accessPattern in this.model.indexes) {
 			let index = this.model.indexes[accessPattern].index;
@@ -75,6 +75,10 @@ class Entity {
 		this.schema = model;
 	}
 
+	get scan() {
+		return this._makeChain(TableIndex, this._clausesWithFilters, clauses.index, {_isPagination: true}).scan();
+	}
+
 	setIdentifier(type = "", identifier = "") {
 		if (!this.identifiers[type]) {
 			throw new e.ElectroError(e.ErrorCodes.InvalidIdentifier, `Invalid identifier type: "${type}". Valid identifiers include: ${u.commaSeparatedString(Object.keys(this.identifiers))}`);

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,
+                        }
+                    });
                 }
             });
         }