@onehat/data 1.21.20 → 1.21.21

package/src/Repository/Repository.js

@@ -190,6 +190,11 @@ export default class Repository extends EventEmitter {
 		 */
 		this.page = 1;
 
+		/**
+		 * @member {number} previousPage - State: Previous page number in pagination
+		 */
+		this.previousPage = null;
+
 		/**
 		 * Getter for 
 		 * @member {number} pageTotal - State: Total number of entities on the current page
@@ -216,6 +221,7 @@ export default class Repository extends EventEmitter {
 
 		/**
 		 * @member {number} total - Total number of entities in remote storage that pass filters
+		 * Example: "Showing 21-30 of 45" This would be 45
 		 */
 		this.total = 0;
 
@@ -255,11 +261,6 @@ export default class Repository extends EventEmitter {
 		 */
 		this.lastLoaded = null;
 
-		/**
-		 * @member {boolean} areRootNodesLoaded - State: whether or not root nodes have been loaded at least once
-		 */
-		this.areRootNodesLoaded = false;
-
 		/**
 		 * @member {boolean} isSaving - State: whether or not entities are currently being saved
 		 */
@@ -349,6 +350,7 @@ export default class Repository extends EventEmitter {
 
 		this._createMethods();
 		this._createStatics();
+		this._createListeners();
 
 		const init = this.schema.repository.init || this.originalConfig.init; // The latter is mainly for lfr repositories
 		if (init) {
@@ -396,6 +398,37 @@ export default class Repository extends EventEmitter {
 		}
 	}
 
+	/**
+	 * Creates the initial listeners for this Repository, based on originalConfig.
+	 * @private
+	 */
+	_createListeners() {
+		if (this.isDestroyed) {
+			this.throwError('this._createListeners is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		const listeners = this.originalConfig.listeners;
+		if (!_.isEmpty(listeners)) {
+			const oThis = this;
+			_.each(listeners, ({ event, handler }) => {
+				if (!event || !handler) {
+					oThis.throwError('Invalid listener definition. Must have event and handler.');
+					return;
+				}
+				oThis.on(event, handler);
+			});
+		}
+	}
+
+	getModel() {
+		if (this.model) {
+			return this.model;
+		}
+		if (!this.isUnique) {
+			return this.name;
+		}
+		return this.name.match(/^([^-]*)-(.*)/)[1]; // converts 'ModelName-22f9915c-79f5-4e86-a25b-9446c7b85b63' to 'ModelName'
+	}
 
 	//     __                    __
 	//    / /   ____  ____ _____/ /
@@ -912,6 +945,8 @@ export default class Repository extends EventEmitter {
 			return false;
 		}
 
+		this.previousPage = this.page;
+
 		// Reset to page 1 (don't use setPage(), so we can skip _onChangePagination, which we'll do later)
 		this.page = 1;
 		this.emit('changePage');
@@ -947,6 +982,7 @@ export default class Repository extends EventEmitter {
 			return false;
 		}
 
+		this.previousPage = this.page;
 		this.page = page;
 		this.emit('changePage');
 		if (this._onChangePagination) {
@@ -2127,95 +2163,6 @@ export default class Repository extends EventEmitter {
 	}
 
 
-	//   ______
-	//  /_  __/_______  ___  _____
-	//   / / / ___/ _ \/ _ \/ ___/
-	//  / / / /  /  __/  __(__  )
-	// /_/ /_/   \___/\___/____/
-	
-
-	/**
-	 * Gets the root TreeNodes
-	 */
-	getRootNodes() {
-		this.ensureTree();
-		if (this.isDestroyed) {
-			this.throwError('this.loadRootNodes is no longer valid. Repository has been destroyed.');
-			return;
-		}
-
-		// Look through all entities and pull out the root nodes.
-		// Subclasses of Repository will override this method to get root nodes from server
-		const entities = _.filter(this.getEntities(), (entity) => {
-			return entity.isRoot;
-		})
-		return entities;
-	}
-
-
-	/**
-	 * Populates the TreeNodes with .parent and .children references
-	 */
-	assembleTreeNodes() {
-		this.ensureTree();
-		if (this.isDestroyed) {
-			this.throwError('this.assembleTreeNodes is no longer valid. Repository has been destroyed.');
-			return;
-		}
-
-		const treeNodes = this.getEntities();
-
-		// Reset all parent/child relationships
-		_.each(treeNodes, (treeNode) => {
-			treeNode.parent = null;
-			treeNode.children = [];
-		});
-
-		// Rebuild all parent/child relationships
-		const oThis = this;
-		_.each(treeNodes, (treeNode) => {
-			const parent = oThis.getById(treeNode.parentId);
-			if (parent) {
-				treeNode.parent = parent;
-				parent.children.push(treeNode);
-			}
-		});
-	}
-
-	/**
-	 * Removes the treeNode and all of its children from repository
-	 * without deleting anything on the server
-	 */
-	removeTreeNode(treeNode) {
-		if (!_.isEmpty(treeNode.children)) {
-			const children = treeNode.children;
-			treeNode.parent = null;
-			treeNode.children = [];
-			
-			const oThis = this;
-			_.each(children, (child) => {
-				oThis.removeTreeNode(child);
-			});
-		}
-
-		this.removeEntity(treeNode);
-	}
-
-	/**
-	 * Helper to make sure this Repository is a tree
-	 * @private
-	 */
-	async ensureTree() {
-		if (!this.isTree) {
-			this.throwError('This Repository is not a tree!');
-			return false;
-		}
-		return true;
-	}
-
-
-
-
 
 	//    __  ____  _ ___ __  _          
 	//   / / / / /_(_) (_) /_(_)__  _____

package/src/Repository/Tree.js

@@ -0,0 +1,452 @@
+/** @module Repository */
+
+import Repository from './Repository.js'; // so we can use static methods
+import OneBuildRepository from './OneBuild.js';
+import _ from 'lodash';
+
+
+/**
+ * This class is used for OneBuild Trees
+ * that contain multiple node types.
+ * 
+ * @extends TreeRepository
+ */
+class TreeRepository extends OneBuildRepository {
+	constructor(config = {}) {
+		super(...arguments);
+
+		const defaults = {
+
+			isTree: true,
+			rootNodeType: this.getModel(), // e.g. 'Fleets'
+
+			api: {
+				getNodes: 'getNodes',
+				moveNode: 'moveNode',
+				searchNodes: 'searchNodes',
+			},
+
+			editableNodeTypes: [
+				this.getModel(),
+			],
+
+		};
+		_.merge(this, defaults, config);
+
+	}
+
+	async initialize() {
+
+		this.registerEvents([
+			'loadRootNodes',
+		]);
+
+		await super.initialize();
+	}
+
+	getModelFromTreeNode(treeNode) {
+		return treeNode.nodeType || this.rootNodeType;
+	}
+
+	/**
+	 * Loads the root nodes of this tree.
+	 */
+	loadRootNodes(depth) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.setRootNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		this.emit('beforeLoad'); // TODO: canceling beforeLoad will cancel the load operation
+		this.markLoading();
+
+		const
+			data = _.merge({ depth }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.getNodes;
+
+		if (this.debugMode) {
+			console.log('loadRootNodes', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for loadRootNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				this._destroyEntities();
+
+				// Set the current entities
+				const oThis = this;
+				this.entities = _.map(root, (data) => {
+					const entity = Repository._createEntity(oThis.schema, data, this, true);
+					oThis._relayEntityEvents(entity);
+					return entity;
+				});
+
+				this.assembleTreeNodes();
+				
+				// Set the total records that pass filter
+				this.total = total;
+				this._setPaginationVars();
+
+				this.markLoaded();
+
+				
+				// Don't emit events for root nodes...
+				this.rehash();
+				this.emit('loadRootNodes', this);
+				// this.emit('changeData', this.entities);
+
+				return this.getBy((entity) => {
+					return entity.isRoot;
+				});
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Loads (or reloads) the supplied treeNode
+	 */
+	loadNode(treeNode, depth = 1) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.loadNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		// If children already exist, remove them from the repository
+		// This way, we can reload just a portion of the tree
+		if (!_.isEmpty(treeNode.children)) {
+			_.each(treeNode.children, (child) => {
+				treeNode.repository.removeTreeNode(child);
+			});
+			treeNode.children = [];
+		}
+		
+		this.markLoading();
+
+		const
+			data = _.merge({ depth, nodeId: treeNode.id, }, this._baseParams, this._params),
+			url = treeNode.getModel() + '/' + this.api.getNodes;
+
+		if (this.debugMode) {
+			console.log('loadNode', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for loadNode', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				
+				// Set the current entities
+				const children = [];
+				_.each(root, (data) => {
+					if (data.id === treeNode.id) {
+						// This is the node we're loading, so update it directly
+						treeNode.loadOriginalData(data);
+						return null;
+					}
+					const entity = Repository._createEntity(this.schema, data, this, true);
+					this._relayEntityEvents(entity);
+					children.push(entity);
+				});
+				if (children.length) {
+					this.entities = this.entities.concat(children);
+					this.assembleTreeNodes();
+					this._setPaginationVars();
+				}
+
+				this.markLoaded();
+
+				this.rehash();
+				// this.emit('changeData', this.entities);
+				this.emit('load', this);
+
+				return treeNode;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * alias for backward compatibility
+	 */ 
+	loadChildNodes(treeNode, depth = 1) {
+		return this.loadNode(treeNode, depth);
+	}
+
+	/**
+	 * Override the AjaxRepository to we can reload a treeNode if needed
+	 */
+	reloadEntity(entity, callback = null) {
+		if (!entity.isTree) {
+			return super.reloadEntity(entity, callback);
+		}
+
+		return this.loadNode(entity, 1);
+	}
+
+	/**
+	 * Searches all nodes for the supplied text.
+	 * This basically takes the search query and returns whatever the server sends
+	 */
+	searchNodes(q) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.searchNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		const
+			data = _.merge({ q, }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.searchNodes;
+
+		if (this.debugMode) {
+			console.log('searchNodes', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for searchNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root,
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				return root;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Moves the supplied treeNode to a new position on the tree
+	 * @returns id of common ancestor node 
+	 */
+	moveTreeNode(treeNode, newParentId) {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.moveTreeNode is no longer valid. Repository has been destroyed.');
+			return;
+		}
+		if (!this.isOnline) {
+			this.throwError('Offline');
+			return;
+		}
+
+		const
+			oldParentId = treeNode.parent?.id,
+			data = _.merge({ nodeId: treeNode.id, parentId: newParentId, }, this._baseParams, this._params),
+			url = this.rootNodeType + '/' + this.api.moveNode;
+
+		// NOTE: The rootNodeType controller needs to know about all the possible nodeTypes,
+		// so any particular node can move all around the tree.
+		
+		if (this.debugMode) {
+			console.log('moveTreeNode', data);
+		}
+
+		return this._send('POST', url, data)
+			.then((result) => {
+				if (this.debugMode) {
+					console.log('Response for searchNodes', result);
+				}
+
+				if (this.isDestroyed) {
+					// If this repository gets destroyed before it has a chance
+					// to process the Ajax request, just ignore the response.
+					return;
+				}
+
+				const {
+					root: {
+						commonAncestorId,
+						oldParent,
+						newParent,
+						node,
+					},
+					success,
+					total,
+					message
+				} = this._processServerResponse(result);
+
+				if (!success) {
+					this.throwError(message);
+					return;
+				}
+
+				// move it from oldParent.children to newParent.children
+				const
+					oldParentRecord = this.getById(oldParentId),
+					newParentRecord = this.getById(newParentId);
+
+				oldParentRecord?.loadOriginalData(oldParent);
+				newParentRecord.loadOriginalData(newParent);
+				treeNode.loadOriginalData(node);
+
+				this.assembleTreeNodes();
+
+				return commonAncestorId;
+			})
+			.finally(() => {
+				this.markLoading(false);
+			});
+	}
+
+	/**
+	 * Gets the root TreeNodes
+	 */
+	getRootNodes() {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.loadRootNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		// Look through all entities and pull out the root nodes.
+		// Subclasses of Repository will override this method to get root nodes from server
+		const entities = _.filter(this.getEntities(), (entity) => {
+			return entity.isRoot;
+		})
+		return entities;
+	}
+
+	/**
+	 * Populates the TreeNodes with .parent and .children references
+	 */
+	assembleTreeNodes() {
+		this.ensureTree();
+		if (this.isDestroyed) {
+			this.throwError('this.assembleTreeNodes is no longer valid. Repository has been destroyed.');
+			return;
+		}
+
+		const treeNodes = this.getEntities();
+
+		// Reset all parent/child relationships
+		_.each(treeNodes, (treeNode) => {
+			treeNode.parent = null;
+			treeNode.children = [];
+		});
+
+		// Rebuild all parent/child relationships
+		const oThis = this;
+		_.each(treeNodes, (treeNode) => {
+			const parent = oThis.getById(treeNode.parentId);
+			if (parent) {
+				treeNode.parent = parent;
+				parent.children.push(treeNode);
+			}
+		});
+	}
+
+	/**
+	 * Removes the treeNode and all of its children from repository
+	 * without deleting anything on the server
+	 */
+	removeTreeNode(treeNode) {
+		if (!_.isEmpty(treeNode.children)) {
+			const children = treeNode.children;
+			treeNode.parent = null;
+			treeNode.children = [];
+			
+			const oThis = this;
+			_.each(children, (child) => {
+				oThis.removeTreeNode(child);
+			});
+		}
+	
+		this.removeEntity(treeNode);
+	}
+
+	/**
+	 * Helper to make sure this Repository is a tree
+	 * @private
+	 */
+	async ensureTree() {
+		if (!this.isTree) {
+			this.throwError('This Repository is not a tree!');
+			return false;
+		}
+		return true;
+	}
+
+}
+
+
+TreeRepository.className = 'Tree';
+TreeRepository.type = 'tree';
+
+export default TreeRepository;

package/src/Repository/index.js

@@ -7,6 +7,7 @@ import MemoryRepository from './Memory.js';
 import NullRepository from './Null.js';
 import OneBuildRepository from './OneBuild.js';
 import RestRepository from './Rest.js';
+import TreeRepository from './Tree.js';
 
 const CoreRepositoryTypes = {
 	[AjaxRepository.type]: AjaxRepository,
@@ -16,6 +17,7 @@ const CoreRepositoryTypes = {
 	[NullRepository.type]: NullRepository,
 	[OneBuildRepository.type]: OneBuildRepository,
 	[RestRepository.type]: RestRepository,
+	[TreeRepository.type]: TreeRepository,
 };
 
 export default CoreRepositoryTypes;

package/src/Schema/Schema.js

@@ -75,24 +75,19 @@ export default class Schema extends EventEmitter {
 				 * @member {string} parentIdProperty - name of parent_id Property (e.g. 'categories__parent_id' for Adjacency Lists, and parent_id for Closure Tables)
 				 * For trees only
 				 */
-				parentIdProperty: null,
+				parentIdProperty: 'parentId',
 
 				/**
 				 * @member {string} depthIdProperty - name of depth Property (e.g. 'categories__depth' for Adjacency Lists, and depth for Closure Tables)
 				 * For trees only
 				 */
-				depthProperty: null,
+				depthProperty: 'depth',
 
 				/**
 				 * @member {string} hasChildrenProperty - name of hasChildren Property (e.g. 'categories__has_children' for Adjacency Lists, and has_children for Closure Tables)
 				 * For trees only
 				 */
-				hasChildrenProperty: null,
-
-				/**
-				 * @member {boolean} isTree - Whether this model has hierarchical tree data
-				 */
-				isTree: false,
+				hasChildrenProperty: 'hasChildren',
 
 				/**
 				 * @member {boolean} isAdjacencyList - Whether this tree is an Adjacency List
@@ -291,7 +286,9 @@ export default class Schema extends EventEmitter {
 				if (!propertyType) {
 					propertyType = PropertyTypes['string'];
 				}
-				const staticDefaults = propertyType.getStaticDefaults();
+				// Pass the property definition to getStaticDefaults for types like 'mixed'
+				// that need access to the configuration (e.g., the types array)
+				const staticDefaults = propertyType.getStaticDefaults(property);
 				defaultValue = staticDefaults.defaultValue;
 			}
 			if (_.isFunction(defaultValue)) {

package/src/Writer/index.js

@@ -1,10 +1,10 @@
 /** @module Writer */
 
 import JsonWriter from './JsonWriter.js';
-import XmlWriter from './XmlWriter.js';
+// import XmlWriter from './XmlWriter.js';
 
 const WriterTypes = {
 	[JsonWriter.type]: JsonWriter,
-	[XmlWriter.type]: XmlWriter,
+	// [XmlWriter.type]: XmlWriter,
 };
 export default WriterTypes;