electrodb 1.7.2 → 1.8.2

package/CHANGELOG.md

@@ -159,4 +159,15 @@ All notable changes to this project will be documented in this file. Breaking ch
 ## [1.7.2] - 2022-03-27
 ### Fixed
 - Fixed issue#111, `update` method specific query option typing no longer lost when using a `where` method in a query chain
-- Fixing incorrect typing for exposed `UpdateEntityItem` type. Exported type was missing composite key attributes
+- Fixing incorrect typing for exposed `UpdateEntityItem` type. Exported type was missing composite key attributes
+
+## [1.8.0] - 2022-03-28
+### Added
+- Expected typings for the injected v2 client now include methods for `transactWrite` and `transactGet`
+### Changed
+- Map attributes will now always resolve to least an empty object on a `create` and `put` methods (instead of just the root map)
+- In the past, default values for property attributes on maps only resolves when a user provided an object to place the values on. Now default values within maps attributes will now always resolve onto the object on `create` and `put` methods.
+
+## [1.8.1] - 2022-03-29
+### Fixed
+- Solidifying default application methodology: default values for nested properties will be applied up until an undefined default occurs or default callback returns undefined

package/README.md

@@ -459,7 +459,7 @@ const EmployeesModel = {
 	attributes: {
 		employee: {
 			type: "string",
-			default: () => uuidv4(),
+			default: () => uuid(),
 		},
 		firstName: {
 			type: "string",
@@ -686,9 +686,9 @@ attributes: {
 Property      | Type                                                       | Required | Types     | Description
  ------------ | :--------------------------------------------------------: | :------: | :-------: | -----------
 `type`        | `string`, `ReadonlyArray<string>`, `string[]`              | yes      | all       | Accepts the values: `"string"`, `"number"` `"boolean"`, `"map"`, `"list"`, `"set"`, an array of strings representing a finite list of acceptable values: `["option1", "option2", "option3"]`, or `"any"` which disables value type checking on that attribute.
-`required`    | `boolean`                                                  | no       | all       | Flag an attribute as required to be present when creating a record. This attribute also acts as a type of `NOT NULL` flag, preventing it from being removed directly.  
+`required`    | `boolean`                                                  | no       | all       | Flag an attribute as required to be present when creating a record. This attribute also acts as a type of `NOT NULL` flag, preventing it from being removed directly. When applied to nested properties, be mindful that default map values can cause required child attributes to fail validation.
 `hidden`      | `boolean`                                                  | no       | all       | Flag an attribute as hidden to remove the property from results before they are returned. 
-`default`     | `value`, `() => value`                                     | no       | all       | Either the default value itself or a synchronous function that returns the desired value. Applied before `set` and before `required` check. 
+`default`     | `value`, `() => value`                                     | no       | all       | Either the default value itself or a synchronous function that returns the desired value. Applied before `set` and before `required` check. In the case of nested attributes, default values will apply defaults to children attributes until an undefined value is reached
 `validate`    | `RegExp`, `(value: any) => void`, `(value: any) => string` | no       | all       | Either regex or a synchronous callback to return an error string (will result in exception using the string as the error's message), or thrown exception in the event of an error.   
 `field`       | `string`                                                   | no       | all       | The name of the attribute as it exists in DynamoDB, if named differently in the schema attributes. Defaults to the `AttributeName` as defined in the schema.
 `readOnly`    | `boolean`                                                  | no       | all       | Prevents an attribute from being updated after the record has been created. Attributes used in the composition of the table's primary Partition Key and Sort Key are read-only by default. The one exception to `readOnly` is for properties that also use the `watch` property, read [attribute watching](#attribute-watching) for more detail. 

package/index.d.ts

@@ -1139,6 +1139,8 @@ type DocumentClient = {
     batchWrite: DocumentClientMethod;
     batchGet: DocumentClientMethod;
     scan: DocumentClientMethod;
+    transactGet: DocumentClientMethod;
+    transactWrite: DocumentClientMethod;
 } | {
     send: (command: any) => Promise<any>;
 }

package/package.json

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

package/src/client.js

@@ -9,7 +9,7 @@ const DocumentClientVersions = {
 };
 
 const v3Methods = ['send'];
-const v2Methods = ['get', 'put', 'update', 'delete', 'batchWrite', 'batchGet', 'scan', 'query', 'createSet'];
+const v2Methods = ['get', 'put', 'update', 'delete', 'batchWrite', 'batchGet', 'scan', 'query', 'createSet', 'transactWrite', 'transactGet'];
 const supportedClientVersions = {
     [DocumentClientVersions.v2]: v2Methods,
     [DocumentClientVersions.v3]: v3Methods,
@@ -81,6 +81,18 @@ class DocumentClientV3Wrapper {
             return this.client.send(command);
         });
     }
+    transactWrite(params) {
+        return this.promiseWrap(async () => {
+            const command = new this.lib.TransactWriteCommand(params);
+            return this.client.send(command);
+        });
+    }
+    transactGet(params) {
+        return this.promiseWrap(async () => {
+            const command = new this.lib.TransactGetCommand(params);
+            return this.client.send(command);
+        });
+    }
     createSet(value) {
         if (Array.isArray(value)) {
             return new Set(value);

package/src/entity.js

@@ -899,6 +899,18 @@ class Entity {
 		return {parameters, config};
 	}
 
+	addListeners(logger) {
+		this.eventManager.add(logger);
+	}
+
+	_addLogger(logger) {
+		if (validations.isFunction(logger)) {
+			this.addListeners(logger);
+		} else {
+			throw new e.ElectroError(e.ErrorCodes.InvalidLoggerProvided, `Logger must be of type function`);
+		}
+	}
+
 	_getPrimaryIndexFieldNames() {
 		let hasSortKey = this.model.lookup.indexHasSortKeys[TableIndex];
 		let accessPattern = this.model.translations.indexes.fromIndexToAccessPattern[TableIndex];

package/src/schema.js

@@ -575,30 +575,30 @@ class MapAttribute extends Attribute {
 			}
 			return v;
 		}
-		const valueType = getValueType(value);
-		if (value === undefined) {
-			return getValue(value);
-		} else if (value && valueType !== "object" && Object.keys(value).length === 0) {
-			return getValue(value);
+
+		let data = value === undefined
+			? getValue(value)
+			: value;
+
+		const valueType = getValueType(data);
+
+		if (data === undefined) {
+			return data;
 		} else if (valueType !== "object") {
 			throw new e.ElectroAttributeValidationError(this.path, `Invalid value type at entity path: "${this.path}". Expected value to be an object to fulfill attribute type "${this.type}"`);
 		}
 
-		const data = {};
+		const response = {};
 
 		for (const name of Object.keys(this.properties.attributes)) {
 			const attribute = this.properties.attributes[name];
-			const results = attribute.val(value[attribute.name]);
+			const results = attribute.val(data[attribute.name]);
 			if (results !== undefined) {
-				data[name] = results;
+				response[name] = results;
 			}
 		}
 
-		if (Object.keys(data).length > 0) {
-			return getValue(data);
-		} else {
-			return getValue();
-		}
+		return response;
 	}
 }
 
@@ -726,28 +726,25 @@ class ListAttribute extends Attribute {
 			return v;
 		}
 
-		if (value === undefined) {
-			return this.default();
-		} else if (Array.isArray(value) && value.length === 0) {
-			return value;
-		} else if (!Array.isArray(value)) {
+		const data = value === undefined
+			? getValue(value)
+			: value;
+
+		if (data === undefined) {
+			return data;
+		} else if (!Array.isArray(data)) {
 			throw new e.ElectroAttributeValidationError(this.path, `Invalid value type at entity path "${this.path}. Received value of type "${getValueType(value)}", expected value of type "array"`);
 		}
 
-		const data = [];
-
-		for (const v of value) {
-			const results = this.items.val(v);
+		const response = [];
+		for (const d of data) {
+			const results = this.items.val(d);
 			if (results !== undefined) {
-				data.push(results);
+				response.push(results);
 			}
 		}
 
-		if (data.filter(value => value !== undefined).length > 0) {
-			return getValue(data);
-		} else {
-			return getValue();
-		}
+		return response;
 	}
 }
 

package/src/service.js

@@ -191,6 +191,14 @@ class Service {
 			entity._setClient(options.client);
 		}
 
+		if (options.logger) {
+			entity._addLogger(options.logger);
+		}
+
+		if (options.listeners) {
+			entity.addListeners(options.listeners);
+		}
+
 		if (this._modelVersion === ModelVersions.beta && this.service.version) {
 			entity.model.version = this.service.version;
 		}