electrodb 2.6.1 → 2.7.1

package/index.d.ts

@@ -156,8 +156,8 @@ export interface CollectionWhereOperations {
     begins: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     exists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
     notExists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V extends Array<infer I> ? I : V : never) => string;
+    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V extends Array<infer I> ? I : V : never) => string;
     value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     name: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
     size: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
@@ -601,6 +601,11 @@ export type ElectroEventListener = (event: ElectroEvent) => void;
 //     details: any;
 // };
 
+export type EntityIdentifiers<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? AllTableIndexCompositeAttributes<A, F, C, S>
+        : never;
+
 export type EntityItem<E extends Entity<any, any, any, any>> =
     E extends Entity<infer A, infer F, infer C, infer S>
         ? ResponseItem<A, F, C, S>
@@ -621,9 +626,14 @@ export type BatchGetEntityItem<E extends Entity<any, any, any, any>> =
         ? ResponseItem<A, F, C, S>[]
         : never;
 
+export type UpdateEntityResponseItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? AllTableIndexCompositeAttributes<A,F,C,S>
+        : never;
+
 export type UpdateEntityItem<E extends Entity<any, any, any, any>> =
     E extends Entity<infer A, infer F, infer C, infer S>
-        ? Partial<ResponseItem<A,F,C,S>>
+        ? SetItem<A,F,C,S>
         : never;
 
 export type UpdateAddEntityItem<E extends Entity<any, any, any, any>> =
@@ -692,7 +702,7 @@ export type BatchGetResponse<E extends Entity<any, any, any, any>> =
     } : never;
 
 export type UpdateEntityResponse<E extends Entity<any, any, any, any>> = {
-    data: UpdateEntityItem<E>;
+    data: UpdateEntityResponseItem<E>;
 }
 export type UpdateAddEntityResponse<E extends Entity<any, any, any, any>> = {
     data: UpdateAddEntityItem<E>;
@@ -793,7 +803,7 @@ export type UpdateRecordGoTransaction<ResponseType> = <T = ResponseType, Options
 export interface SetRecordActionOptionsTransaction<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> {
     commit: UpdateRecordGoTransaction<TableItem>;
     params: ParamRecord<UpdateQueryParams>;
-    set: SetRecordTransaction<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    set: SetRecordTransaction<A,F,C,S, SetItem<A,F,C,S>, IndexCompositeAttributes, TableItem>;
     remove: RemoveRecordTransaction<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
     add: SetRecordTransaction<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     subtract: SetRecordTransaction<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
@@ -818,19 +828,19 @@ export interface BatchGetRecordOperationOptions<A extends string, F extends stri
 }
 
 export interface PutRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
-    go: PutRecordGo<ResponseType, PutQueryOptions>;
+    go: PutRecordGo<ResponseType>;
     params: ParamRecord<PutQueryOptions>;
     where: WhereClause<A, F, C, S, Item<A, F, C, S, S["attributes"]>, PutRecordOperationOptions<A, F, C, S, ResponseType>>;
 }
 
 export interface UpsertRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
-    go: PutRecordGo<ResponseType, UpdateQueryParams>;
+    go: UpsertRecordGo<ResponseType, AllTableIndexCompositeAttributes<A,F,C,S>>;
     params: ParamRecord<UpdateQueryParams>;
     where: WhereClause<A, F, C, S, Item<A, F, C, S, S["attributes"]>, UpsertRecordOperationOptions<A, F, C, S, ResponseType>>;
 }
 
 export interface DeleteRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
-    go: DeleteRecordOperationGo<ResponseType, DeleteQueryOptions>;
+    go: DeleteRecordOperationGo<ResponseType, AllTableIndexCompositeAttributes<A,F,C,S>>;
     params: ParamRecord<DeleteQueryOptions>;
     where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,DeleteRecordOperationOptions<A,F,C,S,ResponseType>>;
 }
