@aws-amplify/datastore 3.14.0 → 3.14.1-unstable.10

package/src/sync/processors/sync.ts

@@ -26,6 +26,7 @@ import {
 	ConsoleLogger as Logger,
 	Hub,
 	NonRetryableError,
+	BackgroundProcessManager,
 } from '@aws-amplify/core';
 import { ModelPredicateCreator } from '../../predicates';
 import { getSyncErrorType } from './errorMaps';
@@ -40,6 +41,8 @@ const logger = new Logger('DataStore');
 class SyncProcessor {
 	private readonly typeQuery = new WeakMap<SchemaModel, [string, string]>();
 
+	private runningProcesses = new BackgroundProcessManager();
+
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>,
@@ -90,7 +93,8 @@ class SyncProcessor {
 		lastSync: number,
 		nextToken: string,
 		limit: number = null,
-		filter: GraphQLFilter
+		filter: GraphQLFilter,
+		onTerminate: Promise<void>
 	): Promise<{ nextToken: string; startedAt: number; items: T[] }> {
 		const [opName, query] = this.typeQuery.get(modelDefinition);
 
@@ -113,6 +117,12 @@ class SyncProcessor {
 
 		let authModeAttempts = 0;
 		const authModeRetry = async () => {
+			if (!this.runningProcesses.isOpen) {
+				throw new Error(
+					'sync.retreievePage termination was requested. Exiting.'
+				);
+			}
+
 			try {
 				logger.debug(
 					`Attempting sync with authMode: ${readAuthModes[authModeAttempts]}`
@@ -123,6 +133,7 @@ class SyncProcessor {
 					opName,
 					modelDefinition,
 					authMode: readAuthModes[authModeAttempts],
+					onTerminate,
 				});
 				logger.debug(
 					`Sync successful with authMode: ${readAuthModes[authModeAttempts]}`
@@ -175,12 +186,14 @@ class SyncProcessor {
 		opName,
 		modelDefinition,
 		authMode,
+		onTerminate,
 	}: {
 		query: string;
 		variables: { limit: number; lastSync: number; nextToken: string };
 		opName: string;
 		modelDefinition: SchemaModel;
 		authMode: GRAPHQL_AUTH_MODE;
+		onTerminate: Promise<void>;
 	}): Promise<
 		GraphQLResult<{
 			[opName: string]: {
@@ -205,6 +218,8 @@ class SyncProcessor {
 						authToken,
 						userAgentSuffix: USER_AGENT_SUFFIX_DATASTORE,
 					});
+
+					// TODO: onTerminate.then(() => API.cancel(...))
 				} catch (error) {
 					// Catch client-side (GraphQLAuthError) & 401/403 errors here so that we don't continue to retry
 					const clientOrForbiddenErrorMessage =
@@ -288,14 +303,15 @@ class SyncProcessor {
 					throw error;
 				}
 			},
-			[query, variables]
+			[query, variables],
+			undefined,
+			onTerminate
 		);
 	}
 
 	start(
 		typesLastSync: Map<SchemaModel, [string, number]>
 	): Observable<SyncModelPage> {
-		let processing = true;
 		const { maxRecordsToSync, syncPageSize } = this.amplifyConfig;
 		const parentPromises = new Map<string, Promise<void>>();
 		const observable = new Observable<SyncModelPage>(observer => {
@@ -314,76 +330,88 @@ class SyncProcessor {
 
 			const allModelsReady = Array.from(sortedTypesLastSyncs.entries())
 				.filter(([{ syncable }]) => syncable)
-				.map(async ([modelDefinition, [namespace, lastSync]]) => {
-					let done = false;
-					let nextToken: string = null;
-					let startedAt: number = null;
-					let items: ModelInstanceMetadata[] = null;
-
-					let recordsReceived = 0;
-					const filter = this.graphqlFilterFromPredicate(modelDefinition);
-
-					const parents = this.schema.namespaces[
-						namespace
-					].modelTopologicalOrdering.get(modelDefinition.name);
-					const promises = parents.map(parent =>
-						parentPromises.get(`${namespace}_${parent}`)
-					);
-
-					const promise = new Promise<void>(async res => {
-						await Promise.all(promises);
-
-						do {
-							if (!processing) {
-								return;
-							}
-
-							const limit = Math.min(
-								maxRecordsToSync - recordsReceived,
-								syncPageSize
+				.map(
+					([modelDefinition, [namespace, lastSync]]) =>
+						this.runningProcesses.isOpen &&
+						this.runningProcesses.add(async onTerminate => {
+							let done = false;
+							let nextToken: string = null;
+							let startedAt: number = null;
+							let items: ModelInstanceMetadata[] = null;
+
+							let recordsReceived = 0;
+							const filter = this.graphqlFilterFromPredicate(modelDefinition);
+
+							const parents = this.schema.namespaces[
+								namespace
+							].modelTopologicalOrdering.get(modelDefinition.name);
+							const promises = parents.map(parent =>
+								parentPromises.get(`${namespace}_${parent}`)
 							);
 
-							({ items, nextToken, startedAt } = await this.retrievePage(
-								modelDefinition,
-								lastSync,
-								nextToken,
-								limit,
-								filter
-							));
-
-							recordsReceived += items.length;
-
-							done = nextToken === null || recordsReceived >= maxRecordsToSync;
-
-							observer.next({
-								namespace,
-								modelDefinition,
-								items,
-								done,
-								startedAt,
-								isFullSync: !lastSync,
-							});
-						} while (!done);
+							const promise = new Promise<void>(async res => {
+								await Promise.all(promises);
+
+								do {
+									if (!this.runningProcesses.isOpen) {
+										return;
+									}
+
+									const limit = Math.min(
+										maxRecordsToSync - recordsReceived,
+										syncPageSize
+									);
+
+									({ items, nextToken, startedAt } = await this.retrievePage(
+										modelDefinition,
+										lastSync,
+										nextToken,
+										limit,
+										filter,
+										onTerminate
+									));
+
+									recordsReceived += items.length;
+
+									done =
+										nextToken === null || recordsReceived >= maxRecordsToSync;
+
+									observer.next({
+										namespace,
+										modelDefinition,
+										items,
+										done,
+										startedAt,
+										isFullSync: !lastSync,
+									});
+								} while (!done);
 
-						res();
-					});
+								res();
+							});
 
-					parentPromises.set(`${namespace}_${modelDefinition.name}`, promise);
+							parentPromises.set(
+								`${namespace}_${modelDefinition.name}`,
+								promise
+							);
 
-					await promise;
-				});
+							await promise;
+						}, `adding model ${modelDefinition.name}`)
+				);
 
 			Promise.all(allModelsReady).then(() => {
 				observer.complete();
 			});
-
-			return () => {
-				processing = false;
-			};
 		});
 
 		return observable;
 	}
+
+	async stop() {
+		logger.debug('stopping sync processor');
+		await this.runningProcesses.close();
+		await this.runningProcesses.open();
+		logger.debug('sync processor stopped');
+	}
 }
 
 export type SyncModelPage = {

package/src/sync/utils.ts

@@ -661,9 +661,7 @@ export function getIdentifierValue(
 ): string {
 	const pkFieldNames = extractPrimaryKeyFieldNames(modelDefinition);
 
-	const idOrPk = pkFieldNames
-		.map(f => model[f])
-		.join(IDENTIFIER_KEY_SEPARATOR);
+	const idOrPk = pkFieldNames.map(f => model[f]).join(IDENTIFIER_KEY_SEPARATOR);
 
 	return idOrPk;
 }

package/src/util.ts

@@ -39,13 +39,13 @@ export const ID = 'id';
  * Used by the Async Storage Adapter to concatenate key values
  * for a record. For instance, if a model has the following keys:
  * `customId: ID! @primaryKey(sortKeyFields: ["createdAt"])`,
- * we concatenate the `customId` and `createdAt` as: 
+ * we concatenate the `customId` and `createdAt` as:
  * `12-234-5#2022-09-28T00:00:00.000Z`
  */
 export const DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR = '#';
 
 /**
- * Used for generating spinal-cased index name from an array of 
+ * Used for generating spinal-cased index name from an array of
  * key field names.
  * E.g. for keys `[id, title]` => 'id-title'
  */
@@ -417,6 +417,96 @@ export const isPrivateMode = () => {
 	});
 };
 
+let safariCompatabilityModeResult;
+
+/**
+ * Whether the browser's implementation of IndexedDB breaks on array lookups
+ * against composite indexes whose keypath contains a single column.
+ *
+ * E.g., Whether `store.createIndex(indexName, ['id'])` followed by
+ * `store.index(indexName).get([1])` will *ever* return records.
+ *
+ * In all known, modern Safari browsers as of Q4 2022, the query against an index like
+ * this will *always* return `undefined`. So, the index needs to be created as a scalar.
+ */
+export const isSafariCompatabilityMode: () => Promise<boolean> = async () => {
+	try {
+		const dbName = uuid();
+		const storeName = 'indexedDBFeatureProbeStore';
+		const indexName = 'idx';
+
+		if (indexedDB === null) return false;
+
+		if (safariCompatabilityModeResult !== undefined) {
+			return safariCompatabilityModeResult;
+		}
+
+		const db: IDBDatabase | false = await new Promise(resolve => {
+			const dbOpenRequest = indexedDB.open(dbName);
+			dbOpenRequest.onerror = () => resolve(false);
+
+			dbOpenRequest.onsuccess = () => {
+				const db = dbOpenRequest.result;
+				resolve(db);
+			};
+
+			dbOpenRequest.onupgradeneeded = (event: any) => {
+				const db = event?.target?.result;
+
+				db.onerror = () => resolve(false);
+
+				const store = db.createObjectStore(storeName, {
+					autoIncrement: true,
+				});
+
+				store.createIndex(indexName, ['id']);
+			};
+		});
+
+		if (!db) {
+			throw new Error('Could not open probe DB');
+		}
+
+		const rwTx = db.transaction(storeName, 'readwrite');
+		const rwStore = rwTx.objectStore(storeName);
+		rwStore.add({
+			id: 1,
+		});
+
+		(rwTx as any).commit();
+
+		const result = await new Promise(resolve => {
+			const tx = db.transaction(storeName, 'readonly');
+			const store = tx.objectStore(storeName);
+			const index = store.index(indexName);
+
+			const getRequest = index.get([1]);
+
+			getRequest.onerror = () => resolve(false);
+
+			getRequest.onsuccess = (event: any) => {
+				resolve(event?.target?.result);
+			};
+		});
+
+		if (db && typeof db.close === 'function') {
+			await db.close();
+		}
+
+		await indexedDB.deleteDatabase(dbName);
+
+		if (result === undefined) {
+			safariCompatabilityModeResult = true;
+		} else {
+			safariCompatabilityModeResult = false;
+		}
+	} catch (error) {
+		safariCompatabilityModeResult = false;
+	}
+
+	return safariCompatabilityModeResult;
+};
+
 const randomBytes = (nBytes: number): Buffer => {
 	return Buffer.from(new WordArray().random(nBytes).toString(), 'hex');
 };

package/lib/authModeStrategies/defaultAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy } from '../types';
-export declare const defaultAuthStrategy: AuthModeStrategy;

package/lib/authModeStrategies/index.d.ts

@@ -1,2 +0,0 @@
-export { defaultAuthStrategy } from './defaultAuthStrategy';
-export { multiAuthStrategy } from './multiAuthStrategy';

package/lib/authModeStrategies/multiAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy, AmplifyContext } from '../types';
-export declare const multiAuthStrategy: (amplifyContext: AmplifyContext) => AuthModeStrategy;

package/lib/datastore/datastore.d.ts

@@ -1,63 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { PredicateAll } from '../predicates';
-import { ConflictHandler, DataStoreConfig, NonModelTypeConstructor, ProducerPaginationInput, PersistentModel, PersistentModelConstructor, ProducerModelPredicate, Schema, SubscriptionMessage, DataStoreSnapshot, TypeConstructorMap, ErrorHandler, ObserveQueryOptions, PersistentModelMetaData, IdentifierFieldOrIdentifierObject } from '../types';
-export declare let syncClasses: TypeConstructorMap;
-declare const initSchema: (userSchema: Schema) => Record<string, PersistentModelConstructor<any> | NonModelTypeConstructor<unknown>>;
-export declare type ModelInstanceCreator = typeof modelInstanceCreator;
-declare function modelInstanceCreator<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, init: Partial<T>): T;
-declare class DataStore {
-    private Auth;
-    private API;
-    private Cache;
-    private amplifyConfig;
-    private authModeStrategy;
-    private conflictHandler;
-    private errorHandler;
-    private fullSyncInterval;
-    private initialized?;
-    private initReject;
-    private initResolve;
-    private maxRecordsToSync;
-    private storage?;
-    private sync?;
-    private syncPageSize;
-    private syncExpressions;
-    private syncPredicates;
-    private sessionId;
-    private storageAdapter;
-    private amplifyContext;
-    getModuleName(): string;
-    start: () => Promise<void>;
-    query: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: IdentifierFieldOrIdentifierObject<T, PersistentModelMetaData<T>>): Promise<T | undefined>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ProducerModelPredicate<T> | typeof PredicateAll, paginationProducer?: ProducerPaginationInput<T>): Promise<T[]>;
-    };
-    save: <T extends Readonly<Record<string, any>>>(model: T, condition?: ProducerModelPredicate<T>) => Promise<T>;
-    setConflictHandler: (config: DataStoreConfig) => ConflictHandler;
-    setErrorHandler: (config: DataStoreConfig) => ErrorHandler;
-    delete: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: IdentifierFieldOrIdentifierObject<T, PersistentModelMetaData<T>>): Promise<T[]>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition: ProducerModelPredicate<T> | typeof PredicateAll): Promise<T[]>;
-        <T extends PersistentModel>(model: T, condition?: ProducerModelPredicate<T>): Promise<T>;
-    };
-    observe: {
-        (): Observable<SubscriptionMessage<PersistentModel>>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: string): Observable<SubscriptionMessage<T>>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ProducerModelPredicate<T> | typeof PredicateAll): Observable<SubscriptionMessage<T>>;
-        <T extends PersistentModel>(model: T): Observable<SubscriptionMessage<T>>;
-    };
-    observeQuery: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ProducerModelPredicate<T> | typeof PredicateAll, paginationProducer?: ObserveQueryOptions<T>): Observable<DataStoreSnapshot<T>>;
-    };
-    configure: (config?: DataStoreConfig) => void;
-    clear: () => Promise<void>;
-    stop: (this: DataStore) => Promise<void>;
-    private processPagination;
-    private processSyncExpressions;
-    private createFromCondition;
-    private unwrapPromise;
-    private weakMapFromEntries;
-    private retrieveSessionId;
-}
-declare const instance: DataStore;
-export { DataStore as DataStoreClass, initSchema, instance as DataStore };

