electrodb 1.11.1 → 2.0.0

package/src/schema.js

@@ -107,7 +107,7 @@ class Attribute {
 		this.watchedBy = watchedBy;
 		this.watching = watching;
 		this.watchAll = watchAll;
-		let { type, enumArray } = this._makeType(this.name, definition.type);
+		let { type, enumArray } = this._makeType(this.name, definition);
 		this.type = type;
 		this.enumArray = enumArray;
 		this.parentType = definition.parentType;
@@ -145,7 +145,7 @@ class Attribute {
 		const {items, client} = definition;
 		const prop = {...items, ...parent};
 		// The use of "*" is to ensure the child's name is "*" when added to the traverser and searching for the children of a list
-		return Schema.normalizeAttributes({ '*': prop }, {}, {client, traverser: parent.traverser}).attributes["*"];
+		return Schema.normalizeAttributes({ '*': prop }, {}, {client, traverser: parent.traverser, parent}).attributes["*"];
 	}
 
 	static buildChildSetItems(definition, parent) {
@@ -156,7 +156,7 @@ class Attribute {
 			throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid "items" definition for Set attribute: "${definition.path}". Acceptable item types include ${u.commaSeparatedString(allowedTypes)}`);
 		}
 		const prop = {type: items, ...parent};
-		return Schema.normalizeAttributes({ prop }, {}, {client, traverser: parent.traverser}).attributes.prop;
+		return Schema.normalizeAttributes({ prop }, {}, {client, traverser: parent.traverser, parent}).attributes.prop;
 	}
 
 	static buildChildMapProperties(definition, parent) {
@@ -168,7 +168,7 @@ class Attribute {
 		for (let name of Object.keys(properties)) {
 			attributes[name] = {...properties[name], ...parent};
 		}
-		return Schema.normalizeAttributes(attributes, {}, {client, traverser: parent.traverser});
+		return Schema.normalizeAttributes(attributes, {}, {client, traverser: parent.traverser, parent});
 	}
 
 	static buildPath(name, type, parentPath) {
@@ -369,11 +369,14 @@ class Attribute {
 	_makeType(name, definition) {
 		let type = "";
 		let enumArray = [];
-		if (Array.isArray(definition)) {
+		if (Array.isArray(definition.type)) {
 			type = AttributeTypes.enum;
-			enumArray = [...definition];
+			enumArray = [...definition.type];
+		// } else if (definition.type === AttributeTypes.set && Array.isArray(definition.items)) {
+			// type = AttributeTypes.enumSet;
+			// enumArray = [...definition.items];
 		} else {
-			type = definition || "string";
+			type = definition.type || "string";
 		}
 		if (!AttributeTypeNames.includes(type)) {
 			throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid "type" property for attribute: "${name}". Acceptable types include ${AttributeTypeNames.join(", ")}`);
@@ -409,12 +412,19 @@ class Attribute {
 		let reason = [];
 		switch (this.type) {
 			case AttributeTypes.enum:
+			case AttributeTypes.enumSet:
+				// isTyped = this.enumArray.every(enumValue => {
+				// 	const val = Array.isArray(value) ? value : [value];
+				// 	return val.includes(enumValue);
+				// })
 				isTyped = this.enumArray.includes(value);
 				if (!isTyped) {
 					reason.push(new e.ElectroAttributeValidationError(this.path, `Invalid value type at entity path: "${this.path}". Value not found in set of acceptable values: ${u.commaSeparatedString(this.enumArray)}`));
 				}
 				break;
 			case AttributeTypes.any:
+			case AttributeTypes.static:
+			case AttributeTypes.custom:
 				isTyped = true;
 				break;
 			case AttributeTypes.string:
@@ -903,9 +913,9 @@ class SetAttribute extends Attribute {
 }
 
 class Schema {
-	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), client} = {}) {
-		this._validateProperties(properties);
-		let schema = Schema.normalizeAttributes(properties, facets, {traverser, client});
+	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), client, parent} = {}) {
+		this._validateProperties(properties, parent);
+		let schema = Schema.normalizeAttributes(properties, facets, {traverser, client, parent});
 		this.client = client;
 		this.attributes = schema.attributes;
 		this.enums = schema.enums;
@@ -918,7 +928,8 @@ class Schema {
 		this.traverser = traverser;
 	}
 
-	static normalizeAttributes(attributes = {}, facets = {}, {traverser, client} = {}) {
+	static normalizeAttributes(attributes = {}, facets = {}, {traverser, client, parent} = {}) {
+		const attributeHasParent = !!parent;
 		let invalidProperties = [];
 		let normalized = {};
 		let usedAttrs = {};
@@ -1024,6 +1035,10 @@ class Schema {
 				parentType: attribute.parentType,
 			};
 
+			if (definition.type === AttributeTypes.custom) {
+				definition.type = AttributeTypes.any;
+			}
+
 			if (attribute.watch !== undefined) {
 				if (attribute.watch === AttributeWildCard) {
 					definition.watchAll = true;
@@ -1095,6 +1110,10 @@ class Schema {
 				case AttributeTypes.set:
 					normalized[name] = new SetAttribute(definition);
 					break;
+				case AttributeTypes.any:
+					if (attributeHasParent) {
+						throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid attribute "${definition.name}" defined within "${parent.parentPath}". Attributes with type ${u.commaSeparatedString([AttributeTypes.any, AttributeTypes.custom])} are only supported as root level attributes.`);
+					}
 				default:
 					normalized[name] = new Attribute(definition);
 			}
@@ -1344,8 +1363,17 @@ class Schema {
 	}
 }
 
+function createCustomAttribute(definition = {}) {
+	return {
+		...definition,
+		type: 'custom'
+	};
+}
+
 module.exports = {
 	Schema,
 	Attribute,
+	SetAttribute,
 	CastTypes,
+	createCustomAttribute,
 };

package/src/service.js

@@ -243,13 +243,8 @@ class Service {
 
 	cleanseRetrievedData(collection = "", entities, data = {}, config = {}) {
 		if (config.raw) {
-			if (config._isPagination) {
-				return [data.LastEvaluatedKey, data];
-			} else {
-				return data;
-			}
+			return data;
 		}
-
 		data.Items = data.Items || [];
 		let index = this.collectionSchema[collection].index;
 		let results = {};
@@ -268,18 +263,15 @@ class Service {
 			if (!entityAlias) {
 				continue;
 			}
-
 			// pager=false because we don't want the entity trying to parse the lastEvaluatedKey
-			let items = this.collectionSchema[collection].entities[entityAlias].formatResponse({Item: record}, index, {...config, pager: false});
-			results[entityAlias].push(items);
-		}
-
-		if (config._isPagination) {
-			let page = this._formatReturnPager(config, index, data.LastEvaluatedKey, data.Items[data.Items.length - 1]);
-			return [page, results];
-		} else {
-			return results;
+			let items = this.collectionSchema[collection].entities[entityAlias].formatResponse({Item: record}, index, {
+				...config,
+				pager: false,
+				parse: undefined
+			});
+			results[entityAlias].push(items.data);
 		}
+		return results;
 	}
 
 	findKeyOwner(lastEvaluatedKey) {
@@ -287,92 +279,25 @@ class Service {
 			.find((entity) => entity.ownsLastEvaluatedKey(lastEvaluatedKey));
 	}
 
-	findItemPagerOwner(collection, pager = {}) {
-		if (this.collectionSchema[collection] === undefined) {
-			throw new Error("Invalid collection");
-		}
-		let matchingEntities = [];
-		if (pager === null) {
-			return matchingEntities;
-		}
-		for (let entity of Object.values(this.collectionSchema[collection].entities)) {
-			if (entity.ownsPager(pager, this.collectionSchema[collection].index)) {
-				matchingEntities.push(entity);
-			}
-		}
-		return matchingEntities;
-	}
-
-	findNamedPagerOwner(pager = {}) {
-		let identifiers = this._getEntityIdentifiers(this.entities);
-		for (let identifier of identifiers) {
-			let hasCorrectFieldProperties = typeof pager[identifier.nameField] === "string" && typeof pager[identifier.versionField] === "string";
-			let hasMatchingFieldValues = pager[identifier.nameField] === identifier.name && pager[identifier.versionField] === identifier.version;
-			if (hasCorrectFieldProperties && hasMatchingFieldValues) {
-				return identifier.entity;
-			}
-		}
-	}
-
-	expectPagerOwner(type, collection, pager) {
-		if (type === Pager.raw) {
-			return Object.values(this.collectionSchema[collection].entities)[0];
-		} else if (type === Pager.named || type === undefined) {
-			let owner = this.findNamedPagerOwner(pager);
-			if (owner === undefined) {
-				throw new e.ElectroError(e.ErrorCodes.NoOwnerForPager, "Supplied Pager does not resolve to Entity within Service");
-			}
-			return owner;
-		} else if (type === Pager.item) {
-			let owners = this.findItemPagerOwner(collection, pager);
-			if (owners.length === 1) {
-				return owners[0];
-			} else {
-				throw new e.ElectroError(e.ErrorCodes.PagerNotUnique, "Supplied Pager did not resolve to single Entity");
-			}
-		} else {
-			throw new e.ElectroError(e.ErrorCodes.InvalidOptions, `Invalid value for option "pager" provider: "${pager}". Allowed values include ${u.commaSeparatedString(Object.keys(Pager))}.`)
+	expectKeyOwner(lastEvaluatedKey) {
+		const owner = this.findKeyOwner(lastEvaluatedKey);
+		if (owner === undefined) {
+			throw new e.ElectroError(e.ErrorCodes.NoOwnerForCursor, `Supplied cursor does not resolve to Entity within the Service ${this.service.name}`);
 		}
+		return owner;
 	}
 
-	findPagerIdentifiers(collection, pager = {}) {
-		if (this.collectionSchema[collection] === undefined) {
-			throw new Error("Invalid collection");
-		}
-		let matchingIdentifiers = [];
-		if (pager === null) {
-			return matchingIdentifiers;
-		}
-		for (let entity of Object.values(this.collectionSchema[collection].entities)) {
-			if (entity.ownsPager(pager, this.collectionSchema[collection].index)) {
-				matchingIdentifiers.push({
-					[entity.identifiers.entity]: entity.getName(),
-					[entity.identifiers.version]: entity.getVersion(),
-				});
-			}
-		}
-		return matchingIdentifiers;
+	findCursorOwner(cursor) {
+		return Object.values(this.entities)
+			.find(entity => entity.ownsCursor(cursor));
 	}
 
-	_formatReturnPager(config, index, lastEvaluatedKey, lastReturned) {
-		if (config.pager === "raw") {
-			return lastEvaluatedKey;
-		} else if (!lastEvaluatedKey) {
-			return null;
-		} else {
-			let entity = this.findKeyOwner(lastEvaluatedKey);
-			if (!entity) {
-				return lastReturned !== undefined
-					? this._formatReturnPager(config, index, lastReturned)
-					: null
-			}
-			let page = entity._formatKeysToItem(index, lastEvaluatedKey);
-			if (config.pager === "named") {
-				page[entity.identifiers.entity] = entity.getName();
-				page[entity.identifiers.version] = entity.getVersion();
-			}
-			return page;
+	expectCursorOwner(cursor) {
+		const owner = this.findCursorOwner(cursor);
+		if (owner === undefined) {
+			throw new e.ElectroError(e.ErrorCodes.NoOwnerForCursor, `Supplied cursor does not resolve to Entity within the Service ${this.service.name}`);
 		}
+		return owner;
 	}
 
 	_getTableName() {
@@ -389,21 +314,7 @@ class Service {
 	_makeCollectionChain(name = "", attributes = {}, initialClauses = {}, expressions = {}, entities = {}, entity = {}, facets = {}) {
 		let filterBuilder = new FilterFactory(attributes, FilterOperations);
 		let whereBuilder = new WhereFactory(attributes, FilterOperations);
-
-		let pageClause = {...initialClauses.page};
-		let pageAction = initialClauses.page.action;
-		pageClause.action = (entity, state, page = null, options = {}) => {
-			try {
-				if (page === null) {
-					return pageAction(entity, state, page, options);
-				}
-				let owner = this.expectPagerOwner(options.pager, name, page);
-				return pageAction(owner, state, page, options);
-			} catch(err) {
-				return Promise.reject(err);
-			}
-		}
-		let clauses = {...initialClauses, page: pageClause};
+		let clauses = {...initialClauses};
 
 		clauses = filterBuilder.injectFilterClauses(clauses);
 		clauses = whereBuilder.injectWhereClauses(clauses);
@@ -412,6 +323,14 @@ class Service {
 			// expressions, // DynamoDB doesnt return what I expect it would when provided with these entity filters
 			parse: (options, data) => {
 				return this.cleanseRetrievedData(name, entities, data, options);
+			},
+			formatCursor: {
+				serialize: (key) => {
+					return this.expectKeyOwner(key).serializeCursor(key);
+				},
+				deserialize: (cursor) => {
+					return this.expectCursorOwner(cursor).deserilizeCursor(cursor);
+				}
 			}
 		};
 

package/src/types.js

@@ -52,8 +52,11 @@ const AttributeTypes = {
 	enum: "enum",
 	map: "map",
 	set: "set",
+	// enumSet: "enumSet",
 	list: "list",
 	any: "any",
+	custom: "custom",
+	static: "static",
 };
 
 const PathTypes = {
@@ -107,7 +110,8 @@ const AttributeMutationMethods = {
 const Pager = {
 	raw: "raw",
 	named: "named",
-	item: "item"
+	item: "item",
+	cursor: "cursor"
 }
 
 const UnprocessedTypes = {
@@ -191,6 +195,15 @@ const TerminalOperation = {
 	page: 'page',
 }
 
+const AllPages = 'all';
+
+const ResultOrderOption = {
+	'asc': true,
+	'desc': false
+};
+
+const ResultOrderParam = 'ScanIndexForward';
+
 module.exports = {
 	Pager,
 	KeyTypes,
@@ -220,5 +233,8 @@ module.exports = {
 	AttributeProxySymbol,
 	ElectroInstanceTypes,
 	EventSubscriptionTypes,
-	AttributeMutationMethods
+	AttributeMutationMethods,
+	AllPages,
+	ResultOrderOption,
+	ResultOrderParam,
 };

package/src/util.js

@@ -161,6 +161,29 @@ function getUnique(arr1, arr2) {
   ]));
 }
 
+const cursorFormatter = {
+  serialize: (key) => {
+    if (!key) {
+      return null;
+    } else if (typeof val !== 'string') {
+      key = JSON.stringify(key);
+    }
+    return Buffer.from(key).toString('base64url');
+  },
+  deserialize: (cursor) => {
+    if (!cursor) {
+      return undefined;
+    } else if (typeof cursor !== 'string') {
+      throw new Error(`Invalid cursor provided, expected type 'string' recieved: ${JSON.stringify(cursor)}`);
+    }
+    try {
+      return JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+    } catch(err) {
+      throw new Error('Unable to parse cursor');
+    }
+  }
+}
+
 module.exports = {
   getUnique,
   batchItems,
@@ -171,6 +194,7 @@ module.exports = {
   genericizeJSONPath,
   commaSeparatedString,
   formatAttributeCasing,
+  cursorFormatter,
   applyBetaModelOverrides,
   formatIndexNameForDisplay,
   BatchGetOrderMaintainer,

package/src/where.js

@@ -120,7 +120,7 @@ class WhereFactory {
 			injected[name] = {
 				name,
 				action: this.buildClause(filter),
-				children: ["params", "go", "page", "where", ...modelFilters],
+				children: ["params", "go", "where", ...modelFilters],
 			};
 		}
 		filterChildren.push("where");
@@ -129,7 +129,7 @@ class WhereFactory {
 			action: (entity, state, fn) => {
 				return this.buildClause(fn)(entity, state);
 			},
-			children: ["params", "go", "page", "where", ...modelFilters],
+			children: ["params", "go", "where", ...modelFilters],
 		};
 		for (let parent of filterParents) {
 			injected[parent] = { ...injected[parent] };