@onehat/data 1.23.0 → 1.23.2

package/cypress/e2e/OneHatData.cy.js

@@ -28,6 +28,7 @@ async function beforeEach(that) {
 	}, true);
 	that.repository = that.oneHatData.getRepositoryById('foo');
 }
+
 function afterEach(that) {
 	that.oneHatData.destroy();
 }
@@ -267,8 +268,130 @@ describe('OneHatData', function() {
 
 			const
 				repo1 = that.oneHatData.getRepository('bar'),
-				repo2 = that.oneHatData.getRepository('bar', true);
+				repo2 = await that.oneHatData.getUniqueRepository('bar');
 			expect(repo1 !== repo2).to.be.true;
+			expect(repo2.isInitialized).to.be.true;
+
+			afterEach(that);
+		})();
+	});
+
+	it('getRepository(name, true) throws migration error', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			expect(() => that.oneHatData.getRepository('bar', true)).to.throw('Use await this.getUniqueRepository(name) instead.');
+
+			afterEach(that);
+		})();
+	});
+
+	it('getUniqueRepository returns initialized unique repository', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const repository = await that.oneHatData.getUniqueRepository('bar');
+
+			expect(repository).to.be.ok;
+			expect(repository.isUnique).to.be.true;
+			expect(repository.isInitialized).to.be.true;
+
+			afterEach(that);
+		})();
+	});
+
+	it('getRepository unique keeps filters isolated from bound repository', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const
+				boundRepository = that.oneHatData.getRepository('bar'),
+				uniqueRepository = await that.oneHatData.getUniqueRepository('bar');
+
+			boundRepository.filter('key', 'bound-only');
+			expect(boundRepository.hasFilterValue('key', 'bound-only')).to.be.true;
+			expect(uniqueRepository.hasFilter('key')).to.be.false;
+
+			uniqueRepository.filter('key', 'unique-only');
+			expect(uniqueRepository.hasFilterValue('key', 'unique-only')).to.be.true;
+			expect(boundRepository.hasFilterValue('key', 'bound-only')).to.be.true;
+			expect(boundRepository.hasFilterValue('key', 'unique-only')).to.be.false;
+
+			afterEach(that);
+		})();
+	});
+
+	it('getUniqueRepository allows setBaseParams for Ajax repositories', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			that.oneHatData.createSchema({
+				name: 'meters',
+				model: {
+					idProperty: 'id',
+					displayProperty: 'name',
+					properties: [
+						{ name: 'id' },
+						{ name: 'name' },
+					],
+				},
+				repository: {
+					type: 'ajax',
+					api: {
+						get: 'meters',
+					},
+				},
+			});
+			await that.oneHatData.createRepository('meters', true);
+
+			const uniqueRepository = await that.oneHatData.getUniqueRepository('meters');
+
+			expect(() => {
+				uniqueRepository.setBaseParams({
+					foo: 'bar',
+				});
+			}).to.not.throw();
+
+			expect(uniqueRepository.getBaseParam('foo')).to.be.eq('bar');
+
+			afterEach(that);
+		})();
+	});
+
+	it('getOrCreateUniqueRepository reuses existing mapped repository', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const repository1 = await that.oneHatData.getOrCreateUniqueRepository('partsMap', 'bar');
+			const repository2 = await that.oneHatData.getOrCreateUniqueRepository('partsMap', 'bar');
+
+			expect(repository1).to.be.eq(repository2);
+			expect(repository1.isUnique).to.be.true;
+
+			afterEach(that);
+		})();
+	});
+
+	it('getOrCreateUniqueRepository recreates repository when mapped id is stale', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const repository1 = await that.oneHatData.getOrCreateUniqueRepository('partsMap', 'bar');
+			const originalId = repository1.id;
+
+			that.oneHatData.deleteRepository(originalId);
+
+			const repository2 = await that.oneHatData.getOrCreateUniqueRepository('partsMap', 'bar');
+
+			expect(repository2).to.be.ok;
+			expect(repository2.id).to.not.eq(originalId);
+			expect(that.oneHatData.uniqueRepositoryIdsMap.partsMap).to.be.eq(repository2.id);
 
 			afterEach(that);
 		})();