package/lib/index.d.ts

@@ -1,15 +0,0 @@
-export { DataStore, DataStoreClass, initSchema, ModelInstanceCreator, } from './datastore/datastore';
-export { Predicates, ModelPredicateCreator, ModelSortPredicateCreator, } from './predicates';
-export { Adapter as StorageAdapter } from './storage/adapter';
-export declare const utils: {
-    USER: import("./util").NAMESPACES;
-    traverseModel: <T extends Readonly<Record<string, any>>>(srcModelName: string, instance: T, namespace: import("./types").SchemaNamespace, modelInstanceCreator: <T_1 extends Readonly<Record<string, any>>>(modelConstructor: import("./types").PersistentModelConstructor<T_1>, init: Partial<T_1>) => T_1, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => import("./types").PersistentModelConstructor<any>) => {
-        modelName: string;
-        item: T;
-        instance: T;
-    }[];
-    validatePredicate: <T_2 extends Readonly<Record<string, any>>>(model: T_2, groupType: "and" | "or" | "not", predicatesOrGroups: (import("./types").PredicateObject<T_2> | import("./types").PredicatesGroup<T_2>)[]) => any;
-    isNonModelConstructor: (obj: any) => obj is import("./types").NonModelTypeConstructor<any>;
-    isModelConstructor: <T_3 extends Readonly<Record<string, any>>>(obj: any) => obj is import("./types").PersistentModelConstructor<T_3>;
-};
-export * from './types';

