@onehat/data 1.4.13 → 1.5.2

package/cypress/integration/Entity.spec.js

@@ -14,7 +14,7 @@ describe('Entity', function() {
 				properties: [
 					{ name: 'foo', type: 'int' },
 					{ name: 'bar' },
-					{ name: 'baz', mapping: 'baz.test.val', type: 'bool' },
+					{ name: 'baz', mapping: 'baz.test.val', type: 'bool', defaultValue: null, },
 				],
 			},
 		});
@@ -198,6 +198,17 @@ describe('Entity', function() {
 			expect(_.isEqual(this.entity.submitValues, expected)).to.be.true;
 		});
 
+		it('getSubmitValuesMapped & submitValuesMapped', function() {
+			const result = this.entity.getSubmitValuesMapped(),
+				expected = {
+					foo: 1,
+					bar: 'one',
+					'baz.test.val': true,
+				};
+			expect(_.isEqual(result, expected)).to.be.true;
+			expect(_.isEqual(this.entity.submitValuesMapped, expected)).to.be.true;
+		});
+
 		it('getDisplayValues & displayValues', function() {
 			const result = this.entity.getDisplayValues(),
 				expected = {
@@ -258,20 +269,74 @@ describe('Entity', function() {
 		});
 
 		it('getReverseMappedRawValue', function() {
-			const definition = {
-				name: 'foo',
-				mapping: 'a.b.c',
-				type: 'int',
-			},
-			Property = PropertyTypes[definition.type];
-			const property = new Property(definition, 'fakeEntity');
+			const definition1 = {
+					name: 'foo',
+					mapping: 'a.b.c',
+					type: 'int',
+				},
+				Property1 = PropertyTypes[definition1.type];
+			const property1 = new Property1(definition1, 'fakeEntity');
+
+			property1.setValue('47');
+			
+			const reverseMapped1 = Entity.getReverseMappedRawValue(property1),
+				expected1 = { a: { b: { c: '47' }, }, };
+			
+			expect(_.isEqual(reverseMapped1, expected1)).to.be.true;
+
+
+			// Now, with no mapping
+			const definition2 = {
+					name: 'foo',
+					type: 'int',
+				},
+				Property2 = PropertyTypes[definition2.type];
+			const property2 = new Property2(definition2, 'fakeEntity');
 
-			property.setValue('47');
+			property2.setValue('47');
 			
-			const reverseMapped = Entity.getReverseMappedRawValue(property),
-				expected = { a: { b: { c: '47' }, }, };
+			const reverseMapped2 = Entity.getReverseMappedRawValue(property2),
+				expected2 = { foo: '47' };
 			
-			expect(_.isEqual(reverseMapped, expected)).to.be.true;
+			expect(_.isEqual(reverseMapped2, expected2)).to.be.true;
+		});
+
+		it('getReverseMappedRawValues (check deep matches)', function() {
+			const schema = new Schema({
+					name: 'baz',
+					model: {
+						idProperty: 'foo',
+						displayProperty: 'bar',
+						properties: [
+							{ name: 'foo', type: 'int' },
+							{ name: 'bar' },
+							{ name: 'baz', mapping: 'baz.test.val', type: 'bool', defaultValue: null, },
+							{ name: 'baz2', mapping: 'baz.test2', type: 'bool', defaultValue: null, },
+						],
+					},
+				}),
+				data = {
+					foo: 1,
+					bar: 'one',
+					baz: {
+						test: {
+							val: true,
+						},
+						test2: false,
+					},
+				},
+				entity = new Entity(schema, data);
+			entity.initialize();
+
+			const result = entity.getReverseMappedRawValues();
+			expect(_.isEqual(result, data)).to.be.true;
+		});
+
+		it('build a new entity from an existing one using getDataForNewEntity', function() {
+			const entity = new Entity(this.schema, this.entity.getDataForNewEntity());
+			entity.initialize();
+
+			expect(_.isEqual(entity.submitValues, this.entity.submitValues)).to.be.true;
 		});
 
 		it('getChanged', function() {

package/cypress/integration/Property/Property.spec.js

@@ -108,6 +108,10 @@ describe('Property', function() {
 			const property = entity.getProperty('bar');
 			expect(property.isDisplayProperty).to.be.true;
 		});
+	
+		it('getMapping', function() {
+			expect(this.property.getMapping()).to.be.eq('id');
+		});
 
 	});
 

package/cypress/integration/Repository/Repository.spec.js

@@ -511,6 +511,12 @@ describe('Repository Base', function() {
 			expect(didFireAdd).to.be.true;
 		});
 
+		it('createStandaloneEntity', async function() {
+			const entity = await this.repository.createStandaloneEntity({ key: 6, value: 'six' });
+			expect(entity.id).to.be.eq(6);
+			expect(_.size(this.repository.entities)).to.be.eq(5);
+		});
+
 		it('addMultiple', async function() {
 			await this.repository.addMultiple([
 				{ key: 6, value: 'six' },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@onehat/data",
-	"version": "1.4.13",
+	"version": "1.5.2",
 	"description": "JS data modeling package with adapters for many storage mediums.",
 	"main": "src/index.js",
 	"type": "module",

package/src/Entity.js

@@ -32,8 +32,10 @@ class Entity extends EventEmitter {
 	 * @constructor
 	 * @param {Schema} schema - Schema object
 	 * @param {object} rawData - Raw data object. Keys are Property names, Values are Property values.
+	 * @param {Repository} repository
+	 * @param {boolean} - Has rawData already been mapped according to schema?
 	 */
-	constructor(schema, rawData = {}, repository = null) {
+	constructor(schema, rawData = {}, repository = null, originalIsMapped = false) {
 		super(...arguments);
 
 		if (!schema) {
@@ -86,6 +88,12 @@ class Entity extends EventEmitter {
 		 */
 		this._originalDataParsed = null;
 
+		/**
+		 * @member {boolean} originalIsMapped - Has the original data already been mapped according to schema?
+		 * @private
+		 */
+		this.originalIsMapped = originalIsMapped;
+
 		/**
 		 * @member {Object} properties - Object of all Properties, keyed by id (for quick access)
 		 * These properties are actually created in the initialize() function.
@@ -204,6 +212,11 @@ class Entity extends EventEmitter {
 				throw new Error('PropertyType ' + type + ' does not exist.');
 			}
 
+			if (this.originalIsMapped) {
+				// Data has already been mapped according to schema, so alter definition
+				definition = _.clone(definition); // Clone it so you don't alter original in schema
+				definition.mapping = definition.name;
+			}
 			const Property = PropertyTypes[type],
 				property = new Property(definition, this._proxy);
 			
@@ -444,6 +457,36 @@ class Entity extends EventEmitter {
 		return this.getSubmitValues();
 	}
 
+	/**
+	 * Gets an object of properties/values for this Entity,
+	 * and returns them with the mapped names
+	 * Values are the "submit" values, not the "raw" or "parsed" or "display" values.
+	 * @return {object} propertyValues
+	 */
+	getSubmitValuesMapped = () => {
+		if (this.isDestroyed) {
+			throw Error('this.getSubmitValuesMapped is no longer valid. Entity has been destroyed.');
+		}
+		
+		let propertyValues = {};
+		_.forOwn(this.properties, (property) => {
+			const name = property.hasMapping ? property.getMapping() : property.name;
+			propertyValues[name] = property.getSubmitValue();
+		});
+		return propertyValues;
+	}
+
+	/**
+	 * Gets "submit" values for this Entity, and returns them with the mapped names
+	 * @return {object} values
+	 */
+	get submitValuesMapped() {
+		if (this.isDestroyed) {
+			throw Error('this.submitValuesMapped is no longer valid. Entity has been destroyed.');
+		}
+		return this.getSubmitValuesMapped();
+	}
+
 	/**
 	 * Gets an object of values for this Entity,
 	 * Values are the "display" values, not the "raw" or "parsed" or "submit" values.
@@ -556,6 +599,11 @@ class Entity extends EventEmitter {
 	 * @static
 	 */
 	static getReverseMappedRawValue(property) {
+		if (!property.hasMapping) {
+			const obj = {};
+			obj[property.name] = property.rawValue;
+			return obj;
+		}
 		const mapStack = property.mapping.split('.'),
 			rawValue = property.getRawValue();
 
@@ -578,6 +626,37 @@ class Entity extends EventEmitter {
 		return value;
 	}
 
+	/**
+	 * Builds up an object of original values for this entity, from which another entity could be easily created
+	 * @return {object} value - An object representing the 'path' to the raw value.
+	 * e.g. With a mapping of 'a.b.c' and a property rawValue of '47', the 
+	 * following object will be returned:{ a: { b: { c: '47' }, }, }
+	 */
+	getReverseMappedRawValues = () => {
+		if (this.isDestroyed) {
+			throw Error('this.getReverseMappedRawValues is no longer valid. Entity has been destroyed.');
+		}
+		
+		let propertyValues = {};
+		_.forOwn(this.properties, (property) => {
+			const reverseMapped = Entity.getReverseMappedRawValue(property);
+			_.merge(propertyValues, reverseMapped);
+		});
+		return propertyValues;
+	}
+
+	/**
+	 * Convenience function
+	 * Build a new entity with this data
+	 */
+	getDataForNewEntity = () => {
+		if (this.isDestroyed) {
+			throw Error('this.getDataForNewEntity is no longer valid. Entity has been destroyed.');
+		}
+		
+		return this.getReverseMappedRawValues();
+	}
+
 	/**
 	 * Gets the values that have changed since last time saved
 	 * @return {array|boolean} diff - Array of property names that have changed, or false

package/src/Property/Property.js

@@ -405,6 +405,17 @@ export default class Property extends EventEmitter {
 		return this.__proto__.constructor.className;
 	}
 
+	/**
+	 * Gets the mapped name of this Property.
+	 * @return {string} name
+	 */
+	getMapping = () => {
+		if (this.isDestroyed) {
+			throw Error('this.getMapping is no longer valid. Property has been destroyed.');
+		}
+		return this.mapping;
+	}
+
 	/**
 	 * Destroy this object.
 	 * - Removes all circular references to parent objects

package/src/Repository/Repository.js

@@ -847,10 +847,11 @@ export default class Repository extends EventEmitter {
 	 * Creates a single new Entity in storage medium.
 	 * @param {object} data - Either raw data object or Entity. If raw data, keys are Property names, Values are Property values.
 	 * @param {boolean} isPersisted - Whether the new entity should be marked as already being persisted in storage medium.
+	 * @param {boolean} originalIsMapped - Has data already been mapped according to schema?
 	 * @return {object} entity - new Entity object
 	 * @fires add
 	 */
-	add = async (data, isPersisted) => {
+	add = async (data, isPersisted = false, originalIsMapped = false) => {
 		if (this.isDestroyed) {
 			throw Error('this.add is no longer valid. Repository has been destroyed.');
 		}
@@ -858,7 +859,7 @@ export default class Repository extends EventEmitter {
 		let entity = data;
 		if (!(data instanceof Entity)) {
 			// Create the new entity
-			entity = Repository._createEntity(this.schema, data, this, isPersisted);
+			entity = Repository._createEntity(this.schema, data, this, isPersisted, originalIsMapped);
 		}
 		this._relayEntityEvents(entity);
 		this.entities.push(entity);
@@ -877,20 +878,48 @@ export default class Repository extends EventEmitter {
 		return entity;
 	}
 
+	/**
+	 * Creates a new static Entity that does NOT persist in storage medium.
+	 * @param {object} data - Either raw data object or Entity. If raw data, keys are Property names, Values are Property values.
+	 * @param {boolean} isPersisted - Whether the new entity should be marked as already being persisted in storage medium.
+	 * @param {boolean} originalIsMapped - Has data already been mapped according to schema?
+	 * @return {object} entity - new Entity object
+	 */
+	createStandaloneEntity = async (data, isPersisted = false, originalIsMapped = false) => {
+		if (this.isDestroyed) {
+			throw Error('this.createStandaloneEntity is no longer valid. Repository has been destroyed.');
+		}
+		
+		const entity = Repository._createEntity(this.schema, data, this, isPersisted, originalIsMapped);
+
+		if (entity.isPhantom) {
+			entity.createId(); // either a UUID or a temp id
+		}
+
+		return entity;
+	}
+
+	/**
+	 * Convenience function to add entity with mapped data.
+	 */
+	addMapped = (data, isPersisted = false) => {
+		return this.add(data, isPersisted, true);
+	}
+
 	/**
 	 * Convenience function to create multiple new Entities in storage medium.
 	 * @param {array} data - Array of data objects or Entities. 
 	 * @param {boolean} isPersisted - Whether the new entities should be marked as already being persisted in storage medium.
 	 * @return {array} entities - new Entity objects
 	 */
-	addMultiple = async (allData, isPersisted) => {
+	addMultiple = async (allData, isPersisted = false, originalIsMapped = false) => {
 
 		let entities = [],
 			i;
 
 		for (i = 0; i < allData.length; i++) {
 			const data = allData[i],
-				entity = await this.add(data, isPersisted);
+				entity = await this.add(data, isPersisted, originalIsMapped);
 			entities.push(entity);
 		};
 		
@@ -907,8 +936,8 @@ export default class Repository extends EventEmitter {
 	 * @return {object} entity - new Entity object
 	 * @private
 	 */
-	static _createEntity = (schema, rawData, repository = null, isPersisted = false) => {
-		const entity = new Entity(schema, rawData, repository);
+	static _createEntity = (schema, rawData, repository = null, isPersisted = false, originalIsMapped = false) => {
+		const entity = new Entity(schema, rawData, repository, originalIsMapped);
 		entity.initialize();
 		entity.isPersisted = isPersisted;
 		return entity;