package/package.json

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

package/src/Integration/ReactNative/useOneHatData.js

@@ -28,12 +28,19 @@ export default function useOneHatData(schemaName, uniqueRepository = false) {
 	useEffect(() => {
 
 		let repository,
+			repositoryIdToDelete = null,
+			isMounted = true,
 			onChangeData = () => {};
 		(async () => {
 
 			if (uniqueRepository) {
-				repository = await oneHatData.createRepository(schemaName);
-				repository.isUnique = true;
+				if (_.isString(schemaName)) {
+					repository = await oneHatData.getUniqueRepository(schemaName);
+				} else {
+					repository = await oneHatData.createRepository(schemaName);
+					repository.isUnique = true;
+				}
+				repositoryIdToDelete = repository?.id;
 			} else if (_.isObject(schemaName)) {
 				if (schemaName.id) {
 					repository = oneHatData.getRepositoryById(schemaName.id);
@@ -44,6 +51,11 @@ export default function useOneHatData(schemaName, uniqueRepository = false) {
 			} else {
 				repository = oneHatData.getRepository(schemaName); // Get bound Repository for this schema
 			}
+
+			if (!isMounted || !repository) {
+				return;
+			}
+
 			onChangeData = () => {
 				setEntities(repository.entities); // Set new state in component
 			};
@@ -57,9 +69,12 @@ export default function useOneHatData(schemaName, uniqueRepository = false) {
 		})();
 
 		return () => {
-			repository.off('changeData', onChangeData);
-			if (uniqueRepository) {
-				oneHatData.deleteRepository(schemaName);
+			isMounted = false;
+			if (repository) {
+				repository.off('changeData', onChangeData);
+			}
+			if (uniqueRepository && repositoryIdToDelete) {
+				oneHatData.deleteRepository(repositoryIdToDelete);
 			}
 		};
 		

package/src/OneHatData.js

@@ -479,24 +479,72 @@ export class OneHatData extends EventEmitter {
 		if (this.isDestroyed) {
 			throw new Error('this.getRepository is no longer valid. OneHatData has been destroyed.');
 		}
+		if (unique) {
+			throw new Error('this.getRepository(name, true) is no longer supported. Use await this.getUniqueRepository(name) instead.');
+		}
 		const schema = this.getSchema(name);
 		if (!schema) {
 			return null;
 		}
-		if (unique) {
-			const
-				repoToClone = schema.getBoundRepository(),
-				clone = _.cloneDeep(repoToClone);
-			
-			const id = uuid();
-			clone.name = clone.name + '-' + id;
-			clone.id = id;
-			clone.isUnique = true;
-			return clone;
-		}
 		return schema.getBoundRepository();
 	}
 
+	/**
+	 * Gets a fully initialized unique Repository for the supplied schema.
+	 * @param {string} name - Name of Schema
+	 * @return {Promise<Repository>} repository
+	 */
+	getUniqueRepository = async (name) => {
+		if (this.isDestroyed) {
+			throw new Error('this.getUniqueRepository is no longer valid. OneHatData has been destroyed.');
+		}
+
+		const schema = this.getSchema(name);
+		if (!schema) {
+			throw new Error('this.getUniqueRepository: Schema not found. Name: ' + name);
+		}
+
+		const boundRepository = schema.getBoundRepository();
+		if (!boundRepository) {
+			throw new Error('this.getUniqueRepository: Schema does not have a bound Repository. Name: ' + name);
+		}
+
+		const
+			id = uuid(),
+			schemaRepositoryDef = _.isString(schema.repository) ? { type: schema.repository } : schema.repository,
+			safeOverrides = _.omit(boundRepository.originalConfig || {}, [ // Keep behavioral overrides while omitting mutable runtime state and nested repo instances.
+				'id',
+				'name',
+				'isUnique',
+				'local',
+				'remote',
+				'entities',
+				'filters',
+				'sorters',
+				'page',
+				'previousPage',
+				'pageTotal',
+				'pageStart',
+				'pageEnd',
+				'totalPages',
+				'total',
+				'isFiltered',
+				'isInitialized',
+				'isLoaded',
+				'isLoading',
+				'lastLoaded',
+				'hash',
+			]),
+			config = _.merge({}, schemaRepositoryDef, this._repositoryGlobals, safeOverrides, {
+				schema,
+				id,
+				name: boundRepository.name + '-' + id,
+				isUnique: true,
+			});
+
+		return await this.createRepository(config);
+	}
+
 	/**
 	 * Gets or creates a unique repository with the supplied schemaName and name
 	 * @param {string} mapName - Name of unique repository (will be internally mapped to an id)
@@ -505,13 +553,17 @@ export class OneHatData extends EventEmitter {
 	 */
 	getOrCreateUniqueRepository = async (mapName, schemaName) => {
 		if (this.isDestroyed) {
-			throw new Error('this.getUniqueRepository is no longer valid. OneHatData has been destroyed.');
+			throw new Error('this.getOrCreateUniqueRepository is no longer valid. OneHatData has been destroyed.');
 		}
 		
 		// Try to get it
 		let id = this.uniqueRepositoryIdsMap[mapName];
 		if (id) {
-			return this.getRepositoryById(id);
+			const existingRepository = this.getRepositoryById(id);
+			if (existingRepository) {
+				return existingRepository;
+			}
+			delete this.uniqueRepositoryIdsMap[mapName];
 		}
 
 		// Try to create it
@@ -519,11 +571,8 @@ export class OneHatData extends EventEmitter {
 		if (!schema) {
 			return null;
 		}
-
-		const repository = await this.createRepository(schemaName);
+		const repository = await this.getUniqueRepository(schemaName);
 		id = repository.id;
-		repository.name += '-' + id;
-		repository.isUnique = true;
 		this.uniqueRepositoryIdsMap[mapName] = repository.id;
 		return repository;
 	}

package/src/Repository/Ajax.js

@@ -1171,7 +1171,6 @@ class AjaxRepository extends Repository {
 	 * @private
 	 */
 	_send(method, url, data, options = {}) {
-
 		if (!url) {
 			this.throwError('No url submitted');
 			return;

package/src/Repository/Repository.js

@@ -160,6 +160,7 @@ export default class Repository extends EventEmitter {
 			 * @member {boolean} debugMode - Whether this Repository should output debug messages
 			 */
 			debugMode: false,
+
 		};
 
 		_.merge(this, defaults, config);
@@ -235,6 +236,11 @@ export default class Repository extends EventEmitter {
 		 */
 		this.isInitialized = false;
 
+		/**
+		 * @member {boolean} isInitializing - State: whether initialize() is currently running
+		 */
+		this.isInitializing = false;
+
 		/**
 		 * @member {boolean} isTree - Whether this Repository contains TreeNodes
 		 * @readonly
@@ -328,38 +334,43 @@ export default class Repository extends EventEmitter {
 	 * This is async because we may need to wait for loading and sorting.
 	 */
 	async initialize() {
-		// Create default sorters if none supplied
-		if (this.isAutoSort && !this.sorters.length) {
-			this.sorters = this.getDefaultSorters();
-		}
-		
-		// Assign event handlers
-		this.on('entity_change', async (entity) => { // Entity changed its value
-			if (this.isAutoSave && !this.isRemotePhantomMode) {
-				return await this.save(entity);
+		this.isInitializing = true;
+		try {
+			// Create default sorters if none supplied
+			if (this.isAutoSort && !this.sorters.length) {
+				this.sorters = this.getDefaultSorters();
 			}
-		});
+			
+			// Assign event handlers
+			this.on('entity_change', async (entity) => { // Entity changed its value
+				if (this.isAutoSave && !this.isRemotePhantomMode) {
+					return await this.save(entity);
+				}
+			});
 
-		// Auto load & sort
-		if (this.isAutoLoad && !this.isTree) {
-			await this.load();
-		}
-		if (!this.isSorted && this.isAutoSort && !this.isRemoteSort && !this.isTree) { // load may have sorted, in which case this will be skipped.
-			await this.sort();
-		}
+			// Auto load & sort
+			if (this.isAutoLoad && !this.isTree) {
+				await this.load();
+			}
+			if (!this.isSorted && this.isAutoSort && !this.isRemoteSort && !this.isTree) { // load may have sorted, in which case this will be skipped.
+				await this.sort();
+			}
 
-		this._createMethods();
-		this._createStatics();
-		this._createListeners();
+			this._createMethods();
+			this._createStatics();
+			this._createListeners();
 
-		const init = this.schema.repository.init || this.originalConfig.init; // The latter is mainly for lfr repositories
-		if (init) {
-			await init.call(this);
-		}
-		this.rehash();
+			const init = this.schema.repository.init || this.originalConfig.init; // The latter is mainly for lfr repositories
+			if (init) {
+				await init.call(this);
+			}
+			this.rehash();
 
-		this.isInitialized = true;
-		this.emit('initialize');
+			this.isInitialized = true;
+			this.emit('initialize');
+		} finally {
+			this.isInitializing = false;
+		}
 	}
 
 	/**
@@ -1201,7 +1212,6 @@ export default class Repository extends EventEmitter {
 	 * @return {array} entities - new Entity objects
 	 */
 	async addMultiple(allData, isPersisted = false) {
-
 		if (!this.canAdd) {
 			this.throwError('Adding has been disabled on this repository.');
 			return;
@@ -2275,10 +2285,23 @@ export default class Repository extends EventEmitter {
 	 * @param {object} data - optional data object to describe the error
 	 */
 	throwError(obj, data = null) {
+		let errorObject = obj;
+		if (!(errorObject instanceof Error)) {
+			// standardize the errorObject to be an Error instance
+			if (_.isString(errorObject)) {
+				errorObject = new Error(errorObject);
+			} else if (errorObject && _.isString(errorObject.message)) {
+				errorObject = new Error(errorObject.message);
+			} else {
+				errorObject = new Error('Unknown repository error');
+			}
+		}
+		errorObject.context = data;
+
 		if (this.errorHandler) {
-			this.errorHandler(obj, data);
+			this.errorHandler(errorObject, data);
 		} else {
-			this.emit('error', obj, data);
+			this.emit('error', errorObject, data);
 		}
 	}
 
@@ -2311,11 +2334,7 @@ export default class Repository extends EventEmitter {
 	 * @return {string} className
 	 */
 	getClassName() {
-		if (this.isDestroyed) {
-			this.throwError('this.getClassName is no longer valid. Repository has been destroyed.');
-			return;
-		}
-		return this.__proto__.constructor.className;
+		return this.__proto__.constructor.className || this.constructor.className || 'Repository';
 	}
 
 	get className() {
@@ -2327,11 +2346,7 @@ export default class Repository extends EventEmitter {
 	 * @return {string} className
 	 */
 	getType() {
-		if (this.isDestroyed) {
-			this.throwError('this.getClassName is no longer valid. Repository has been destroyed.');
-			return;
-		}
-		return this.__proto__.constructor.type;
+		return this.__proto__.constructor.type || this.constructor.type || null;
 	}
 
 	get type() {
@@ -2339,11 +2354,9 @@ export default class Repository extends EventEmitter {
 	}
 
 	toString() {
-		if (this.isDestroyed) {
-			this.throwError('this.toString is no longer valid. Repository has been destroyed.');
-			return;
-		}
-		return this.getClassName() + 'Repository {' + this.name + '} - ' + this.id;
+		const name = this.name || 'destroyed';
+		const id = this.id || 'unknown';
+		return this.getClassName() + 'Repository {' + name + '} - ' + id;
 	}
 
 };