electrodb 1.7.1 → 1.8.1

package/CHANGELOG.md

@@ -154,4 +154,20 @@ All notable changes to this project will be documented in this file. Breaking ch
 
 ## [1.7.1] - 2022-03-19
 ### Added
-- Adding support for the v3 DyanmoDBClient. This change also brings in a new ElectroDB dependency [@aws-sdk/lib-dynamodb](https://www.npmjs.com/package/@aws-sdk/client-dynamodb). [[read more](./README.md#aws-dynamodb-client)]
+- Adding support for the v3 DyanmoDBClient. This change also brings in a new ElectroDB dependency [@aws-sdk/lib-dynamodb](https://www.npmjs.com/package/@aws-sdk/client-dynamodb). [[read more](./README.md#aws-dynamodb-client)]
+
+## [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
+
+## [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

@@ -1,3 +1,9 @@
+type Flatten<T> = T extends any[]
+  ? T
+  : T extends object
+    ? {[Key in keyof T]: Flatten<T[Key]>}
+    : T;
+
 declare const WhereSymbol: unique symbol;
 declare const UpdateDataSymbol: unique symbol;
 
@@ -987,6 +993,13 @@ interface UpdateQueryOptions extends QueryOptions {
     response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
 }
 
+interface UpdateQueryParams {
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+    table?: string;
+    params?: object;
+    originalErr?: boolean;
+}
+
 interface DeleteQueryOptions extends QueryOptions {
     response?: "default" | "none" | 'all_old';
 }
@@ -1042,7 +1055,13 @@ type SingleRecordOperationOptions<A extends string, F extends A, C extends strin
 type PutRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
     go: GoRecord<ResponseType, PutQueryOptions>;
     params: ParamRecord<PutQueryOptions>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptions<A,F,C,S,ResponseType>>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
+};
+
+type UpdateRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
+    go: GoRecord<ResponseType, UpdateQueryOptions>;
+    params: ParamRecord<UpdateQueryParams>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
 };
 
 type DeleteRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
@@ -1058,7 +1077,7 @@ type BulkRecordOperationOptions<A extends string, F extends A, C extends string,
 
 type SetRecordActionOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> = {
     go: GoRecord<Partial<TableItem>, UpdateQueryOptions>;
-    params: ParamRecord<UpdateQueryOptions>;
+    params: ParamRecord<UpdateQueryParams>;
     set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     remove: SetRecord<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
     add: SetRecord<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
@@ -1066,7 +1085,7 @@ type SetRecordActionOptions<A extends string, F extends A, C extends string, S e
     append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
-    where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,TableItem,IndexCompositeAttributes>>;
+    where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
 }
 
 type SetRecord<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> = (properties: SetAttr) => SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>;
@@ -1120,6 +1139,8 @@ type DocumentClient = {
     batchWrite: DocumentClientMethod;
     batchGet: DocumentClientMethod;
     scan: DocumentClientMethod;
+    transactGet: DocumentClientMethod;
+    transactWrite: DocumentClientMethod;
 } | {
     send: (command: any) => Promise<any>;
 }
@@ -1482,7 +1503,7 @@ export type CreateEntityItem<E extends Entity<any, any, any, any>> =
 
 export type UpdateEntityItem<E extends Entity<any, any, any, any>> =
     E extends Entity<infer A, infer F, infer C, infer S>
-        ? SetItem<A, F, C, S>
+        ? Partial<ResponseItem<A,F,C,S>>
         : never;
 
 export type UpdateAddEntityItem<E extends Entity<any, any, any, any>> =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "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/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;
 	}
 }