Add REST store support

package.json

@@ -18,7 +18,7 @@
   "typings": "./dist/umd/@dojo/stores.d.ts",
   "peerDependencies": {
     "@dojo/compose": "2.0.0-beta.21",
-    "@dojo/core": "2.0.0-alpha.20",
+    "@dojo/core": "2.0.0-alpha.21",
     "@dojo/shim": "2.0.0-beta.8",
     "@dojo/has": "2.0.0-alpha.7"
   },

src/patch/createPatch.ts

@@ -4,7 +4,7 @@ import createJsonPointer, { JsonPointer } from './createJsonPointer';
 export interface Patch<T, U> {
 	operations: Operation[];
 	apply(target: T): U;
-	toString(): String;
+	toString(): string;
 }
 
 export type PatchMapEntry<T, U> = { id: string; patch: Patch<T, U> };

src/query/createFilter.ts

@@ -164,16 +164,16 @@ function createFilterHelper<T>(filters: FilterChainMember<T>[], serializer: (fil
 			}
 			return createFilterHelper(newFilters, serializer);
 		},
-		lessThan(path: ObjectPointer<T>, value: number) {
+		lessThan(path: ObjectPointer<T>, value: any) {
 			return comparatorFilterHelper(FilterType.LessThan, value, path);
 		},
-		lessThanOrEqualTo(path: ObjectPointer<T>, value: number) {
+		lessThanOrEqualTo(path: ObjectPointer<T>, value: any) {
 			return comparatorFilterHelper(FilterType.LessThanOrEqualTo, value, path);
 		},
-		greaterThan(path: ObjectPointer<T>, value: number) {
+		greaterThan(path: ObjectPointer<T>, value: any) {
 			return comparatorFilterHelper(FilterType.GreaterThan, value, path);
 		},
-		greaterThanOrEqualTo(path: ObjectPointer<T>, value: number) {
+		greaterThanOrEqualTo(path: ObjectPointer<T>, value: any) {
 			return comparatorFilterHelper(FilterType.GreaterThanOrEqualTo, value, path);
 		},
 		matches(path: ObjectPointer<T>, value: RegExp) {

src/storage/createBaseStorage.ts

@@ -0,0 +1,80 @@
+import WeakMap from '@dojo/shim/WeakMap';
+import Promise from '@dojo/shim/Promise';
+import { Patch, PatchMapEntry } from '../patch/createPatch';
+import { Query } from '../query/interfaces';
+import { StoreOperation, CrudOptions, StoreOptions } from '../store/createStore';
+import compose, { ComposeFactory } from '@dojo/compose/compose';
+
+export interface FetchResult<T> extends Promise<T[]> {
+	/**
+	 * A Promise that resolves to the total number of items in the underlying storage.
+	 */
+	totalLength: Promise<number>;
+	/**
+	 * For a store, this is identical to totalLength. For a QueryTransformResult, this resolves to the number of items
+	 * that match the QueryTransformResult's queries
+	 */
+	dataLength: Promise<number>;
+}
+
+export type IdObject = { [ index: string ]: string; id: string };
+
+export type CrudArgument<T> = T | string | PatchMapEntry<T, T>;
+
+export interface UpdateResults<T> {
+	currentItems?: T[];
+	failedData?: CrudArgument<T>[];
+	successfulData: T[] | string[];
+	type: StoreOperation;
+}
+
+export interface BaseStorage<T> {
+	identify(items: T[]|T): string[];
+}
+
+export interface Storage<T, O extends CrudOptions> extends BaseStorage<T> {
+	createId(): Promise<string>;
+	fetch(query?: Query<T>): FetchResult<T>;
+	get(ids: string[]): Promise<T[]>;
+	put(items: T[], options?: O): Promise<UpdateResults<T>>;
+	add(items: T[], options?: O): Promise<UpdateResults<T>>;
+	delete(ids: string[]): Promise<UpdateResults<T>>;
+	patch(updates: { id: string; patch: Patch<T, T> }[], options?: O): Promise<UpdateResults<T>>;
+	isUpdate(item: T): Promise<{ isUpdate: boolean; item: T, id: string }>;
+}
+
+export interface BaseStorageState<T> {
+	idProperty?: string;
+	idFunction?: (item: T) => string;
+}
+
+export interface StorageFactory extends ComposeFactory<Storage<{}, {}>, StoreOptions<{}, CrudOptions>> {
+	<T extends {}, O extends CrudOptions>(options?: StoreOptions<T, O>): Storage<T, O>;
+}
+
+const instanceStateMap = new WeakMap<Storage<{}, {}>, BaseStorageState<{}>>();
+
+const createBaseStorage = compose<BaseStorage<IdObject>, StoreOptions<{}, CrudOptions>>({
+	identify(this: Storage<{}, {}>, items: IdObject[]| IdObject): string[] {
+		const state = instanceStateMap.get(this);
+		const itemArray = Array.isArray(items) ? <IdObject []> items : [ <IdObject> items ];
+		if (state.idProperty) {
+			return itemArray.map((item) => item[state.idProperty!]);
+		}
+		else if (state.idFunction) {
+			return itemArray.map(state.idFunction);
+		}
+		else {
+			return itemArray.map((item) => item.id);
+		}
+	}
+
+}, <T, O>(instance: Storage<T, O>, options?: StoreOptions<T, CrudOptions>) => {
+	options = options || {};
+	instanceStateMap.set(instance, {
+		idProperty: options.idProperty,
+		idFunction: options.idFunction
+	});
+});
+
+export default createBaseStorage;