@aws-amplify/datastore 5.0.1-unstable.cfbde4c.0 → 5.0.1

package/lib/predicates/next.d.ts

@@ -1,317 +0,0 @@
-import { PersistentModel, ModelMeta, ModelPredicate as StoragePredicate, PredicateInternalsKey, V5ModelPredicate as ModelPredicate, RecursiveModelPredicate } from '../types';
-import { ExclusiveStorage as StorageAdapter } from '../storage/storage';
-type GroupOperator = 'and' | 'or' | 'not';
-type UntypedCondition = {
-    fetch: (storage: StorageAdapter) => Promise<Record<string, any>[]>;
-    matches: (item: Record<string, any>) => Promise<boolean>;
-    copy(extract?: GroupCondition): [UntypedCondition, GroupCondition | undefined];
-    toAST(): any;
-};
-/**
- * Takes a key object from `registerPredicateInternals()` to fetch an internal
- * `GroupCondition` object, which can then be used to query storage or
- * test/match objects.
- *
- * This indirection exists to hide `GroupCondition` from public interfaces, since
- * `GroupCondition` contains extra methods and properties that public callers
- * should not use.
- *
- * @param key A key object previously returned by `registerPredicateInternals()`
- */
-export declare const internals: (key: any) => GroupCondition;
-/**
- * A condition that can operate against a single "primitive" field of a model or item.
- * @member field The field of *some record* to test against.
- * @member operator The equality or comparison operator to use.
- * @member operands The operands for the equality/comparison check.
- */
-export declare class FieldCondition {
-    field: string;
-    operator: string;
-    operands: string[];
-    constructor(field: string, operator: string, operands: string[]);
-    /**
-     * Creates a copy of self.
-     * @param extract Not used. Present only to fulfill the `UntypedCondition` interface.
-     * @returns A new, identitical `FieldCondition`.
-     */
-    copy(extract?: GroupCondition): [FieldCondition, GroupCondition | undefined];
-    /**
-     * Produces a tree structure similar to a graphql condition. The returned
-     * structure is "dumb" and is intended for another query/condition
-     * generation mechanism to interpret, such as the cloud or storage query
-     * builders.
-     *
-     * E.g.,
-     *
-     * ```json
-     * {
-     * 	"name": {
-     * 		"eq": "robert"
-     * 	}
-     * }
-     * ```
-     */
-    toAST(): {
-        [x: string]: {
-            [x: string]: string | string[];
-        };
-    };
-    /**
-     * Produces a new condition (`FieldCondition` or `GroupCondition`) that
-     * matches the opposite of this condition.
-     *
-     * Intended to be used when applying De Morgan's Law, which can be done to
-     * produce more efficient queries against the storage layer if a negation
-     * appears in the query tree.
-     *
-     * For example:
-     *
-     * 1. `name.eq('robert')` becomes `name.ne('robert')`
-     * 2. `price.between(100, 200)` becomes `m => m.or(m => [m.price.lt(100), m.price.gt(200)])`
-     *
-     * @param model The model meta to use when construction a new `GroupCondition`
-     * for cases where the negation requires multiple `FieldCondition`'s.
-     */
-    negated(model: ModelMeta<any>): GroupCondition | FieldCondition;
-    /**
-     * Not implemented. Not needed. GroupCondition instead consumes FieldConditions and
-     * transforms them into legacy predicates. (*For now.*)
-     * @param storage N/A. If ever implemented, the storage adapter to query.
-     * @returns N/A. If ever implemented, return items from `storage` that match.
-     */
-    fetch(storage: StorageAdapter): Promise<Record<string, any>[]>;
-    /**
-     * Determins whether a given item matches the expressed condition.
-     * @param item The item to test.
-     * @returns `Promise<boolean>`, `true` if matches; `false` otherwise.
-     */
-    matches(item: Record<string, any>): Promise<boolean>;
-    /**
-     * Checks `this.operands` for compatibility with `this.operator`.
-     */
-    validate(): void;
-}
-/**
- * A set of sub-conditions to operate against a model, optionally scoped to
- * a specific field, combined with the given operator (one of `and`, `or`, or `not`).
- * @member groupId Used to distinguish between GroupCondition instances for
- * debugging and troublehsooting.
- * @member model A metadata object that tells GroupCondition what to query and how.
- * @member field The field on the model that the sub-conditions apply to.
- * @member operator How to group child conditions together.
- * @member operands The child conditions.
- */
-export declare class GroupCondition {
-    /**
-     * The `ModelMeta` of the model to query and/or filter against.
-     * Expected to contain:
-     *
-     * ```js
-     * {
-     * 	builder: ModelConstructor,
-     * 	schema: SchemaModel,
-     * 	pkField: string[]
-     * }
-     * ```
-     */
-    model: ModelMeta<any>;
-    /**
-     * If populated, this group specifices a condition on a relationship.
-     *
-     * If `field` does *not* point to a related model, that's an error. It
-     * could indicate that the `GroupCondition` was instantiated with bad
-     * data, or that the model metadata is incorrect.
-     */
-    field: string | undefined;
-    /**
-     * If a `field` is given, whether the relationship is a `HAS_ONE`,
-     * 'HAS_MANY`, or `BELONGS_TO`.
-     *
-     * TODO: Remove this and replace with derivation using
-     * `ModelRelationship.from(this.model, this.field).relationship`;
-     */
-    relationshipType: string | undefined;
-    /**
-     *
-     */
-    operator: GroupOperator;
-    /**
-     *
-     */
-    operands: UntypedCondition[];
-    /**
-     * Whether this GroupCondition is the result of an optimize call.
-     *
-     * This is used to guard against infinitely fetch -> optimize -> fetch
-     * recursion.
-     */
-    isOptimized: boolean;
-    groupId: string;
-    constructor(
-    /**
-     * The `ModelMeta` of the model to query and/or filter against.
-     * Expected to contain:
-     *
-     * ```js
-     * {
-     * 	builder: ModelConstructor,
-     * 	schema: SchemaModel,
-     * 	pkField: string[]
-     * }
-     * ```
-     */
-    model: ModelMeta<any>, 
-    /**
-     * If populated, this group specifices a condition on a relationship.
-     *
-     * If `field` does *not* point to a related model, that's an error. It
-     * could indicate that the `GroupCondition` was instantiated with bad
-     * data, or that the model metadata is incorrect.
-     */
-    field: string | undefined, 
-    /**
-     * If a `field` is given, whether the relationship is a `HAS_ONE`,
-     * 'HAS_MANY`, or `BELONGS_TO`.
-     *
-     * TODO: Remove this and replace with derivation using
-     * `ModelRelationship.from(this.model, this.field).relationship`;
-     */
-    relationshipType: string | undefined, 
-    /**
-     *
-     */
-    operator: GroupOperator, 
-    /**
-     *
-     */
-    operands: UntypedCondition[], 
-    /**
-     * Whether this GroupCondition is the result of an optimize call.
-     *
-     * This is used to guard against infinitely fetch -> optimize -> fetch
-     * recursion.
-     */
-    isOptimized?: boolean);
-    /**
-     * Returns a copy of a GroupCondition, which also returns the copy of a
-     * given reference node to "extract".
-     * @param extract A node of interest. Its copy will *also* be returned if the node exists.
-     * @returns [The full copy, the copy of `extract` | undefined]
-     */
-    copy(extract?: GroupCondition): [GroupCondition, GroupCondition | undefined];
-    /**
-     * Creates a new `GroupCondition` that contains only the local field conditions,
-     * omitting related model conditions. That resulting `GroupCondition` can be
-     * used to produce predicates that are compatible with the storage adapters and
-     * Cloud storage.
-     *
-     * @param negate Whether the condition tree should be negated according
-     * to De Morgan's law.
-     */
-    withFieldConditionsOnly(negate: boolean): GroupCondition;
-    /**
-     * Returns a version of the predicate tree with unnecessary logical groups
-     * condensed and merged together. This is intended to create a dense tree
-     * with leaf nodes (`FieldCondition`'s) aggregated under as few group conditions
-     * as possible for the most efficient fetching possible -- it allows `fetch()`.
-     *
-     * E.g. a grouping like this:
-     *
-     * ```yaml
-     * and:
-     * 	and:
-     * 		id:
-     * 			eq: "abc"
-     * 	and:
-     * 		name:
-     * 			eq: "xyz"
-     * ```
-     *
-     * Will become this:
-     *
-     * ```yaml
-     * and:
-     * 	id:
-     * 		eq: "abc"
-     * 	name:
-     * 		eq: "xyz"
-     * ```
-     *
-     * This allows `fetch()` to pass both the `id` and `name` conditions to the adapter
-     * together, which can then decide what index to use based on both fields together.
-     *
-     * @param preserveNode Whether to preserve the current node and to explicitly not eliminate
-     * it during optimization. Used internally to preserve the root node and children of
-     * `not` groups. `not` groups will always have a single child, so there's nothing to
-     * optimize below a `not` (for now), and it makes the query logic simpler later.
-     */
-    optimized(preserveNode?: boolean): UntypedCondition;
-    /**
-     * Fetches matching records from a given storage adapter using legacy predicates (for now).
-     * @param storage The storage adapter this predicate will query against.
-     * @param breadcrumb For debugging/troubleshooting. A list of the `groupId`'s this
-     * GroupdCondition.fetch is nested within.
-     * @param negate Whether to match on the `NOT` of `this`.
-     * @returns An `Promise` of `any[]` from `storage` matching the child conditions.
-     */
-    fetch(storage: StorageAdapter, breadcrumb?: string[], negate?: boolean): Promise<Record<string, any>[]>;
-    /**
-     * Determines whether a single item matches the conditions of `this`.
-     * When checking the target `item`'s properties, each property will be `await`'d
-     * to ensure lazy-loading is respected where applicable.
-     * @param item The item to match against.
-     * @param ignoreFieldName Tells `match()` that the field name has already been dereferenced.
-     * (Used for iterating over children on HAS_MANY checks.)
-     * @returns A boolean (promise): `true` if matched, `false` otherwise.
-     */
-    matches(item: Record<string, any>, ignoreFieldName?: boolean): Promise<boolean>;
-    /**
-     * Tranfsorm to a AppSync GraphQL compatible AST.
-     * (Does not support filtering in nested types.)
-     */
-    toAST(): {
-        [x: string]: any[];
-    };
-    /**
-     * Turn this predicate group into something a storage adapter
-     * understands how to use.
-     */
-    toStoragePredicate<T>(): StoragePredicate<T>;
-    /**
-     * A JSON representation that's good for debugging.
-     */
-    toJSON(): this & {
-        model: string;
-    };
-}
-/**
- * Creates a "seed" predicate that can be used to build an executable condition.
- * This is used in `query()`, for example, to seed customer- E.g.,
- *
- * ```
- * const p = predicateFor({builder: modelConstructor, schema: modelSchema, pkField: string[]});
- * p.and(child => [
- *   child.field.eq('whatever'),
- *   child.childModel.childField.eq('whatever else'),
- *   child.childModel.or(child => [
- *     child.otherField.contains('x'),
- *     child.otherField.contains('y'),
- *     child.otherField.contains('z'),
- *   ])
- * ])
- * ```
- *
- * `predicateFor()` returns objecst with recursive getters. To facilitate this,
- * a `query` and `tail` can be provided to "accumulate" nested conditions.
- *
- * @param ModelType The ModelMeta used to build child properties.
- * @param field Scopes the query branch to a field.
- * @param query A base query to build on. Omit to start a new query.
- * @param tail The point in an existing `query` to attach new conditions to.
- * @returns A ModelPredicate (builder) that customers can create queries with.
- * (As shown in function description.)
- */
-export declare function recursivePredicateFor<T extends PersistentModel>(ModelType: ModelMeta<T>, allowRecursion?: boolean, field?: string, query?: GroupCondition, tail?: GroupCondition): RecursiveModelPredicate<T> & PredicateInternalsKey;
-export declare function predicateFor<T extends PersistentModel>(ModelType: ModelMeta<T>): ModelPredicate<T> & PredicateInternalsKey;
-export {};

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/ssr/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeModel = exports.deserializeModel = void 0;
-// Helper for converting JSON back into DataStore models (while respecting IDs)
-function deserializeModel(Model, init) {
-    if (Array.isArray(init)) {
-        return init.map(init => deserializeModel(Model, init));
-    }
-    // `fromJSON` is intentionally hidden from types as a "private" method (though it exists on the instance)
-    // @ts-ignore Property 'fromJSON' does not exist on type 'PersistentModelConstructor<T>'.ts(2339)
-    return Model.fromJSON(init);
-}
-exports.deserializeModel = deserializeModel;
-// Helper for converting DataStore models to JSON
-function serializeModel(model) {
-    return JSON.parse(JSON.stringify(model));
-}
-exports.serializeModel = serializeModel;

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