@@ -841,9 +851,10 @@ export interface BatchWriteOperationOptions<A extends string, F extends string,
 }
 
 export interface SetRecordActionOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> {
-    go: UpdateRecordGo<TableItem>;
+    go: UpdateRecordGo<TableItem, AllTableIndexCompositeAttributes<A,F,C,S>>;
     params: ParamRecord<UpdateQueryParams>;
-    set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes, TableItem>;
+    // ifNotExists: 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>;
     subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
@@ -1005,7 +1016,7 @@ export interface DeleteQueryOptions extends QueryOptions {
 }
 
 export interface PutQueryOptions extends QueryOptions {
-    response?: "default" | "none" | 'all_old';
+    response?: "default" | "none" | 'all_old' | 'all_new';
 }
 
 export interface ParamOptions {
@@ -1206,20 +1217,52 @@ export type ServiceQueryRecordsGo<ResponseType, Options = ServiceQueryGoTerminal
 
 export type QueryRecordsGo<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<{ data: T, cursor: string | null }>;
 
-export type UpdateRecordGo<ResponseType> = <T = ResponseType, Options extends UpdateQueryOptions = UpdateQueryOptions>(options?: Options) =>
+export type UpdateRecordGo<ResponseType, Keys> = <T = ResponseType, Options extends UpdateQueryOptions = UpdateQueryOptions>(options?: Options) =>
     Options extends infer O
         ? 'response' extends keyof O
-        ? O['response'] extends 'all_new'
-            ? Promise<{data: T}>
-            : O['response'] extends 'all_old'
-                ? Promise<{data: T}>
-                : Promise<{data: Partial<T>}>
-        : Promise<{data: Partial<T>}>
+            ? O['response'] extends 'all_new'
+                ? Promise<{ data: T }>
+                : O['response'] extends 'all_old'
+                    ? Promise<{ data: T }>
+                    : O['response'] extends 'default'
+                        ? Promise<{ data: Keys }>
+                        : O['response'] extends 'none'
+                            ? Promise<{ data: null }>
+                            : Promise<{ data: Partial<T> }>
+            : Promise<{ data: Keys }>
         : never;
 
-export type PutRecordGo<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<{ data: T }>;
+export type UpsertRecordGo<ResponseType, Keys> = <T = ResponseType, Options extends UpdateQueryOptions = UpdateQueryOptions>(options?: Options) =>
+    Options extends infer O
+        ? 'response' extends keyof O
+            ? O['response'] extends 'all_new'
+                ? Promise<{ data: T }>
+                : O['response'] extends 'all_old'
+                    ? Promise<{ data: T }>
+                    : O['response'] extends 'default'
+                        ? Promise<{ data: Keys }>
+                            : O['response'] extends 'none'
+                                ? Promise<{ data: null }>
+                                : Promise<{ data: Partial<T> }>
+            : Promise<{ data: Keys }>
+        : never;
 
-export type DeleteRecordOperationGo<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<{ data: T }>;
+export type PutRecordGo<ResponseType> = <T = ResponseType, Options extends PutQueryOptions = PutQueryOptions>(options?: Options) => Promise<{ data: T }>
+
+export type DeleteRecordOperationGo<ResponseType, Keys> = <T = ResponseType, Options extends DeleteQueryOptions = DeleteQueryOptions>(options?: Options) =>
+    Options extends infer O
+        ? 'response' extends keyof O
+        ? O['response'] extends 'all_new'
+            ? Promise<{ data: T }>
+            : O['response'] extends 'all_old'
+                ? Promise<{ data: T }>
+                : O['response'] extends 'default'
+                    ? Promise<{ data: Keys }>
+                    : O['response'] extends 'none'
+                        ? Promise<{ data: null }>
+                        : Promise<{ data: Partial<T> }>
+        : Promise<{ data: Keys }>
+        : never;
 
 export type BatchWriteGo<ResponseType> = <O extends BulkOptions>(options?: O) =>
     Promise<{ unprocessed: ResponseType }>
@@ -2419,8 +2462,8 @@ export interface WhereOperations<A extends string, F extends string, C extends s
     begins: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     exists: <A extends WhereAttributeSymbol<any>>(attr: A) => string;
     notExists: <A extends WhereAttributeSymbol<any>>(attr: A) => string;
-    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V extends Array<infer I> ? I : V : never) => string;
+    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V extends Array<infer I> ? I : V : never) => string;
     value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V : never) => A extends WhereAttributeSymbol<infer V> ? V : never;
     name: <A extends WhereAttributeSymbol<any>>(attr: A) => string;
     size: <T, A extends WhereAttributeSymbol<T>>(attr: A) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.6.1",
