electrodb 2.5.0 → 2.6.0

package/src/errors.js

@@ -187,6 +187,24 @@ const ErrorCodes = {
     name: "InvalidLimitOption",
     sym: ErrorCode,
   },
+  InvalidConversionKeysProvided: {
+    code: 2007,
+    section: "invalid-conversion-values-provided",
+    name: "InvalidConversionKeysProvided",
+    sym: ErrorCode,
+  },
+  InvalidConversionCursorProvided: {
+    code: 2008,
+    section: "invalid-conversion-values-provided",
+    name: "InvalidConversionCursorProvided",
+    sym: ErrorCode,
+  },
+  InvalidConversionCompositeProvided: {
+    code: 2009,
+    section: "invalid-conversion-values-provided",
+    name: "InvalidConversionCompositeProvided",
+    sym: ErrorCode,
+  },
   InvalidAttribute: {
     code: 3001,
     section: "invalid-attribute",

package/src/service.js

@@ -323,17 +323,25 @@ class Service {
 				continue;
 			}
 
-			const entityAlias = matchToEntityAlias({identifiers, record});
+			const entityAlias = matchToEntityAlias({identifiers, record, entities: this.entities, allowMatchOnKeys: config.ignoreOwnership });
 
 			if (!entityAlias) {
 				continue;
 			}
+
 			// pager=false because we don't want the entity trying to parse the lastEvaluatedKey
-			let formatted = entities[entityAlias].formatResponse({Item: record}, index, {
-				...config,
-				pager: false,
-				parse: undefined
-			});
+			let formatted;
+			if (config.hydrate) {
+				formatted = {
+					data: record // entities[entityAlias]._formatKeysToItem(index, record),
+				};
+			} else {
+				formatted = entities[entityAlias].formatResponse({Item: record}, index, {
+					...config,
+					pager: false,
+					parse: undefined,
+				});
+			}
 
 			results[entityAlias].push(formatted.data);
 		}
@@ -429,6 +437,70 @@ class Service {
 			entities,
 			indexType,
 			compositeAttributes,
+			hydrator: async (entity, index, items, config) => {
+				if (entity && entities[entity]) {
+					return entities[entity].hydrate(index, items, {
+						...config,
+						parse: undefined,
+						hydrator: undefined,
+						_isCollectionQuery: false,
+						ignoreOwnership: config._providedIgnoreOwnership,
+					});
+				}
+
+				// let itemLookup = [];
+				let entityItemRefs = {};
+				// let entityResultRefs = {};
+				for (let i = 0; i < items.length; i++) {
+					const item = items[i];
+					for (let entityName in entities) {
+						entityItemRefs[entityName] = entityItemRefs[entityName] || [];
+						const entity = entities[entityName];
+						// if (entity.ownsKeys({ keys: item })) {
+						if (entity.ownsKeys(item)) {
+							// const entityItemRefsIndex =
+							entityItemRefs[entityName].push({
+								item,
+								itemSlot: i,
+							});
+							// itemLookup[i] = {
+							// 	entityName,
+							// 	entityItemRefsIndex,
+							// 	originalItem: item,
+							// }
+						}
+					}
+				}
+
+				let unprocessed = [];
+				let data = new Array(items.length).fill(null);
+				for (const entityName in entityItemRefs) {
+					const itemRefs = entityItemRefs[entityName];
+					const items = itemRefs.map(ref => ref.item);
+					const results = await entities[entity].hydrate(index, items, {
+						...config,
+						parse: undefined,
+						hydrate: false,
+						hydrator: undefined,
+						_isCollectionQuery: false,
+						ignoreOwnership: config._providedIgnoreOwnership,
+					});
+					unprocessed = unprocessed.concat(results.unprocessed);
+					if (results.data.length !== itemRefs.length) {
+						throw new Error('Temporary: something wrong');
+					}
+					for (let r = 0; r < itemRefs.length; r++) {
+						const itemRef = itemRefs[r];
+						const hydrated = results.data[r];
+						data[itemRef.itemSlot] = hydrated;
+					}
+				}
+
+				return {
+					data,
+					unprocessed,
+				}
+			}
 		};
 
 		return entity.collection(name, clauses, facets, options);

package/src/update.js

@@ -11,6 +11,7 @@ class UpdateExpression extends ExpressionState {
             subtract: new Set(),
             delete: new Set()
         };
+        this.seen = new Map();
         this.type = BuilderTypes.update;
     }
 
@@ -18,10 +19,29 @@ class UpdateExpression extends ExpressionState {
         this.operations[type].add(expression);
     }
 
-    set(name, value) {
-        const n = this.setName({}, name, name);
-        const v = this.setValue(name, value);
-        this.add(ItemOperations.set, `${n.prop} = ${v}`);
+    unadd(type, expression) {
+        this.operations[type].delete(expression);
+    }
+
+    set(name, value, operation) {
+        const seen = this.seen.get(name);
+        let n;
+        let v;
+        if (seen) {
+            n = seen.name;
+            v = seen.value;
+            this.unadd(ItemOperations.set, seen.expression);
+        } else {
+            n = this.setName({}, name, name);
+            v = this.setValue(name, value);
+        }
+        const expression = `${n.prop} = ${v}`;
+        this.seen.set(name, {
+            name: n,
+            value: v,
+            expression,
+        });
+        this.add(operation || ItemOperations.set, expression);
     }
 
     remove(name) {

package/src/util.js

@@ -237,10 +237,15 @@ function getFirstDefined(...params) {
   return params.find(val => val !== undefined);
 }
 
+function regexpEscape(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 module.exports = {
   getUnique,
   batchItems,
   addPadding,
+  regexpEscape,
   removePadding,
   removeFixings,
   parseJSONPath,