@@ -1,40 +0,0 @@
-import AsyncStorageDatabase from './AsyncStorageDatabase';
-import { ModelInstanceMetadata, ModelPredicate, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-import { StorageAdapterBase } from './StorageAdapterBase';
-export declare class AsyncStorageAdapter extends StorageAdapterBase {
-    protected db: AsyncStorageDatabase;
-    protected preSetUpChecks(): Promise<void>;
-    protected preOpCheck(): Promise<void>;
-    /**
-     * Open AsyncStorage database
-     * Create new DB if one doesn't exist
-     *
-     * Called by `StorageAdapterBase.setUp()`
-     *
-     * @returns AsyncStorageDatabase instance
-     */
-    protected initDb(): Promise<AsyncStorageDatabase>;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    protected _get<T>(storeName: string, keyArr: string[]): Promise<T>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    private getByKey;
-    private getAll;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
-    protected deleteItem<T extends PersistentModel>(deleteQueue?: {
-        storeName: string;
-        items: T[] | IDBValidKey[];
-    }[]): Promise<void>;
-    /**
-     * Retrieves concatenated primary key values from a model
-     *
-     * @param model
-     * @returns
-     */
-    private getIndexKeyValuesPath;
-}
-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<[string, string][]>;
-    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(): import("@react-native-async-storage/async-storage").AsyncStorageStatic;

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

@@ -1,70 +0,0 @@
-import * as idb from 'idb';
-import { ModelInstanceMetadata, ModelPredicate, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-import { StorageAdapterBase } from './StorageAdapterBase';
-declare class IndexedDBAdapter extends StorageAdapterBase {
-    protected db: idb.IDBPDatabase;
-    private safariCompatabilityMode;
-    protected preSetUpChecks(): Promise<void>;
-    protected preOpCheck(): Promise<void>;
-    /**
-     * Initialize IndexedDB database
-     * Create new DB if one doesn't exist
-     * Upgrade outdated DB
-     *
-     * Called by `StorageAdapterBase.setUp()`
-     *
-     * @returns IDB Database instance
-     */
-    protected initDb(): Promise<idb.IDBPDatabase>;
-    protected _get<T>(storeOrStoreName: idb.IDBPObjectStore | string, keyArr: string[]): Promise<T>;
-    clear(): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    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<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    protected deleteItem<T extends PersistentModel>(deleteQueue: {
-        storeName: string;
-        items: T[] | IDBValidKey[];
-    }[]): Promise<void>;
-    private checkPrivate;
-    /**
-     * Whether the browser's implementation of IndexedDB is coercing single-field
-     * indexes to a scalar key.
-     *
-     * If this returns `true`, we need to treat indexes containing a single field
-     * as scalars.
-     *
-     * See PR description for reference:
-     * https://github.com/aws-amplify/amplify-js/pull/10527
-     */
-    private setSafariCompatabilityMode;
-    private getNamespaceAndModelFromStorename;
-    private createObjectStoreForModel;
-    private getByKey;
-    private getAll;
-    /**
-     * Tries to generate an index fetcher for the given predicates. Assumes
-     * that the given predicate conditions are contained by an AND group and
-     * should therefore all match a single record.
-     *
-     * @param storeName The table to query.
-     * @param predicates The predicates to try to AND together.
-     * @param transaction
-     */
-    private matchingIndexQueries;
-    private baseQueryIndex;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    private enginePagination;
-    /**
-     * Checks the given path against the browser's IndexedDB implementation for
-     * necessary compatibility transformations, applying those transforms if needed.
-     *
-     * @param `keyArr` strings to compatibilize for browser-indexeddb index operations
-     * @returns An array or string, depending on and given key,
-     * that is ensured to be compatible with the IndexedDB implementation's nuances.
-     */
-    private canonicalKeyPath;
-}
-declare const _default: IndexedDBAdapter;
-export default _default;

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

@@ -1,134 +0,0 @@
-import { Adapter } from './index';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, PredicatesGroup, QueryOne } from '../../types';
-import { NAMESPACES } from '../../util';
-import type { IDBPDatabase, IDBPObjectStore } from 'idb';
-import type AsyncStorageDatabase from './AsyncStorageDatabase';
-export declare abstract class StorageAdapterBase implements Adapter {
-    protected schema: InternalSchema;
-    protected namespaceResolver: NamespaceResolver;
-    protected modelInstanceCreator: ModelInstanceCreator;
-    protected getModelConstructorByModelName: (namsespaceName: NAMESPACES, modelName: string) => PersistentModelConstructor<any>;
-    protected initPromise: Promise<void>;
-    protected resolve: (value?: any) => void;
-    protected reject: (value?: any) => void;
-    protected dbName: string;
-    protected abstract db: IDBPDatabase | AsyncStorageDatabase;
-    protected abstract preSetUpChecks(): Promise<void>;
-    protected abstract preOpCheck(): Promise<void>;
-    protected abstract initDb(): Promise<IDBPDatabase | AsyncStorageDatabase>;
-    /**
-     * Initializes local DB
-     *
-     * @param theSchema
-     * @param namespaceResolver
-     * @param modelInstanceCreator
-     * @param getModelConstructorByModelName
-     * @param sessionId
-     */
-    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: NAMESPACES, modelName: string) => PersistentModelConstructor<any>, sessionId?: string): Promise<void>;
-    abstract clear(): Promise<void>;
-    abstract save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): any;
-    abstract query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    abstract queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast: QueryOne): Promise<T | undefined>;
-    abstract batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    /**
-     * @param modelConstructor
-     * @returns local DB table name
-     */
-    protected getStorenameForModel(modelConstructor: PersistentModelConstructor<any>): string;
-    /**
-     *
-     * @param model - instantiated model record
-     * @returns the record's primary key values
-     */
-    protected getIndexKeyValuesFromModel<T extends PersistentModel>(model: T): string[];
-    /**
-     * Common metadata for `save` operation
-     * used by individual storage adapters
-     *
-     * @param model
-     */
-    protected saveMetadata<T extends PersistentModel>(model: T): {
-        storeName: string;
-        set: Set<string>;
-        connectionStoreNames: any;
-        modelKeyValues: string[];
-    };
-    /**
-     * Enforces conditional save. Throws if condition is not met.
-     * used by individual storage adapters
-     *
-     * @param model
-     */
-    protected validateSaveCondition<T extends PersistentModel>(condition?: ModelPredicate<T>, fromDB?: unknown): void;
-    protected abstract _get<T>(storeOrStoreName: IDBPObjectStore | string, keyArr: string[]): Promise<T>;
-    /**
-     * Instantiate models from POJO records returned from the database
-     *
-     * @param namespaceName - string model namespace
-     * @param srcModelName - string model name
-     * @param records - array of uninstantiated records
-     * @returns
-     */
-    protected load<T>(namespaceName: NAMESPACES, srcModelName: string, records: T[]): Promise<T[]>;
-    /**
-     * Extracts operands from a predicate group into an array of key values
-     * Used in the query method
-     *
-     * @param predicates - predicate group
-     * @param keyPath - string array of key names ['id', 'sortKey']
-     * @returns string[] of key values
-     *
-     * @example
-     * ```js
-     * { and:[{ id: { eq: 'abc' }}, { sortKey: { eq: 'def' }}] }
-     * ```
-     * Becomes
-     * ```
-     * ['abc', 'def']
-     * ```
-     */
-    private keyValueFromPredicate;
-    /**
-     * Common metadata for `query` operation
-     * used by individual storage adapters
-     *
-     * @param modelConstructor
-     * @param predicate
-     * @param pagination
-     */
-    protected queryMetadata<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): {
-        storeName: string;
-        namespaceName: NAMESPACES;
-        queryByKey: string[];
-        predicates: PredicatesGroup<any>;
-        hasSort: import("../../types").SortPredicate<T>;
-        hasPagination: number;
-    };
-    /**
-     * Delete record
-     * Cascades to related records (for Has One and Has Many relationships)
-     *
-     * @param modelOrModelConstructor
-     * @param condition
-     * @returns
-     */
-    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
-    protected abstract deleteItem<T extends PersistentModel>(deleteQueue?: {
-        storeName: string;
-        items: T[] | IDBValidKey[];
-    }[]): any;
-    /**
-     * Recursively traverse relationship graph and add
-     * all Has One and Has Many relations to `deleteQueue` param
-     *
-     * Actual deletion of records added to `deleteQueue` occurs in the `delete` method
-     *
-     * @param models
-     * @param modelConstructor
-     * @param namespace
-     * @param deleteQueue
-     */
-    private deleteTraverse;
-}

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/getDefaultAdapter/index.native.js

@@ -1,10 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const AsyncStorageAdapter_1 = __importDefault(require("../AsyncStorageAdapter"));
-const getDefaultAdapter = () => {
-    return AsyncStorageAdapter_1.default;
-};
-exports.default = getDefaultAdapter;