@onehat/data 1.23.0 → 1.23.1

package/cypress/e2e/OneHatData.cy.js

@@ -28,6 +28,17 @@ async function beforeEach(that) {
 	}, true);
 	that.repository = that.oneHatData.getRepositoryById('foo');
 }
+
+async function waitForRepositoryInitialization(repository, timeout = 2000) {
+	const start = Date.now();
+	while (!repository.isInitialized) {
+		if (Date.now() - start > timeout) {
+			throw new Error('Repository did not initialize in time: ' + repository.name);
+		}
+		await new Promise((resolve) => setTimeout(resolve, 5));
+	}
+}
+
 function afterEach(that) {
 	that.oneHatData.destroy();
 }
@@ -274,6 +285,97 @@ describe('OneHatData', function() {
 		})();
 	});
 
+	it('getRepositoryAsync returns initialized unique repository', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const repository = await that.oneHatData.getRepositoryAsync('bar', true);
+
+			expect(repository).to.be.ok;
+			expect(repository.isUnique).to.be.true;
+			expect(repository.isInitialized).to.be.true;
+
+			afterEach(that);
+		})();
+	});
+
+	it('getRepositoryAsync returns initialized bound repository', function() {
+		(async () => {
+			const that = {};
+			await beforeEach(that);
+
+			const repository = await that.oneHatData.getRepositoryAsync('bar');
+
+			expect(repository).to.be.eq(that.repository);
+			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 = that.oneHatData.getRepository('bar', true);
+
+			await waitForRepositoryInitialization(uniqueRepository);
+
+			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('getRepository unique allows pre-init 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 = that.oneHatData.getRepository('meters', true);
+
+			expect(() => {
+				uniqueRepository.setBaseParams({
+					foo: 'bar',
+				});
+			}).to.not.throw();
+
+			expect(uniqueRepository.getBaseParam('foo')).to.be.eq('bar');
+
+			afterEach(that);
+		})();
+	});
+
 	it('getRepositoriesBy', function() {
 		(async function() {
 			await beforeEach();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@onehat/data",
-	"version": "1.23.0",
+	"version": "1.23.1",
 	"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.getRepositoryAsync(schemaName, true);
+				} else {
+					repository = await oneHatData.createRepository(schemaName);
+					repository.isUnique = true;
+				}
+				repositoryIdToDelete = repository?.id;
 			} else if (_.isObject(schemaName)) {
 				if (schemaName.id) {
 					repository = oneHatData.getRepositoryById(schemaName.id);
@@ -42,8 +49,13 @@ export default function useOneHatData(schemaName, uniqueRepository = false) {
 					repository = await oneHatData.createRepository(schemaName)
 				}
 			} else {
-				repository = oneHatData.getRepository(schemaName); // Get bound Repository for this schema
+				repository = await oneHatData.getRepositoryAsync(schemaName); // Get initialized 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

@@ -484,19 +484,244 @@ export class OneHatData extends EventEmitter {
 			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 this._createUniqueRepositorySync(name);
 		}
 		return schema.getBoundRepository();
 	}
 
+	/**
+	 * Async variant of getRepository.
+	 * Useful when unique repositories are needed in frameworks that expect
+	 * fully initialized objects before first use.
+	 * @param {string} name - Name of Schema
+	 * @param {boolean} unique - Whether to create a unique repository
+	 * @param {number} timeout - Max ms to wait for initialization
+	 * @return {Promise<Repository>} repository
+	 */
+	getRepositoryAsync = async (name, unique = false, timeout = 10000) => {
+		if (this.isDestroyed) {
+			throw new Error('this.getRepositoryAsync is no longer valid. OneHatData has been destroyed.');
+		}
+
+		const repository = this.getRepository(name, unique);
+		if (!repository) {
+			return null;
+		}
+
+		await this._waitForRepositoryInitialization(repository, timeout);
+		return repository;
+	}
+
+	/**
+	 * Creates an unbound unique Repository synchronously.
+	 * It returns the instance immediately and initializes in background.
+	 * @param {string} name - Name of Schema
+	 * @return {Repository} repository
+	 */
+	_createUniqueRepositorySync = (name) => {
+		if (this.isDestroyed) {
+			throw new Error('this._createUniqueRepositorySync is no longer valid. OneHatData has been destroyed.');
+		}
+
+		const schema = this.getSchema(name);
+		if (!schema) {
+			return null;
+		}
+
+		const boundRepository = schema.getBoundRepository();
+		if (!boundRepository) {
+			return null;
+		}
+
+		const id = uuid();
+		const schemaRepositoryDef = _.isString(schema.repository) ? { type: schema.repository } : schema.repository;
+
+		// Keep behavioral overrides while omitting mutable runtime state and nested repo instances.
+		const safeOverrides = _.omit(boundRepository.originalConfig || {}, [
+			'id',
+			'name',
+			'isUnique',
+			'local',
+			'remote',
+			'entities',
+			'filters',
+			'sorters',
+			'page',
+			'previousPage',
+			'pageTotal',
+			'pageStart',
+			'pageEnd',
+			'totalPages',
+			'total',
+			'isFiltered',
+			'isInitialized',
+			'isLoaded',
+			'isLoading',
+			'lastLoaded',
+			'hash',
+		]);
+
+		const config = _.merge({}, schemaRepositoryDef, this._repositoryGlobals, safeOverrides, {
+			schema,
+			id,
+			name: boundRepository.name + '-' + id,
+			isUnique: true,
+		});
+
+		const repository = this._createRepositorySync(config);
+
+		this.repositories[repository.id] = repository;
+		this._initializeRepositoryInBackground(repository);
+
+		if (repository.isRegisteredEvent('logout')) { // OneBuild repository emits this
+			this.relayEventsFrom(repository, ['logout']);
+		}
+		if (repository.isRegisteredEvent(CROSS_TAB_EVENT_NAME)) {
+			this.relayEventsFrom(repository, [CROSS_TAB_EVENT_NAME]);
+		}
+
+		this.emit('createRepository', repository);
+		return repository;
+	}
+
+	/**
+	 * Creates a Repository instance synchronously.
+	 * Used when we must return a repository instance immediately.
+	 * @param {object} config - Repository config object
+	 * @return {Repository} repository
+	 * @private
+	 */
+	_createRepositorySync = (config) => {
+		if (this.isDestroyed) {
+			throw new Error('this._createRepositorySync is no longer valid. OneHatData has been destroyed.');
+		}
+
+		const workingConfig = _.merge({}, config);
+
+		if (workingConfig.type === 'lfr') {
+			const generalConfig = _.omit(workingConfig, ['type', 'local', 'remote']);
+
+			let localConfig = workingConfig.local;
+			let remoteConfig = workingConfig.remote;
+
+			if (_.isString(localConfig)) {
+				localConfig = {
+					type: localConfig,
+				};
+			}
+			if (_.isString(remoteConfig)) {
+				remoteConfig = {
+					type: remoteConfig,
+				};
+			}
+
+			if (workingConfig.mode === MODE_COMMAND_QUEUE) {
+				generalConfig.isPaginated = false;
+				remoteConfig.type = 'command';
+			}
+
+			localConfig = _.merge({}, generalConfig, localConfig);
+			remoteConfig = _.merge({}, generalConfig, remoteConfig);
+
+			const localRepository = this._createRepositorySync(localConfig);
+			const remoteRepository = this._createRepositorySync(remoteConfig);
+
+			workingConfig.local = localRepository;
+			workingConfig.remote = remoteRepository;
+		}
+
+		const RepositoryType = this._repositoryTypes[workingConfig.type];
+		if (!RepositoryType) {
+			throw new Error('Repository type does not exist');
+		}
+
+		return new RepositoryType(workingConfig, this);
+	}
+
+	/**
+	 * Initializes repositories in the proper dependency order.
+	 * @param {Repository} repository - Repository instance
+	 * @private
+	 */
+	_initializeRepositoryInBackground = (repository) => {
+		repository._initializationError = null;
+		repository._initializationPromise = Promise.resolve()
+			.then(async () => {
+				if (repository && repository.type === 'lfr') {
+					if (repository.local && _.isFunction(repository.local.initialize)) {
+						await repository.local.initialize();
+					}
+					if (repository.remote && _.isFunction(repository.remote.initialize)) {
+						await repository.remote.initialize();
+					}
+				}
+				await repository.initialize();
+			})
+			.catch((error) => {
+				repository._initializationError = error;
+				repository.emit('error', error);
+			});
+		return repository._initializationPromise;
+	}
+
+	/**
+	 * Waits for repository initialization if currently pending.
+	 * @param {Repository} repository - Repository instance
+	 * @param {number} timeout - Max ms to wait for initialization
+	 * @return {Promise<Repository>} repository
+	 * @private
+	 */
+	_waitForRepositoryInitialization = async (repository, timeout = 10000) => {
+		if (!repository) {
+			return null;
+		}
+
+		if (repository._initializationPromise) {
+			await repository._initializationPromise;
+		}
+
+		if (repository._initializationError) {
+			throw repository._initializationError;
+		}
+
+		if (repository.isInitialized === true) {
+			return repository;
+		}
+
+		if (repository.isInitializing && _.isFunction(repository.on) && _.isFunction(repository.off)) {
+			await new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					repository.off('initialize', handleInitialize);
+					repository.off('error', handleError);
+					reject(new Error('Timed out waiting for repository initialization: ' + repository.name));
+				}, timeout);
+
+				const handleInitialize = () => {
+					clearTimeout(timeoutId);
+					repository.off('initialize', handleInitialize);
+					repository.off('error', handleError);
+					resolve();
+				};
+
+				const handleError = (error) => {
+					clearTimeout(timeoutId);
+					repository.off('initialize', handleInitialize);
+					repository.off('error', handleError);
+					reject(error || new Error('Repository initialization failed: ' + repository.name));
+				};
+
+				repository.on('initialize', handleInitialize);
+				repository.on('error', handleError);
+			});
+		}
+
+		if (repository._initializationError) {
+			throw repository._initializationError;
+		}
+
+		return repository;
+	}
+
 	/**
 	 * 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)

package/src/Repository/Ajax.js

@@ -141,51 +141,58 @@ class AjaxRepository extends Repository {
 	}
 
 	async initialize() {
+		this.isInitializing = true;
+		try {
 
-		this.registerEvents([
-			'beforeLoad',
-		]);
+			this.registerEvents([
+				'beforeLoad',
+			]);
 
-		// Respond to Repository events
-		this.on('beforeSave', this._onBeforeSave);
+			// Respond to Repository events
+			this.on('beforeSave', this._onBeforeSave);
 
 
-		// Create Reader
-		let readerConfig;
-		if (this.reader && this.reader.type) {
-			readerConfig = this.reader;
-		} else if (_.isString(this.reader)) {
-			readerConfig = {
-				type: this.reader,
-			};
-		}
-		if (readerConfig && ReaderTypes[readerConfig.type]) {
-			const Reader = ReaderTypes[readerConfig.type];
-			this.reader = new Reader(readerConfig);
-		} else {
-			this.reader = null;
-		}
+			// Create Reader
+			let readerConfig;
+			if (this.reader && this.reader.type) {
+				readerConfig = this.reader;
+			} else if (_.isString(this.reader)) {
+				readerConfig = {
+					type: this.reader,
+				};
+			}
+			if (readerConfig && ReaderTypes[readerConfig.type]) {
+				const Reader = ReaderTypes[readerConfig.type];
+				this.reader = new Reader(readerConfig);
+			} else {
+				this.reader = null;
+			}
 
-		// Create Writer
-		let writerConfig;
-		if (this.writer && this.writer.type) {
-			writerConfig = this.writer;
-		} else if (_.isString(this.writer)) {
-			writerConfig = {
-				type: this.writer,
-			};
-		}
-		if (writerConfig && WriterTypes[writerConfig.type]) {
-			const Writer = WriterTypes[writerConfig.type];
-			this.writer = new Writer(writerConfig);
-		} else {
-			this.writer = null;
-		}
+			// Create Writer
+			let writerConfig;
+			if (this.writer && this.writer.type) {
+				writerConfig = this.writer;
+			} else if (_.isString(this.writer)) {
+				writerConfig = {
+					type: this.writer,
+				};
+			}
+			if (writerConfig && WriterTypes[writerConfig.type]) {
+				const Writer = WriterTypes[writerConfig.type];
+				this.writer = new Writer(writerConfig);
+			} else {
+				this.writer = null;
+			}
 
-		// Initialize query params
-		this._setInitialQueryParams();
+			// Initialize query params
+			this._setInitialQueryParams();
 
-		await super.initialize();
+			await super.initialize();
+		} finally {
+			if (!this.isInitialized) {
+				this.isInitializing = false;
+			}
+		}
 	}
 
 	/**
@@ -227,6 +234,7 @@ class AjaxRepository extends Repository {
 	 * @param {boolean} isBaseParam - Whether param is a base param (to be sent on every request).
 	 */
 	setParam(name, value, isBaseParam = false) {
+		this._assertInitialized('setParam');
 		const
 			re = /^([^\[]+)\[([^\]]+)\](.*)$/,
 			matches = name.match(re),
@@ -263,6 +271,7 @@ class AjaxRepository extends Repository {
 	 * @param {boolean} isBaseParam - Whether param is a base param (to be sent on every request).
 	 */
 	setValuelessParam(name, isBaseParam = false) {
+		this._assertInitialized('setValuelessParam');
 		const
 			re = /^([^\[]+)\[([^\]]+)\](.*)$/,
 			matches = name.match(re),
@@ -290,6 +299,7 @@ class AjaxRepository extends Repository {
 	 * @param {object} params - Params to set. Key is parameter name, value is parameter value
 	 */
 	setParams(params) {
+		this._assertInitialized('setParams');
 		const oThis = this;
 		_.each(params, (value, name) => {
 			oThis.setParam(name, value);
@@ -301,6 +311,7 @@ class AjaxRepository extends Repository {
 	 * @param {string} name - Param name
 	 */
 	hasBaseParam(name) {
+		this._assertInitialized('hasBaseParam');
 		if (this._baseParams.hasOwnProperty(name)) {
 			return true;
 		}
@@ -324,6 +335,7 @@ class AjaxRepository extends Repository {
 	 * @param {string} name - Param name
 	 */
 	getBaseParam(name) {
+		this._assertInitialized('getBaseParam');
 		if (!this.hasBaseParam(name)) {
 			return null;
 		}
@@ -351,6 +363,7 @@ class AjaxRepository extends Repository {
 	 * @param {object} params - Params to set. Key is parameter name, value is parameter value
 	 */
 	getBaseParams() {
+		this._assertInitialized('getBaseParams');
 		return this._baseParams;
 	}
 
@@ -358,6 +371,7 @@ class AjaxRepository extends Repository {
 	 * Returns current value of any baseParam query conditions
 	 */
 	getBaseParamConditions() {
+		this._assertInitialized('getBaseParamConditions');
 		const
 			existingConditions = this._baseParams.conditions || {},
 			convertedConditions = {};
@@ -371,6 +385,7 @@ class AjaxRepository extends Repository {
 	 * Returns current value of any param query conditions
 	 */
 	getParamConditions() {
+		this._assertInitialized('getParamConditions');
 		const
 			existingConditions = this._params.conditions || {},
 			convertedConditions = {};
@@ -385,6 +400,7 @@ class AjaxRepository extends Repository {
 	 * @param {string} name - Param name
 	 */
 	hasParam(name) {
+		this._assertInitialized('hasParam');
 		if (this._params.hasOwnProperty(name)) {
 			return true;
 		}
@@ -409,6 +425,7 @@ class AjaxRepository extends Repository {
 	 * @param {any} value - Param value to set.
 	 */
 	setBaseParam(name, value) {
+		this._assertInitialized('setBaseParam');
 		this.setParam(name, value, true);
 	}
 
@@ -417,6 +434,7 @@ class AjaxRepository extends Repository {
 	 * @param {object} params - Base params to set. Key is parameter name, value is parameter value
 	 */
 	setBaseParams(params) {
+		this._assertInitialized('setBaseParams');
 		const oThis = this;
 		_.each(params, (value, name) => {
 			oThis.setBaseParam(name, value);
@@ -429,6 +447,7 @@ class AjaxRepository extends Repository {
 	 * @param {boolean} reload - Whether to reload repository. Defaults to false.
 	 */
 	clearParams(reload = false, clearBase = false) {
+		this._assertInitialized('clearParams');
 		this._params = {};
 		if (clearBase) {
 			this._baseParams = {};
@@ -444,6 +463,7 @@ class AjaxRepository extends Repository {
 	 * Refreshes entities.
 	 */
 	_onChangeSorters() {
+		this._assertInitialized('_onChangeSorters');
 		const sorter = this.sorters[0];
 		this.setBaseParam(this.paramSort, sorter.name);
 		this.setBaseParam(this.paramDirection, sorter.direction);
@@ -458,6 +478,7 @@ class AjaxRepository extends Repository {
 	 * Refreshes entities.
 	 */
 	_onChangeFilters() {
+		this._assertInitialized('_onChangeFilters');
 		const oThis = this;
 		_.each(this.filters, (value, name) => {
 			oThis.setParam(name, value);
@@ -473,6 +494,7 @@ class AjaxRepository extends Repository {
 	 * Refreshes entities.
 	 */
 	_onChangePagination() {
+		this._assertInitialized('_onChangePagination');
 		this.setBaseParam(this.paramPageNum, this.isPaginated ? this.page : null);
 		this.setBaseParam(this.paramPageSize, this.isPaginated ? this.pageSize : null);
 
@@ -512,6 +534,7 @@ class AjaxRepository extends Repository {
 	 * @fires beforeLoad,changeData,load,error
 	 */
 	async load(params, callback = null) {
+		this._assertInitialized('load');
 		if (this.isTree) {
 			return this.loadRootNodes();
 		}
@@ -684,6 +707,7 @@ class AjaxRepository extends Repository {
 	}
 
 	showMore(params = {}, callback) {
+		this._assertInitialized('showMore');
 		params.showMore = true;
 		return this.load(params, callback);
 	}
@@ -696,6 +720,7 @@ class AjaxRepository extends Repository {
 	 * @fires reloadEntity,beforeLoad,changeData,load,error
 	 */
 	async reloadEntity(entity, callback = null) { // use this notation so we can override it in subclasses
+		this._assertInitialized('reloadEntity');
 		if (this.isDestroyed) {
 			this.throwError('this.reloadEntity is no longer valid. Repository has been destroyed.');
 			return;
@@ -759,6 +784,7 @@ class AjaxRepository extends Repository {
 	 * @private
 	 */
 	_getReloadEntityParams(entity) {
+		this._assertInitialized('_getReloadEntityParams');
 		const params = {
 			id: entity.id,
 		};
@@ -770,6 +796,7 @@ class AjaxRepository extends Repository {
 	 * @private
 	 */
 	_onBeforeSave() {
+		this._assertInitialized('_onBeforeSave');
 		this._operations = {
 			add: false,
 			edit: false,
@@ -1171,6 +1198,7 @@ class AjaxRepository extends Repository {
 	 * @private
 	 */
 	_send(method, url, data, options = {}) {
+		this._assertInitialized('_send');
 
 		if (!url) {
 			this.throwError('No url submitted');
@@ -1251,6 +1279,7 @@ class AjaxRepository extends Repository {
 	 * since the server normally sorts, and they haven't yet gone to server.
 	 */
 	sortInMemory() {
+		this._assertInitialized('sortInMemory');
 		const sorters = this.sorters;
 		let sortNames = [],
 			sortDirections = [];

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,66 @@ 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);
+			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');
+		} finally {
+			this.isInitializing = false;
 		}
-		this.rehash();
+	}
 
-		this.isInitialized = true;
-		this.emit('initialize');
+	/**
+	 * Throws when operational methods are used before initialization completes.
+	 * @param {string} methodName - Name of the method being guarded
+	 * @private
+	 */
+	_assertInitialized(methodName) {
+		const strictMethods = {
+			add: true,
+			addMultiple: true,
+			save: true,
+			delete: true,
+			load: true,
+			reloadEntity: true,
+			_send: true,
+		};
+		if (!strictMethods[methodName]) {
+			return;
+		}
+		if (!this.isInitialized && !this.isInitializing) {
+			throw new Error('Repository ' + this.name + ' is not initialized. Cannot call ' + methodName + ' yet.');
+		}
 	}
 
 	/**
@@ -588,6 +622,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.sort is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('sort');
 		// Assemble sorting definition objects
 		let sorters = [];
 		if (_.isNil(arg1)) {
@@ -648,6 +683,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.setSorters is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('setSorters');
 		if (!this.allowsMultiSort && sorters.length > 1) {
 			this.throwError('Cannot have more than one sorter at a time.');
 			return;
@@ -757,6 +793,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.filter is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('filter');
 
 		if (_.isNil(arg1)) {
 			return this.clearFilters();
@@ -833,6 +870,7 @@ export default class Repository extends EventEmitter {
 	 * @return this
 	 */
 	setFilters(filters, clearFirst = true) {
+		this._assertInitialized('setFilters');
 		const parsed = _.map(filters, (value, name) => {
 			return {
 				name,
@@ -853,6 +891,7 @@ export default class Repository extends EventEmitter {
 	 * - repository.clearFilters(['first_name', 'last_name']); // Clear multiple filters
 	 */
 	clearFilters(filtersToClear) {
+		this._assertInitialized('clearFilters');
 		let filters = [];
 		if (filtersToClear) {
 			if (_.isString(filtersToClear)) {
@@ -875,6 +914,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this._setFilters is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('_setFilters');
 		if (!_.isEqual(this.filters, filters)) {
 			this.filters = filters;
 			this.resetPagination();
@@ -1114,6 +1154,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.add is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('add');
 		if (!this.canAdd) {
 			this.throwError('Adding has been disabled on this repository.');
 			return;
@@ -1201,6 +1242,7 @@ export default class Repository extends EventEmitter {
 	 * @return {array} entities - new Entity objects
 	 */
 	async addMultiple(allData, isPersisted = false) {
+		this._assertInitialized('addMultiple');
 
 		if (!this.canAdd) {
 			this.throwError('Adding has been disabled on this repository.');
@@ -1386,6 +1428,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getByIx is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getByIx');
 		return this.entities[ix];
 	}
 	
@@ -1401,6 +1444,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getByRange is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getByRange');
 		return _.slice(this.entities, startIx, endIx+1);
 	}
 
@@ -1414,6 +1458,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getById is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getById');
 		if (_.isNil(id)) {
 			return null;
 		}
@@ -1430,6 +1475,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getIxById is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getIxById');
 		if (_.isNil(id)) {
 			return null;
 		}
@@ -1451,6 +1497,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getBy is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getBy');
 		return _.filter(this.entities, filter);
 	}
 
@@ -1468,6 +1515,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getFirstBy is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getFirstBy');
 		return _.find(this.entities, filter);
 	}
 
@@ -1513,6 +1561,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getEntities is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getEntities');
 		return this.entities;
 	}
 	/* */
@@ -1528,6 +1577,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.getPagedEntities is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('getEntitiesOnPage');
 		const entities = this.getEntities();
 		if (!this.isPaginated) {
 			return entities;
@@ -1767,6 +1817,7 @@ export default class Repository extends EventEmitter {
 			this.throwError('this.save is no longer valid. Repository has been destroyed.');
 			return;
 		}
+		this._assertInitialized('save');
 
 		this.emit('beforeSave'); // So subclasses can prep anything needed for saving
 	
@@ -2011,6 +2062,7 @@ export default class Repository extends EventEmitter {
 	 * @fires delete
 	 */
 	async delete(entities, moveSubtreeUp = false) {
+		this._assertInitialized('delete');
 		if (this.isDestroyed) {
 			this.throwError('this.delete is no longer valid. Repository has been destroyed.');
 			return;
@@ -2275,10 +2327,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 +2376,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 +2388,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 +2396,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;
 	}
 
 };