package/lib/predicates/index.d.ts

@@ -1,16 +0,0 @@
-import { ModelPredicate, PersistentModel, PredicatesGroup, ProducerModelPredicate, SchemaModel } from '../types';
-export { ModelSortPredicateCreator } from './sort';
-export declare function isPredicatesAll(predicate: any): predicate is typeof PredicateAll;
-export declare const PredicateAll: unique symbol;
-export declare class Predicates {
-    static get ALL(): typeof PredicateAll;
-}
-export declare class ModelPredicateCreator {
-    private static predicateGroupsMap;
-    private static createPredicateBuilder;
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is ModelPredicate<T>;
-    static getPredicates<T extends PersistentModel>(predicate: ModelPredicate<T>, throwOnInvalid?: boolean): PredicatesGroup<any>;
-    static createFromExisting<T extends PersistentModel>(modelDefinition: SchemaModel, existing?: ProducerModelPredicate<T>): ModelPredicate<T>;
-    static createForSingleField<T extends PersistentModel>(modelDefinition: SchemaModel, fieldName: string, value: string): ModelPredicate<T>;
-    static createForPk<T extends PersistentModel>(modelDefinition: SchemaModel, model: T): ModelPredicate<T>;
-}

package/lib/predicates/sort.d.ts

@@ -1,8 +0,0 @@
-import { PersistentModel, SchemaModel, SortPredicate, ProducerSortPredicate, SortPredicatesGroup } from '../types';
-export declare class ModelSortPredicateCreator {
-    private static sortPredicateGroupsMap;
-    private static createPredicateBuilder;
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is SortPredicate<T>;
-    static getPredicates<T extends PersistentModel>(predicate: SortPredicate<T>, throwOnInvalid?: boolean): SortPredicatesGroup<T>;
-    static createFromExisting<T extends PersistentModel>(modelDefinition: SchemaModel, existing: ProducerSortPredicate<T>): SortPredicate<T>;
-}