+  "version": "2.7.1",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {
@@ -12,7 +12,8 @@
     "coverage:local:coveralls": "npm run test:init && nyc npm run test:unit && nyc report --reporter=text-lcov | coveralls",
     "coverage:local:html": "npm run test:init && nyc npm run test:unit && nyc report --reporter=html",
     "build:browser": "browserify playground/browser.js -o playground/bundle.js",
-    "build": "sh buildbrowser.sh"
+    "build": "sh buildbrowser.sh",
+    "start:containers": "docker compose up -d"
   },
   "repository": {
     "type": "git",

package/src/clauses.js

@@ -185,13 +185,17 @@ let clauses = {
 			}
 			try {
 				const {pk, sk} = state.getCompositeAttributes();
+				const pkComposite = entity._expectFacets(facets, pk);
+				state.addOption('_includeOnResponseItem', pkComposite);
 				return state
 					.setMethod(MethodTypes.delete)
 					.setType(QueryTypes.eq)
-					.setPK(entity._expectFacets(facets, pk))
+					.setPK(pkComposite)
 					.ifSK(() => {
 						entity._expectFacets(facets, sk);
-						state.setSK(state.buildQueryComposites(facets, sk));
+						const skComposite = state.buildQueryComposites(facets, sk);
+						state.setSK(skComposite);
+						state.addOption('_includeOnResponseItem', {...skComposite, ...pkComposite});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -215,13 +219,17 @@ let clauses = {
 				if (sk) {
 					filter.unsafeSet(FilterOperationNames.exists, sk);
 				}
+				const pkComposite = entity._expectFacets(facets, attributes.pk);
+				state.addOption('_includeOnResponseItem', pkComposite);
 				return state
 					.setMethod(MethodTypes.delete)
 					.setType(QueryTypes.eq)
-					.setPK(entity._expectFacets(facets, attributes.pk))
+					.setPK(pkComposite)
 					.ifSK(() => {
 						entity._expectFacets(facets, attributes.sk);
-						state.setSK(state.buildQueryComposites(facets, attributes.sk));
+						const skComposite = state.buildQueryComposites(facets, attributes.sk);
+						state.setSK(skComposite);
+						state.addOption('_includeOnResponseItem', {...skComposite, ...pkComposite});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -239,14 +247,18 @@ let clauses = {
 			try {
 				let record = entity.model.schema.checkCreate({...payload});
 				const attributes = state.getCompositeAttributes();
+				const pkComposite = entity._expectFacets(record, attributes.pk);
+				state.addOption('_includeOnResponseItem', pkComposite);
 				return state
 					.setMethod(MethodTypes.upsert)
 					.setType(QueryTypes.eq)
 					.applyUpsert(record)
-					.setPK(entity._expectFacets(record, attributes.pk))
+					.setPK(pkComposite)
 					.ifSK(() => {
 						entity._expectFacets(record, attributes.sk);
-						state.setSK(entity._buildQueryFacets(record, attributes.sk));
+						const skComposite = entity._buildQueryFacets(record, attributes.sk);
+						state.setSK(skComposite);
+						state.addOption('_includeOnResponseItem', {...skComposite, ...pkComposite});
 					})
 					.whenOptions(({ state, options }) => {
 						if (!state.getParams()) {
@@ -337,13 +349,17 @@ let clauses = {
 				if (sk) {
 					filter.unsafeSet(FilterOperationNames.exists, sk);
 				}
+				const pkComposite = entity._expectFacets(facets, attributes.pk);
+				state.addOption('_includeOnResponseItem', pkComposite);
 				return state
 					.setMethod(MethodTypes.update)
 					.setType(QueryTypes.eq)
-					.setPK(entity._expectFacets(facets, attributes.pk))
+					.setPK(pkComposite)
 					.ifSK(() => {
 						entity._expectFacets(facets, attributes.sk);
-						state.setSK(state.buildQueryComposites(facets, attributes.sk));
+						const skComposite = state.buildQueryComposites(facets, attributes.sk);
+						state.setSK(skComposite);
+						state.addOption('_includeOnResponseItem', {...skComposite, ...pkComposite});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -360,13 +376,17 @@ let clauses = {
 			}
 			try {
 				const attributes = state.getCompositeAttributes();
+				const pkComposite = entity._expectFacets(facets, attributes.pk);
+				state.addOption('_includeOnResponseItem', pkComposite);
 				return state
 					.setMethod(MethodTypes.update)
 					.setType(QueryTypes.eq)
-					.setPK(entity._expectFacets(facets, attributes.pk))
+					.setPK(pkComposite)
 					.ifSK(() => {
 						entity._expectFacets(facets, attributes.sk);
-						state.setSK(state.buildQueryComposites(facets, attributes.sk));
+						const skComposite = state.buildQueryComposites(facets, attributes.sk);
+						state.setSK(skComposite);
+						state.addOption('_includeOnResponseItem', {...pkComposite, ...skComposite});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -808,7 +828,8 @@ class ChainState {
 				data: {},
 			},
 			upsert: {
-				data: {}
+				data: {},
+				ifNotExists: {},
 			},
 			keys: {
 				provided: [],
@@ -1018,8 +1039,12 @@ class ChainState {
 		}
 	}
 
-	applyUpsert(data = {}) {
-		this.query.upsert.data = {...this.query.upsert.data, ...data};
+	applyUpsert(data = {}, { ifNotExists } = {}) {
+		if (ifNotExists) {
+			this.query.upsert.ifNotExists = {...this.query.upsert.ifNotExists, ...data};
+		} else {
+			this.query.upsert.data = {...this.query.upsert.data, ...data};
+		}
 		return this;
 	}
 

package/src/entity.js

@@ -673,7 +673,7 @@ class Entity {
 			case MethodTypes.delete:
 			case MethodTypes.remove:
 			case MethodTypes.upsert:
-				return this.formatResponse(response, index, {...config, _objectOnEmpty: true});
+				return this.formatResponse(response, index, { ...config, _objectOnEmpty: true });
 			default:
 				return this.formatResponse(response, index, config);
 		}
@@ -814,7 +814,11 @@ class Entity {
 						results = null;
 					}
 				} else if (config._objectOnEmpty) {
-					return { data: {} };
+					return {
+						data: {
+							...config._includeOnResponseItem,
+						}
+					};
 				} else {
 					results = null;
 				}
@@ -1342,6 +1346,7 @@ class Entity {
 			order: undefined,
 			hydrate: false,
 			hydrator: (_entity, _indexName, items) => items,
+			_includeOnResponseItem: {},
 		};
 
 		return provided.filter(Boolean).reduce((config, option) => {
@@ -1503,6 +1508,13 @@ class Entity {
 				config.hydrator = option.hydrator;
 			}
 
+			if (option._includeOnResponseItem) {
+				config._includeOnResponseItem = {
+					...config._includeOnResponseItem,
+					...option._includeOnResponseItem,
+				}
+			}
+
 			config.page = Object.assign({}, config.page, option.page);
 			config.params = Object.assign({}, config.params, option.params);
 			return config;
@@ -1951,12 +1963,18 @@ class Entity {
 		const { updatedKeys, setAttributes, indexKey } = this._getPutKeys(pk, sk && sk.facets, upsert.data);
 		const upsertAttributes = this.model.schema.translateToFields(setAttributes);
 		const keyNames = Object.keys(indexKey);
-		// update.set(this.identifiers.entity, this.getName());
-		// update.set(this.identifiers.version, this.getVersion());
 		for (const field of [...Object.keys(upsertAttributes), ...Object.keys(updatedKeys)]) {
 			const value = u.getFirstDefined(upsertAttributes[field], updatedKeys[field]);
 			if (!keyNames.includes(field)) {
-				update.set(field, value);
+				let operation = ItemOperations.set;
+				const name = this.model.schema.translationForRetrieval[field];
+				if (name) {
+					const attribute = this.model.schema.attributes[name];
+					if (this.model.schema.readOnlyAttributes.has(name) && (!attribute || !attribute.indexes || attribute.indexes.length === 0)) {
+						operation = ItemOperations.ifNotExists;
+					}
+				}
+				update.set(field, value, operation);
 			}
 		}
 

package/src/schema.js

@@ -1429,15 +1429,14 @@ class Schema {
 			: attribute.getValidate(value);
 	}
 
-	checkUpdate(payload = {}) {
+	checkUpdate(payload = {}, { allowReadOnly } = {}) {
 		let record = {};
 		for (let [path, attribute] of this.traverser.getAll()) {
 			let value = payload[path];
 			if (value === undefined) {
 				continue;
 			}
-			if (attribute.readOnly) {
-				// todo: #electroerror
+			if (attribute.readOnly && !allowReadOnly) {
 				throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Read-Only and cannot be updated`);
 			} else {
 				record[path] = attribute.getValidate(value);

package/src/types.js

@@ -217,6 +217,7 @@ const ItemOperations = {
 	"add": "add",
 	"subtract": "subtract",
 	"append": "append",
+	"ifNotExists": "ifNotExists"
 };
 
 const AttributeProxySymbol = Symbol("attribute_proxy");

package/src/update.js

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

package/.travis.yml

@@ -1,15 +0,0 @@
-language: node_js
-
-services:
-  - docker
-
-before_install:
-  - docker pull amazon/dynamodb-local
-  - docker run -p 8000:8000 --name dynamodb -d amazon/dynamodb-local
-  - docker ps -a
-
-node_js:
-  - '16'
-
-script:
-  - npm run coverage:local:coveralls