electrodb 2.1.2 → 2.2.1

package/src/schema.js

@@ -524,15 +524,22 @@ class MapAttribute extends Attribute {
 			traverser: this.traverser
 		});
 		this.properties = properties;
+		this.isRoot = !!definition.isRoot;
 		this.get = this._makeGet(definition.get, properties);
 		this.set = this._makeSet(definition.set, properties);
 	}
 
 	_makeGet(get, properties) {
 		this._checkGetSet(get, "get");
-
-		const getter = get || ((attr) => attr);
-
+		const getter = get || ((val) => {
+			const isEmpty = !val || Object.keys(val).length === 0;
+			const isNotRequired = !this.required;
+			const isRoot = this.isRoot;
+			if (isEmpty && isRoot && !isNotRequired) {
+				return undefined;
+			}
+			return val;
+		});
 		return (values, siblings) => {
 			const data = {};
 
@@ -541,6 +548,9 @@ class MapAttribute extends Attribute {
 			}
 
 			if (values === undefined) {
+				if (!get) {
+					return undefined;
+				}
 				return getter(data, siblings);
 			}
 
@@ -561,11 +571,23 @@ class MapAttribute extends Attribute {
 
 	_makeSet(set, properties) {
 		this._checkGetSet(set, "set");
-		const setter = set || ((attr) => attr);
+		const setter = set || ((val) => {
+			const isEmpty = !val || Object.keys(val).length === 0;
+			const isNotRequired = !this.required;
+			const isRoot = this.isRoot;
+			if (isEmpty && isRoot && !isNotRequired) {
+				return undefined;
+			}
+			return val;
+		});
+
 		return (values, siblings) => {
 			const data = {};
 			if (values === undefined) {
-				return setter(data, siblings);
+				if (!set) {
+					return undefined;
+				}
+				return setter(values, siblings);
 			}
 			for (const name of Object.keys(properties.attributes)) {
 				const attribute = properties.attributes[name];
@@ -624,18 +646,18 @@ class MapAttribute extends Attribute {
 	}
 
 	val(value) {
-		const getValue = (v) => {
-			v = this.cast(v);
-			if (v === undefined) {
-				v = this.default();
+		const incomingIsEmpty = value === undefined;
+		let fromDefault = false;
+		let data;
+		if (value === undefined) {
+			data = this.default();
+			if (data !== undefined) {
+				fromDefault = true;
 			}
-			return v;
+		} else {
+			data = value;
 		}
 
-		let data = value === undefined
-			? getValue(value)
-			: value;
-
 		const valueType = getValueType(data);
 
 		if (data === undefined) {
@@ -654,6 +676,10 @@ class MapAttribute extends Attribute {
 			}
 		}
 
+		if (Object.keys(response).length === 0 && !fromDefault && this.isRoot && !this.required && incomingIsEmpty) {
+			return undefined;
+		}
+
 		return response;
 	}
 }
@@ -959,9 +985,9 @@ class SetAttribute extends Attribute {
 }
 
 class Schema {
-	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), client, parent} = {}) {
+	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), client, parent, isRoot} = {}) {
 		this._validateProperties(properties, parent);
-		let schema = Schema.normalizeAttributes(properties, facets, {traverser, client, parent});
+		let schema = Schema.normalizeAttributes(properties, facets, {traverser, client, parent, isRoot});
 		this.client = client;
 		this.attributes = schema.attributes;
 		this.enums = schema.enums;
@@ -972,9 +998,10 @@ class Schema {
 		this.requiredAttributes = schema.requiredAttributes;
 		this.translationForWatching = this._formatWatchTranslations(this.attributes);
 		this.traverser = traverser;
+		this.isRoot = !!isRoot;
 	}
 
-	static normalizeAttributes(attributes = {}, facets = {}, {traverser, client, parent} = {}) {
+	static normalizeAttributes(attributes = {}, facets = {}, {traverser, client, parent, isRoot} = {}) {
 		const attributeHasParent = !!parent;
 		let invalidProperties = [];
 		let normalized = {};
@@ -1073,6 +1100,7 @@ class Schema {
 				postfix,
 				traverser,
 				isKeyField,
+				isRoot: !!isRoot,
 				label: attribute.label,
 				required: !!attribute.required,
 				default: attribute.default,

package/src/service.js

@@ -1,6 +1,6 @@
 const { Entity } = require("./entity");
 const { clauses } = require("./clauses");
-const { KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions } = require("./types");
+const { KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions, IndexTypes } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
 const { WhereFactory } = require("./where");
@@ -65,7 +65,9 @@ class Service {
 		this.entities = {};
 		this.find = {};
 		this.collectionSchema = {};
+		this.compositeAttributes = {};
 		this.collections = {};
+		this.identifiers = {};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -89,7 +91,9 @@ class Service {
 		this.entities = {};
 		this.find = {};
 		this.collectionSchema = {};
+		this.compositeAttributes = {};
 		this.collections = {};
+		this.identifiers = {};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -183,12 +187,12 @@ class Service {
 			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Service name defined on joined instance, ${entity.model.service}, does not match the name of this Service: ${this.service.name}. Verify or update the service name on the Entity/Model to match the name defined on this service.`);
 		}
 
-		if (this._getTableName()) {
-			entity._setTableName(this._getTableName());
+		if (this.getTableName()) {
+			entity.setTableName(this.getTableName());
 		}
 
 		if (options.client) {
-			entity._setClient(options.client);
+			entity.setClient(options.client);
 		}
 
 		if (options.logger) {
@@ -205,20 +209,63 @@ class Service {
 
 		this.entities[name] = entity;
 		for (let collection of this.entities[name].model.collections) {
+			// todo: this used to be inside the collection callback, it does not do well being ran multiple times
+			// this forlook adds the entity filters multiple times
 			this._addCollectionEntity(collection, name, this.entities[name]);
 			this.collections[collection] = (...facets) => {
-				let { entities, attributes, identifiers } = this.collectionSchema[collection];
-				return this._makeCollectionChain(collection, attributes, clauses, identifiers, entities, Object.values(entities)[0], ...facets);
+				return this._makeCollectionChain({
+					name: collection,
+					initialClauses: clauses,
+				}, ...facets);
 			};
 		}
+		for (const collection in this.collectionSchema) {
+			const collectionSchema = this.collectionSchema[collection];
+			this.compositeAttributes[collection] = this._collectionSchemaToCompositeAttributes(collectionSchema);
+		}
 		this.find = { ...this.entities, ...this.collections };
 		return this;
 	}
 
-	_setClient(client) {
+	_collectionSchemaToCompositeAttributes(schema) {
+		const keys = schema.keys;
+		return {
+			hasSortKeys: keys.hasSk,
+			customFacets: {
+				pk: keys.pk.isCustom,
+				sk: keys.sk.isCustom,
+			},
+			pk: keys.pk.facets,
+			sk: keys.sk.facets,
+			all: [
+				...keys.pk.facets.map(name => {
+					return {
+						name,
+						index: keys.index,
+						type: 'pk',
+					};
+				}),
+				...keys.sk.facets.map(name => {
+					return {
+						name,
+						index: keys.index,
+						type: 'sk',
+					};
+				})
+			],
+			collection: keys.collection,
+			hasSubCollections: schema.hasSubCollections,
+			casing: {
+				pk: keys.pk.casing,
+				sk: keys.sk.casing,
+			},
+		}
+	}
+
+	setClient(client) {
 		if (client !== undefined) {
 			for (let entity of Object.values(this.entities)) {
-				entity._setClient(client);
+				entity.setClient(client);
 			}
 		}
 	}
@@ -275,8 +322,9 @@ class Service {
 	}
 
 	findKeyOwner(lastEvaluatedKey) {
-		return Object.values(this.entities)
-			.find((entity) => entity.ownsLastEvaluatedKey(lastEvaluatedKey));
+		return Object.values(this.entities)[0];
+		// return Object.values(this.entities)
+		// 	.find((entity) => entity.ownsLastEvaluatedKey(lastEvaluatedKey));
 	}
 
 	expectKeyOwner(lastEvaluatedKey) {
@@ -288,8 +336,9 @@ class Service {
 	}
 
 	findCursorOwner(cursor) {
-		return Object.values(this.entities)
-			.find(entity => entity.ownsCursor(cursor));
+		return Object.values(this.entities)[0];
+		// return Object.values(this.entities)
+		// 	.find(entity => entity.ownsCursor(cursor));
 	}
 
 	expectCursorOwner(cursor) {
@@ -300,18 +349,26 @@ class Service {
 		return owner;
 	}
 
-	_getTableName() {
+	getTableName() {
 		return this.service.table;
 	}
 
-	_setTableName(table) {
+	setTableName(table) {
 		this.service.table = table;
 		for (let entity of Object.values(this.entities)) {
-			entity._setTableName(table);
+			entity.setTableName(table);
 		}
 	}
 
-	_makeCollectionChain(name = "", attributes = {}, initialClauses = {}, expressions = {}, entities = {}, entity = {}, facets = {}) {
+	_makeCollectionChain({
+		name = "",
+		initialClauses = {},
+	}, facets = {}) {
+		const { entities, attributes, identifiers, indexType } = this.collectionSchema[name];
+		const compositeAttributes = this.compositeAttributes[name];
+		const allEntities = Object.values(entities);
+		const entity = allEntities[0];
+
 		let filterBuilder = new FilterFactory(attributes, FilterOperations);
 		let whereBuilder = new WhereFactory(attributes, FilterOperations);
 		let clauses = {...initialClauses};
@@ -319,6 +376,8 @@ class Service {
 		clauses = filterBuilder.injectFilterClauses(clauses);
 		clauses = whereBuilder.injectWhereClauses(clauses);
 
+		const expression = identifiers.expression || "";
+
 		let options = {
 			// expressions, // DynamoDB doesnt return what I expect it would when provided with these entity filters
 			parse: (options, data) => {
@@ -329,9 +388,20 @@ class Service {
 					return this.expectKeyOwner(key).serializeCursor(key);
 				},
 				deserialize: (cursor) => {
-					return this.expectCursorOwner(cursor).deserilizeCursor(cursor);
+					return this.expectCursorOwner(cursor).deserializeCursor(cursor);
 				}
-			}
+			},
+			expressions: {
+				names: identifiers.names || {},
+				values: identifiers.values || {},
+				expression: allEntities.length > 1
+					? `(${expression})`
+					: expression
+			},
+			attributes,
+			entities,
+			indexType,
+			compositeAttributes,
 		};
 
 		return entity.collection(name, clauses, facets, options);
@@ -477,7 +547,33 @@ class Service {
 		if (invalidDefinition) {
 			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Validation Error while joining entity, "${name}". ${invalidIndexMessages.join(", ")}`);
 		}
-		return definition;
+		const sharedSortKeyAttributes = [];
+		const sharedSortKeyCompositeAttributeLabels = [];
+		const sharedSortKeyLabels = [];
+		if (providedIndex.hasSk && definition.hasSk && Array.isArray(definition.sk.labels)) {
+			for (let i = 0; i < definition.sk.labels.length; i++) {
+				const providedLabels = providedIndex.sk.labels[i];
+				const definedLabels = definition.sk.labels[i];
+
+				const namesMatch = providedLabels && providedLabels.name === definedLabels.name;
+				const labelsMatch = providedLabels && providedLabels.label === definedLabels.label;
+				if (!namesMatch || !labelsMatch) {
+					break;
+				}
+				sharedSortKeyLabels.push({...definedLabels});
+				sharedSortKeyCompositeAttributeLabels.push({...definition.sk.facetLabels[i]})
+				sharedSortKeyAttributes.push(definition.sk.facets[i]);
+			}
+		}
+		return {
+			...definition,
+			sk: {
+				...definition.sk,
+				facets: sharedSortKeyAttributes,
+				facetLabels: sharedSortKeyCompositeAttributeLabels,
+				labels: sharedSortKeyLabels,
+			}
+		};
 	}
 
 	_getEntityIndexFromCollectionName(collection, entity) {
@@ -506,7 +602,7 @@ class Service {
 		);
 	}
 
-	_processSubCollections(existing, provided, entityName, collectionName) {
+	_processSubCollections(providedType, existing, provided, entityName, collectionName) {
 		let existingSubCollections;
 		let providedSubCollections;
 		if (v.isArrayHasLength(existing)) {
@@ -520,15 +616,19 @@ class Service {
 			providedSubCollections = [provided];
 		}
 
+		if (providedSubCollections.length > 1 && providedType === IndexTypes.clustered) {
+			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Clustered indexes do not support sub-collections. The sub-collection "${collectionName}", on Entity "${entityName}" must be defined as either an individual collection name or the index must be redefined as an isolated cluster`);
+		}
 		const existingRequiredIndex = existingSubCollections.indexOf(collectionName);
 		const providedRequiredIndex = providedSubCollections.indexOf(collectionName);
 		if (providedRequiredIndex < 0) {
-			throw new Error(`The collection definition for Collection "${collectionName}" does not exist on Entity "${entityName}".`);
+			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `The collection definition for Collection "${collectionName}" does not exist on Entity "${entityName}".`);
 		}
 		if (existingRequiredIndex >= 0 && existingRequiredIndex !== providedRequiredIndex) {
-			throw new Error(`The collection definition for Collection "${collectionName}", on Entity "${entityName}", does not match the established sub-collection order for this service. The collection name provided in slot ${providedRequiredIndex + 1}, ${providedSubCollections[existingRequiredIndex] === undefined ? '(not found)' : `"${providedSubCollections[existingRequiredIndex]}"`}, on Entity "${entityName}", does not match the established collection name in slot ${existingRequiredIndex + 1}, "${collectionName}". When using sub-collections, all Entities within a Service must must implement the same order for all preceding sub-collections.`);
+			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `The collection definition for Collection "${collectionName}", on Entity "${entityName}", does not match the established sub-collection order for this service. The collection name provided in slot ${providedRequiredIndex + 1}, ${providedSubCollections[existingRequiredIndex] === undefined ? '(not found)' : `"${providedSubCollections[existingRequiredIndex]}"`}, on Entity "${entityName}", does not match the established collection name in slot ${existingRequiredIndex + 1}, "${collectionName}". When using sub-collections, all Entities within a Service must must implement the same order for all preceding sub-collections.`);
 		}
 		let length = Math.max(existingRequiredIndex, providedRequiredIndex);
+
 		for (let i = 0; i <= length; i++) {
 			let existingCollection = existingSubCollections[i];
 			let providedCollection = providedSubCollections[i];
@@ -537,7 +637,7 @@ class Service {
 					return i;
 				}
 				if (existingCollection !== providedCollection) {
-					throw new Error(`The collection definition for Collection "${collectionName}", on Entity "${entityName}", does not match the established sub-collection order for this service. The collection name provided in slot ${i+1}, "${providedCollection}", on Entity "${entityName}", does not match the established collection name in slot ${i + 1}, "${existingCollection}". When using sub-collections, all Entities within a Service must must implement the same order for all preceding sub-collections.`);
+					throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `The collection definition for Collection "${collectionName}", on Entity "${entityName}", does not match the established sub-collection order for this service. The collection name provided in slot ${i+1}, "${providedCollection}", on Entity "${entityName}", does not match the established collection name in slot ${i + 1}, "${existingCollection}". When using sub-collections, all Entities within a Service must must implement the same order for all preceding sub-collections.`);
 				}
 			} else if (v.isStringHasLength(providedCollection)) {
 				if (providedCollection === collectionName) {
@@ -564,27 +664,43 @@ class Service {
 			},
 			index: undefined,
 			table: "",
-			collection: []
+			collection: [],
+			indexType: undefined,
+			hasSubCollections: undefined,
 		};
+		const providedType = providedIndex.type || IndexTypes.isolated;
+		if (this.collectionSchema[collection].indexType === undefined) {
+			this.collectionSchema[collection].indexType = providedType;
+		} else if (this.collectionSchema[collection].indexType !== providedType) {
+			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Index type mismatch on collection ${collection}. The entity ${name} defines the index as type ${providedType} while the established type for that index is ${this.collectionSchema[collection].indexType}. Note that when omitted, indexes default to the type "${IndexTypes.isolated}"`);
+		}
 		if (this.collectionSchema[collection].entities[name] !== undefined) {
 			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Entity with name '${name}' has already been joined to this service.`);
 		}
 
 		if (this.collectionSchema[collection].table !== "") {
-			if (this.collectionSchema[collection].table !== entity._getTableName()) {
-				throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Entity with name '${name}' is defined to use a different Table than what is defined on other Service Entities and/or the Service itself. Entity '${name}' is defined with table name '${entity._getTableName()}' but the Service has been defined to use table name '${this.collectionSchema[collection].table}'. All Entities in a Service must reference the same DynamoDB table. To ensure all Entities will use the same DynamoDB table, it is possible to apply the property 'table' to the Service constructor's configuration parameter.`);
+			if (this.collectionSchema[collection].table !== entity.getTableName()) {
+				throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Entity with name '${name}' is defined to use a different Table than what is defined on other Service Entities and/or the Service itself. Entity '${name}' is defined with table name '${entity.getTableName()}' but the Service has been defined to use table name '${this.collectionSchema[collection].table}'. All Entities in a Service must reference the same DynamoDB table. To ensure all Entities will use the same DynamoDB table, it is possible to apply the property 'table' to the Service constructor's configuration parameter.`);
 			}
 		} else {
-			this.collectionSchema[collection].table = entity._getTableName();
+			this.collectionSchema[collection].table = entity.getTableName();
 		}
+
 		this.collectionSchema[collection].keys = this._processEntityKeys(name, this.collectionSchema[collection].keys, providedIndex);
 		this.collectionSchema[collection].attributes = this._processEntityAttributes(name, this.collectionSchema[collection].attributes, entity.model.schema.attributes, this.collectionSchema[collection].keys);
 		this.collectionSchema[collection].entities[name] = entity;
 		this.collectionSchema[collection].identifiers = this._processEntityIdentifiers(this.collectionSchema[collection].identifiers, entity.getIdentifierExpressions(name));
 		this.collectionSchema[collection].index = this._processEntityCollectionIndex(this.collectionSchema[collection].index, providedIndex.index, name, collection);
-		let collectionIndex = this._processSubCollections(this.collectionSchema[collection].collection, providedIndex.collection, name, collection);
+		let collectionIndex = this._processSubCollections(
+			providedType,
+			this.collectionSchema[collection].collection,
+			providedIndex.collection,
+			name,
+			collection
+		);
 		this.collectionSchema[collection].collection[collectionIndex] = collection;
-
+		this.collectionSchema[collection].hasSubCollections = this.collectionSchema[collection].hasSubCollections || Array.isArray(providedIndex.collection);
+		return this.collectionSchema[collection];
 	}
 
 	_processEntityCollectionIndex(existing, provided, name, collection) {

package/src/types.js

@@ -18,6 +18,7 @@ const QueryTypes = {
 	begins: "begins",
 	between: "between",
 	collection: "collection",
+	clustered_collection: 'clustered_collection',
 	is: "is"
 };
 
@@ -36,11 +37,62 @@ const MethodTypes = {
 	batchWrite: "batchWrite"
 };
 
+const IndexTypes = {
+	isolated: 'isolated',
+	clustered: 'clustered',
+}
+
 const Comparisons = {
+	lte: '<=',
+	lt: "<",
 	gte: ">=",
-	gt: ">",
-	lte: "<=",
+	gt: '>'
+}
+
+const PartialComparisons = {
 	lt: "<",
+	gte: ">=",
+
+	/**
+	 * gt becomes gte and last character of incoming value is shifted up one character code
+	 * example:
+	 * sk > '2020-09-05'
+	 *   expected
+	 *     - 2020-09-06@05:05_hero
+	 *     - 2020-10-05@05:05_hero
+	 *     - 2022-02-05@05:05_villian
+	 *     - 2022-06-05@05:05_clown
+	 *     - 2022-09-06@05:05_clown
+	 *   actual (bad - includes all 2020-09-05 records)
+	 *     - 2020-09-05@05:05_hero
+	 *     - 2020-09-06@05:05_hero
+	 *     - 2020-10-05@05:05_hero
+	 *     - 2022-02-05@05:05_villian
+	 *     - 2022-06-05@05:05_clown
+	 */
+	gt: ">=",
+
+	/**
+	 * lte becomes lt and last character of incoming value is shifted up one character code
+	 * example:
+	 * sk >= '2020-09-05'
+	 *   expected
+	 *     - 2012-02-05@05:05_clown
+	 *     - 2015-10-05@05:05_hero
+	 *     - 2017-02-05@05:05_clown
+	 *     - 2017-02-05@05:05_villian
+	 *     - 2020-02-05@05:05_clown
+	 *     - 2020-02-25@05:05_clown
+	 *     - 2020-09-05@05:05_hero
+	 *   actual (bad - missing all 2020-09-05 records)
+	 *     - 2012-02-05@05:05_clown
+	 *     - 2015-10-05@05:05_hero
+	 *     - 2017-02-05@05:05_clown
+	 *     - 2017-02-05@05:05_villian
+	 *     - 2020-02-05@05:05_clown
+	 *     - 2020-02-25@05:05_clown
+	 */
+	lte: "<",
 };
 
 const CastTypes = ["string", "number"];
@@ -210,6 +262,7 @@ module.exports = {
 	CastTypes,
 	KeyCasing,
 	PathTypes,
+	IndexTypes,
 	QueryTypes,
 	ValueTypes,
 	TableIndex,
@@ -229,6 +282,7 @@ module.exports = {
 	UnprocessedTypes,
 	AttributeWildCard,
 	TerminalOperation,
+	PartialComparisons,
 	FormatToReturnValues,
 	AttributeProxySymbol,
 	ElectroInstanceTypes,

package/src/util.js

@@ -220,6 +220,19 @@ function removePadding({padding = {}, value = ''} = {}) {
   return formatted;
 }
 
+function shiftSortOrder(str = '', codePoint) {
+  let newString = '';
+  for (let i = 0; i < str.length; i++) {
+    const isLast = i === str.length - 1;
+    let char = str[i];
+    if (isLast) {
+      char = String.fromCodePoint(char.codePointAt(0) + codePoint);
+    }
+    newString += char;
+  }
+  return newString;
+}
+
 module.exports = {
   getUnique,
   batchItems,
@@ -227,13 +240,14 @@ module.exports = {
   removePadding,
   removeFixings,
   parseJSONPath,
+  shiftSortOrder,
   getInstanceType,
   getModelVersion,
   formatKeyCasing,
+  cursorFormatter,
   genericizeJSONPath,
   commaSeparatedString,
   formatAttributeCasing,
-  cursorFormatter,
   applyBetaModelOverrides,
   formatIndexNameForDisplay,
   BatchGetOrderMaintainer,

package/src/validations.js

@@ -154,6 +154,11 @@ const Index = {
 		},
 		collection: {
 			type: ["array", "string"]
+		},
+		type: {
+			type: 'string',
+			enum: ['clustered', 'isolated'],
+			required: false,
 		}
 	},
 };

package/src/where.js

@@ -50,12 +50,8 @@ class FilterExpression extends ExpressionState {
 			throw new Error(`Invalid operation: "${operation}". Please report`);
 		}
 		const names = this.setName({}, name, name);
-		if (values.length) {
-			for (const value of values) {
-				this.setValue(name, value);
-			}
-		}
-		const condition = template({}, name.expression, names.prop, ...values);
+		const valueExpressions = values.map(value => this.setValue(name, value));
+		const condition = template({}, names.expression, names.prop, ...valueExpressions);
 		this.add(condition);
 	}
 
@@ -70,19 +66,19 @@ class WhereFactory {
     this.operations = {...operations};
   }
 
-	getExpressionType(methodType) {
-		switch (methodType) {
-			case MethodTypes.put:
-			case MethodTypes.create:
-			case MethodTypes.update:
-			case MethodTypes.patch:
-			case MethodTypes.delete:
-			case MethodTypes.remove:
-				return ExpressionTypes.ConditionExpression
-			default:
-				return ExpressionTypes.FilterExpression
-		}
+  getExpressionType(methodType) {
+  	switch (methodType) {
+		case MethodTypes.put:
+		case MethodTypes.create:
+		case MethodTypes.update:
+		case MethodTypes.patch:
+		case MethodTypes.delete:
+		case MethodTypes.remove:
+			return ExpressionTypes.ConditionExpression
+		default:
+			return ExpressionTypes.FilterExpression
 	}
+  }
 
 	buildClause(cb) {
 		if (typeof cb !== "function") {