package/lib/ssr/index.d.ts

@@ -1,3 +0,0 @@
-import { PersistentModel, PersistentModelConstructor } from '@aws-amplify/datastore';
-export declare function deserializeModel<T extends PersistentModel>(Model: PersistentModelConstructor<T>, init: T | T[]): any;
-export declare function serializeModel<T extends PersistentModel>(model: T | T[]): JSON;

package/lib/storage/adapter/AsyncStorageAdapter.d.ts

@@ -1,41 +0,0 @@
-import { Adapter } from './index';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-export declare class AsyncStorageAdapter implements Adapter {
-    private schema;
-    private namespaceResolver;
-    private modelInstanceCreator;
-    private getModelConstructorByModelName;
-    private db;
-    private initPromise;
-    private resolve;
-    private reject;
-    private getStorenameForModel;
-    private getIndexKeyValuesFromModel;
-    private getIndexKeyValuesPath;
-    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    private load;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    private getByKey;
-    private getAll;
-    private keyValueFromPredicate;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
-    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
-    private deleteItem;
-    /**
-     * Populates the delete Queue with all the items to delete
-     * @param relations
-     * @param models
-     * @param srcModel
-     * @param nameSpace
-     * @param deleteQueue
-     */
-    private deleteTraverse;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-}
-declare const _default: AsyncStorageAdapter;
-export default _default;

