@rentman/rm-core 1.0.0 → 1.0.1

package/src/classes/CollectionEntryService.ts

@@ -1,83 +0,0 @@
-import QueryParserFactory from "../factories/QueryParserFactory";
-import ItemEntry from "../models/ItemEntry";
-import QueryService from './QueryService';
-import { shallowMerge } from "./Util";
-
-export default class CollectionEntryService {
-	constructor (
-		private queryParserFactory: QueryParserFactory,
-		private queryService: QueryService
-	) {
-
-	}
-
-	processOptions (options) {
-		return shallowMerge(
-			options,
-			{
-				columns: [],
-				query: null,
-				queryItemType: null,
-				queryParams: {},
-				parent: null,
-				deferRequest: false,
-				limit: null,
-				entryKey: '',
-				addLocalItems: false
-			}
-		);
-	}
-
-	createQuery (options) {
-		const parent = options.parent;
-
-		let query;
-
-		if (parent === null)
-			query = options.query;
-		else {
-			const linkedToQuery = {linkedTo: parent.itemType, query: {id: '&parentId'}};
-			options.queryParams.parentId = parent.itemId;
-
-			query = options.query === null ?
-				linkedToQuery :
-				this.queryService.addAndCondition(options.query, linkedToQuery);
-		}
-
-		const parsedQuery = this.queryParserFactory.construct(query, options.queryParams).parse();
-
-		return {object: parsedQuery[0], string: parsedQuery[1]};
-	}
-
-	getIdArray (itemEntries: ItemEntry[], accumulator) {
-		if (accumulator === undefined)
-			accumulator = [];
-
-		for (const itemEntry of itemEntries)
-			accumulator.push(itemEntry.itemId);
-
-		return accumulator;
-	}
-
-	filterArray (itemEntries: ItemEntry[], callback) {
-		const filteredEntries = [];
-		const removedEntries = [];
-
-		for (const itemEntry of itemEntries) {
-			if (callback(itemEntry))
-				filteredEntries.push(itemEntry);
-			else
-				removedEntries.push(itemEntry);
-		}
-
-		if (removedEntries.length === 0)
-			return removedEntries;
-
-		itemEntries.length = filteredEntries.length;
-
-		for (let i = 0; i < itemEntries.length; i++)
-			itemEntries[i] = filteredEntries[i];
-
-		return removedEntries;
-	}
-}

package/src/classes/CollectionHandler.ts