package/lib/storage/adapter/AsyncStorageDatabase.d.ts

@@ -1,39 +0,0 @@
-import { ModelInstanceMetadata, OpType, PaginationInput, PersistentModel, QueryOne } from '../../types';
-declare class AsyncStorageDatabase {
-    /**
-     * Maps storeNames to a map of ulid->id
-     */
-    private _collectionInMemoryIndex;
-    private storage;
-    /**
-     * Collection index is map of stores (i.e. sync, metadata, mutation event, and data)
-     * @param storeName {string} - Name of the store
-     * @returns Map of ulid->id
-     */
-    private getCollectionIndex;
-    /**
-     * Return ULID for store if it exists, otherwise create a new one
-     * @param storeName {string} - Name of the store
-     * @returns ulid
-     */
-    private getMonotonicFactory;
-    init(): Promise<void>;
-    save<T extends PersistentModel>(item: T, storeName: string, keys: string[], keyValuesPath: string): Promise<void>;
-    batchSave<T extends PersistentModel>(storeName: string, items: ModelInstanceMetadata[], keys: string[]): Promise<[T, OpType][]>;
-    get<T extends PersistentModel>(keyValuePath: string, storeName: string): Promise<T>;
-    getOne(firstOrLast: QueryOne, storeName: string): Promise<any>;
-    /**
-     * This function gets all the records stored in async storage for a particular storeName
-     * It then loads all the records for that filtered set of keys using multiGet()
-     */
-    getAll<T extends PersistentModel>(storeName: string, pagination?: PaginationInput<T>): Promise<T[]>;
-    delete(key: string, storeName: string): Promise<void>;
-    /**
-     * Clear the AsyncStorage of all DataStore entries
-     */
-    clear(): Promise<void>;
-    private getKeyForItem;
-    private getLegacyKeyForItem;
-    private getKeyPrefixForStoreItems;
-}
-export default AsyncStorageDatabase;