@@ -1,619 +0,0 @@
-import { ENTRY_STATUS } from "../constants";
-import CollectionCacheFactory from "../factories/CollectionCacheFactory";
-import CollectionEntryFactory from "../factories/CollectionEntryFactory";
-import ColumnSetFactory from "../factories/ColumnSetFactory";
-import QueryParserFactory from "../factories/QueryParserFactory";
-import { identity } from "../index";
-import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
-import CollectionEntry from "../models/CollectionEntry";
-import CollectionResource from "../models/CollectionResource";
-import ItemEntry from "../models/ItemEntry";
-import ItemResource from "../models/ItemResource";
-import CollectionCache from "./CollectionCache";
-import CollectionEntryService from "./CollectionEntryService";
-import ColumnHandler from "./ColumnHandler";
-import ColumnUtil from "./ColumnUtil";
-import ItemCache from "./ItemCache";
-import ItemEntryService from "./ItemEntryService";
-import ItemHandler from "./ItemHandler";
-import ItemRequestService from "./ItemRequestService";
-import KeyService from "./KeyService";
-import PromiseService from "./PromiseService";
-import QueryService from "./QueryService";
-import { hasProperties } from "./Util";
-
-export default class CollectionHandler {
-	entries: CollectionCache;
-
-	constructor (
-		private errorHandler: ErrorHandlerInterface,
-		private itemRequestService: ItemRequestService,
-		private itemHandler: ItemHandler,
-		private columnHandler: ColumnHandler,
-		private collectionEntryFactory: CollectionEntryFactory,
-		private collectionCacheFactory: CollectionCacheFactory,
-		private queryParserFactory: QueryParserFactory,
-		private collectionEntryService: CollectionEntryService,
-		private columnSetFactory: ColumnSetFactory,
-		private itemEntryService: ItemEntryService,
-		private keyService: KeyService,
-		private promiseService: PromiseService,
-		private queryService: QueryService,
-		private columnUtil: ColumnUtil
-	) {
-		this.entries = this.collectionCacheFactory.construct();
-	}
-
-	getPromises (statusResource) {
-		const promised = statusResource[ENTRY_STATUS.PROMISED];
-		const promisedExpand = statusResource[ENTRY_STATUS.PROMISED_EXPAND];
-		const result = [];
-
-		for (const parentId in promised)
-			result.push(promised[parentId]);
-
-		for (const parentId in promisedExpand)
-			result.push(promisedExpand[parentId]);
-
-		return result;
-	}
-
-	getRequestIds (statusResource) {
-		const result = [];
-
-		for (const parentId in statusResource[ENTRY_STATUS.RESOLVE])
-			result.push(parentId);
-
-		for (const parentId in statusResource[ENTRY_STATUS.EXPAND])
-			result.push(parentId);
-
-		return result;
-	}
-
-	removeFromAndAddToCollections (collectionMap, updateInitial?) {
-		for (const collectionId in collectionMap) {
-			const entry = collectionMap[collectionId];
-			const collection: CollectionEntry = entry.collection;
-
-			collection.removeItems(entry.notfitting, null, true);
-			collection.addItems(entry.fitting, null, true); // doesn't do anything with initial
-
-			if (entry.maybe.length > 0)
-				collection.extend(identity, null, true, updateInitial);
-		}
-	}
-
-	removeFromCollections (collectionMap, updateInitial?, resultResource: CollectionResource | null = null) {
-		let result;
-
-		for (const collectionId in collectionMap) {
-			const mapEntry = collectionMap[collectionId];
-			const fitting = mapEntry.fitting;
-			const maybe = mapEntry.maybe;
-			const collectionEntry: CollectionEntry = mapEntry.collection;
-			const idArray = [];
-
-			for (const fittingItem of fitting)
-				idArray.push(fittingItem.itemId);
-
-			for (const maybeItem of maybe)
-				idArray.push(maybeItem);
-
-			if (resultResource !== null && collectionEntry === resultResource.entry)
-				result = collectionEntry.removeItems(idArray, resultResource, updateInitial);
-			else
-				collectionEntry.removeItems(idArray, null, updateInitial);
-		}
-
-		return result;
-	}
-
-	/**
-	 * @deprecated
-	 */
-	addItemsToCollections (itemEntries: ItemEntry[]) {
-		return this.addToCollections(this.createCollectionMap(itemEntries), false);
-	}
-
-	// TODO: maybe, boolean instead of message
-	addToCollections (collectionMap, updateInitial: boolean, resultResource: ItemResource | null = null) {
-		let result;
-
-		for (const collectionId in collectionMap) {
-			const mapEntry = collectionMap[collectionId];
-			const collectionEntry = mapEntry.collection;
-
-			if (collectionEntry.isDeferred())
-				continue;
-
-			if (resultResource !== null && collectionEntry === resultResource.entry)
-				result = collectionEntry.addItems(mapEntry.fitting, resultResource, updateInitial);
-			else
-				collectionEntry.addItems(mapEntry.fitting, null, updateInitial);
-
-			if (updateInitial && mapEntry.maybe.length > 0)
-				collectionEntry.extend(identity, null, true, updateInitial);
-		}
-
-		return result;
-	}
-
-	batchExpand (parentType: string, itemType: string, collections: CollectionResource[], newColumns) {
-		if (newColumns.length === 0)
-			return this.promiseService.when(collections);
-
-		const parentIdArray = [];
-		let itemEntries = [];
-
-		// TODO: filter local items?
-
-		for (const parentId in collections) {
-			parentIdArray.push(parentId);
-
-			itemEntries = itemEntries.concat(collections[parentId].entry.items);
-		}
-
-		return this.itemRequestService.requestLinkItems(
-			parentType,
-			parentIdArray,
-			itemType,
-			null,
-			newColumns
-		).then(
-			response => {
-				const columnExpansion = this.itemRequestService.processExpansion(
-					newColumns,
-					response,
-					itemType,
-					itemEntries
-				);
-
-				for (const parentId of parentIdArray)
-					collections[parentId].entry.updateColumns(columnExpansion);
-			}
-		);
-	}
-
-	batchExtend (parentType: string, itemType: string, options, queryCallback, collections: CollectionResource[], returnAllItems = false) {
-		if (!hasProperties(collections))
-			return {};
-
-		const parentIdArray = [];
-		let itemIdArray = [];
-
-		options.queryParams = queryCallback(options.queryParams);
-
-		for (const parentId in collections) {
-			const collectionEntry = collections[parentId].entry;
-
-			collectionEntry.extendQuery(queryCallback);
-			parentIdArray.push(parentId);
-
-			itemIdArray = itemIdArray.concat(collectionEntry.getIdArray());
-		}
-
-		return this.itemRequestService.requestLinkItems(
-			parentType,
-			parentIdArray,
-			itemType,
-			this.queryService.addAndCondition(
-				this.collectionEntryService.createQuery(options).object,
-				this.queryService.createNotIn(itemIdArray)
-			),
-			options.columns
-		).then(
-			response => {
-				return this.itemRequestService.processLinkResponse(
-					response,
-					parentType,
-					parentIdArray,
-					itemType,
-					options
-				);
-			},
-			this.errorHandler.reject
-		).then(
-			itemEntryResource => {
-				const result = {};
-
-				for (const parentId of parentIdArray) {
-					const collectionResource = collections[parentId];
-					const itemResources = collectionResource.entry.addItems( // should go first
-						itemEntryResource.items[parentId],
-						collectionResource
-					);
-
-					result[parentId] = returnAllItems ? collectionResource.items : itemResources;
-				}
-
-				return result;
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	batchFetch (
-		parentType: string,
-		parentIdArray: number[],
-		itemType: string,
-		options,
-		deferredCollectionCache: CollectionCache
-	) {
-		const resource = this.createStatusResource(parentType, parentIdArray, itemType, options, deferredCollectionCache);
-
-		return this.promiseService.all(this.getPromises(resource)).then(
-			() => {
-				const requestIds = this.getRequestIds(resource);
-
-				if (requestIds.length > 0) {
-					return this.itemRequestService.requestLinkItems(
-						parentType,
-						requestIds,
-						itemType,
-						options.query === null ?
-							null :
-							this.queryParserFactory.construct(options.query, options.queryParams).parse()[0],
-						options.columns
-					).then(
-						response => {
-							return this.itemRequestService.processLinkResponse(
-								response,
-								parentType,
-								requestIds,
-								itemType,
-								options
-							);
-						},
-						this.errorHandler.reject
-					).then(
-						itemEntryResource => {
-							return this.handleBatchResponse(resource, itemEntryResource);
-						},
-						this.errorHandler.reject
-					);
-				}
-
-				if (hasProperties(resource[ENTRY_STATUS.LOCAL])) {
-					return this.columnHandler.fetch(itemType, options.columns).then(
-						responseColumns => {
-							return this.handleBatchResponse(
-								resource,
-								{
-									columns: this.columnSetFactory.construct(
-										itemType,
-										options.columns,
-										responseColumns,
-										false
-									)
-								}
-							);
-						},
-						this.errorHandler.reject
-					);
-				}
-
-				return resource[ENTRY_STATUS.CACHED];
-
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	clone (collectionEntry: CollectionEntry, options, conversionMap = {}) {
-		const itemType = collectionEntry.itemType;
-		const items = collectionEntry.items;
-		const clonedItems = [];
-
-		if (conversionMap[itemType] === undefined)
-			conversionMap[itemType] = {};
-
-		const conversionMapEntry = conversionMap[itemType];
-
-		// update the conversion map first (dependencies)
-		for (const item of items)
-			conversionMapEntry[item.itemId] = this.keyService.getLocalId();
-
-		for (const itemEntry of items) {
-			const clonedEntry = this.itemHandler.cloneItem(
-				conversionMapEntry[itemEntry.itemId],
-				itemEntry,
-				conversionMap
-			);
-
-			if (options.parent !== null)
-				clonedEntry.parent = options.parent;
-
-			clonedItems.push(clonedEntry);
-		}
-
-		return this.create(itemType, options, collectionEntry.columns, clonedItems);
-	}
-
-	create (itemType: string, options, columns, items: ItemEntry[]) {
-		return this.entries.add(
-			this.collectionEntryFactory.construct(
-				itemType,
-				options
-			)
-		).resolve(
-			{
-				columns: columns,
-				items: items
-			}
-		);
-	}
-
-	createCollectionMap (itemEntries: ItemEntry[]) {
-		const result = {};
-
-		for (const itemEntry of itemEntries)
-			this.expandCollectionMap(itemEntry, result);
-
-		return result;
-	}
-
-	createStatusResource (
-		parentType: string,
-		parentIdArray: number[],
-		itemType: string, options,
-		deferredCollectionCache: CollectionCache
-	) {
-		const result = {};
-
-		for (const statusId in ENTRY_STATUS)
-			result[ENTRY_STATUS[statusId]] = {};
-
-		for (const parentId of parentIdArray) {
-			const entryOptions = this.collectionEntryService.processOptions(options); // use processEntryOptions to clone
-
-			let statusResource;
-
-			entryOptions.parent = {itemType: parentType, itemId: parentId};
-
-			statusResource = this.getEntryStatus(itemType, entryOptions, deferredCollectionCache);
-
-			result[statusResource.status][parentId] = statusResource.entry;
-		}
-
-		return result;
-	}
-
-	expandCollectionMap (
-		itemEntry: ItemEntry,
-		accumulator,
-		collectionCache: CollectionCache = this.entries
-	) {
-		// todo: parent type
-		const parent: any = itemEntry.parent !== undefined ? itemEntry.parent : {};
-
-		const collections = collectionCache.getByFittingItem(
-			parent.itemType,
-			parent.itemId,
-			itemEntry.itemType,
-			this.itemEntryService.getFields(itemEntry)
-		);
-
-		for (const status in collections) {
-			for (const collection of collections[status]) {
-				const collectionId = collection.id;
-
-				if (accumulator[collectionId] === undefined)
-					accumulator[collectionId] = {collection: collection, fitting: [], notfitting: [], maybe: []};
-
-				accumulator[collectionId][status].push(status === 'fitting' ? itemEntry : itemEntry.itemId);
-			}
-		}
-	}
-
-	fetch (itemType: string, options, itemCache: ItemCache, deferredCollectionCache: CollectionCache) {
-		const statusResource = this.getEntryStatus(itemType, options, deferredCollectionCache);
-		const entry = statusResource.entry;
-
-		switch (statusResource.status) {
-			case ENTRY_STATUS.CACHED:
-				return this.promiseService.when(entry);
-			case ENTRY_STATUS.PROMISED:
-				return entry.promise;
-			case ENTRY_STATUS.EXPAND:
-				return entry.expand(options.columns);
-			case ENTRY_STATUS.PROMISED_EXPAND:
-				return entry.promise.then(
-					() => {
-						return entry.expand(options.columns);
-					},
-					this.errorHandler.reject
-				);
-			case ENTRY_STATUS.RESOLVE:
-				return this.resolveRemote(entry, itemCache);
-			case ENTRY_STATUS.LOCAL:
-				return this.resolveLocal(entry, itemCache);
-		}
-	}
-
-	getDeferredEntryStatus (collectionEntry: CollectionEntry, options) {
-		// because the collection entry is not fully loaded yet, we'll have to rely on the options
-		const entryOptions = collectionEntry.options;
-		const entryColumns = entryOptions.columns;
-
-		let isColumnSubset = false;
-
-		if (collectionEntry.reloadQueued) {
-			collectionEntry.reloadQueued = false;
-			entryOptions.columns = this.columnUtil.mergeRequestColumns(options.columns, entryColumns).merged;
-
-			return {
-				entry: collectionEntry,
-				status: collectionEntry.isLocal() ? ENTRY_STATUS.LOCAL : ENTRY_STATUS.RESOLVE
-			};
-		}
-
-		if (entryColumns === true) {
-			console.warn('Columns: true for collections is deprecated!');
-			isColumnSubset = true;
-		} else
-			isColumnSubset = this.columnUtil.isColumnSubset(options.columns, entryColumns, false);
-
-		return {
-			entry: collectionEntry,
-			status: isColumnSubset ? ENTRY_STATUS.PROMISED : ENTRY_STATUS.PROMISED_EXPAND
-		};
-	}
-
-	getEntryStatus (itemType: string, options, deferredEntries: CollectionCache) {
-		const query = this.collectionEntryService.createQuery(options);
-		const cachedEntry = this.entries.getByQuery(itemType, query);
-
-		if (cachedEntry === null)
-			return this.getNewEntryStatus(itemType, query, options, deferredEntries);
-
-		if (cachedEntry.isDeferred())
-			return this.getDeferredEntryStatus(cachedEntry, options);
-
-		return {
-			entry: cachedEntry,
-			status: this.columnUtil.isColumnSubset(options.columns, cachedEntry.columns.request, cachedEntry.columns.true) ?
-				ENTRY_STATUS.CACHED : ENTRY_STATUS.EXPAND
-		};
-	}
-
-	getNewEntryStatus (itemType: string, query, options, deferredEntries: CollectionCache) {
-		let collectionEntry;
-		let deferredOptions;
-
-		if (options.deferRequest) {
-			collectionEntry = deferredEntries.getByQuery(itemType, query);
-
-			if (collectionEntry === null) {
-				return {
-					entry: deferredEntries.add(this.collectionEntryFactory.construct(itemType, options)),
-					status: ENTRY_STATUS.PROMISED
-				};
-			}
-
-			deferredOptions = collectionEntry.options;
-			deferredOptions.columns = this.columnUtil.mergeRequestColumns(deferredOptions.columns, options.columns).merged;
-		} else {
-			collectionEntry = this.collectionEntryFactory.construct(itemType, options);
-		}
-
-		this.entries.add(collectionEntry); // will also add the deferred entry
-
-		return {
-			entry: collectionEntry,
-			status: collectionEntry.isLocal() ? ENTRY_STATUS.LOCAL : ENTRY_STATUS.RESOLVE
-		};
-	}
-
-	handleBatchResponse (statusResource, itemEntryResource) {
-		const result = {};
-
-		for (const parentId in statusResource.cached)
-			result[parentId] = statusResource.cached[parentId];
-
-		for (const parentId in statusResource.resolve) {
-			result[parentId] = statusResource.resolve[parentId].resolve(
-				{
-					items: itemEntryResource.items[parentId],
-					columns: itemEntryResource.columns
-				}
-			);
-		}
-
-		for (const parentId in statusResource.expand) {
-			const collectionEntry: CollectionEntry = statusResource.expand[parentId];
-
-			collectionEntry.updateColumns(itemEntryResource.columnExpansion);
-
-			result[parentId] = collectionEntry;
-		}
-
-		for (const parentId in statusResource.local) {
-			const collectionEntry: CollectionEntry = statusResource.local[parentId];
-
-			result[parentId] = collectionEntry.resolve(
-				{
-					items: this.itemHandler.entries.getByParent( // TODO: use tab cache?
-						collectionEntry.parent.itemType,
-						parentId,
-						collectionEntry.itemType
-					),
-					columns: itemEntryResource.columns
-				}
-			);
-		}
-
-		return result;
-	}
-
-	/**
-	 * @deprecated
-	 */
-	removeItemsFromAndAddItemsToCollections (itemEntries: ItemEntry[]) {
-		return this.removeFromAndAddToCollections(
-			this.createCollectionMap(itemEntries),
-			false
-		);
-	}
-
-	/**
-	 * @deprecated
-	 */
-	// TODO: maybe
-	removeItemsFromCollections (itemEntries: ItemEntry[]) {
-		return this.removeFromCollections(
-			this.createCollectionMap(itemEntries),
-			false
-		);
-	}
-
-	resolveLocal (collectionEntry: CollectionEntry, itemCache) {
-		const itemType = collectionEntry.itemType;
-		const requestColumns = collectionEntry.options.columns;
-
-		return this.columnHandler.fetch(itemType, requestColumns).then(
-			responseColumns => {
-				return collectionEntry.resolve(
-					{
-						items: itemCache.getByQuery(itemType, collectionEntry.query),
-						columns: this.columnSetFactory.construct(itemType, requestColumns, responseColumns, false)
-					}
-				);
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	resolveRemote (collectionEntry, itemCache) {
-		const itemType = collectionEntry.itemType;
-		const options = collectionEntry.options;
-
-		let columnInfo;
-
-		return this.itemRequestService.requestItems(collectionEntry).then(
-			response => {
-				columnInfo = this.columnSetFactory.construct(itemType, options.columns, response.fetchColumnsObject());
-
-				return this.itemRequestService.processResponse(
-					response,
-					response.links[itemType],
-					collectionEntry.parent,
-					columnInfo
-				);
-			},
-			this.errorHandler.reject
-		).then(itemEntries => {
-				return collectionEntry.resolve(
-					{
-						items: itemEntries.concat(
-							options.addLocalItems ?
-								itemCache.getLocalByQuery(itemType, collectionEntry.query) :
-								[]
-						),
-						columns: columnInfo
-					}
-				);
-			},
-			this.errorHandler.reject
-		);
-	}
-}