package/lib/storage/adapter/InMemoryStore.d.ts

@@ -1,11 +0,0 @@
-export declare class InMemoryStore {
-    db: Map<string, string>;
-    getAllKeys: () => Promise<string[]>;
-    multiGet: (keys: string[]) => Promise<any[]>;
-    multiRemove: (keys: string[], callback?: any) => Promise<void>;
-    multiSet: (entries: string[][], callback?: any) => Promise<void>;
-    setItem: (key: string, value: string) => Promise<Map<string, string>>;
-    removeItem: (key: string) => Promise<boolean>;
-    getItem: (key: string) => Promise<string>;
-}
-export declare function createInMemoryStore(): InMemoryStore;

package/lib/storage/adapter/InMemoryStore.native.d.ts

@@ -1 +0,0 @@
-export declare function createInMemoryStore(): AsyncStorage;

package/lib/storage/adapter/IndexedDBAdapter.d.ts

@@ -1,38 +0,0 @@
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-import { Adapter } from './index';
-declare class IndexedDBAdapter implements Adapter {
-    private schema;
-    private namespaceResolver;
-    private modelInstanceCreator;
-    private getModelConstructorByModelName;
-    private db;
-    private initPromise;
-    private resolve;
-    private reject;
-    private dbName;
-    private getStorenameForModel;
-    private getIndexKeyValuesFromModel;
-    private checkPrivate;
-    private getNamespaceAndModelFromStorename;
-    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, sessionId?: string): Promise<void>;
-    private _get;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    private load;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    private getByKey;
-    private getAll;
-    private keyValueFromPredicate;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    private enginePagination;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
-    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
-    private deleteItem;
-    private deleteTraverse;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    private createObjectStoreForModel;
-}
-declare const _default: IndexedDBAdapter;
-export default _default;

package/lib/storage/adapter/getDefaultAdapter/index.d.ts

@@ -1,3 +0,0 @@
-import { Adapter } from '..';
-declare const getDefaultAdapter: () => Adapter;
-export default getDefaultAdapter;

package/lib/storage/adapter/getDefaultAdapter/index.native.d.ts

@@ -1,3 +0,0 @@
-import { Adapter } from '..';
-declare const getDefaultAdapter: () => Adapter;
-export default getDefaultAdapter;

package/lib/storage/adapter/index.d.ts

@@ -1,9 +0,0 @@
-import { ModelInstanceMetadata, ModelPredicate, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne, SystemComponent } from '../../types';
-export interface Adapter extends SystemComponent {
-    clear(): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete: <T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>) => Promise<[T[], T[]]>;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast: QueryOne): Promise<T | undefined>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-}