@aws-amplify/datastore 3.14.1-unstable.2 → 3.14.1

package/lib/storage/storage.d.ts

@@ -1,49 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { Patch } from 'immer';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne, SchemaNamespace, InternalSubscriptionMessage, SubscriptionMessage } from '../types';
-import { Adapter } from './adapter';
-export declare type StorageSubscriptionMessage<T extends PersistentModel> = InternalSubscriptionMessage<T> & {
-    mutator?: Symbol;
-};
-export declare type StorageFacade = Omit<Adapter, 'setUp'>;
-export declare type Storage = InstanceType<typeof StorageClass>;
-declare class StorageClass implements StorageFacade {
-    private readonly schema;
-    private readonly namespaceResolver;
-    private readonly getModelConstructorByModelName;
-    private readonly modelInstanceCreator;
-    private readonly adapter?;
-    private readonly sessionId?;
-    private initialized;
-    private readonly pushStream;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, modelInstanceCreator: ModelInstanceCreator, adapter?: Adapter, sessionId?: string);
-    static getNamespace(): SchemaNamespace;
-    init(): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol, patchesTuple?: [Patch[], PersistentModel]): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    delete<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition?: ModelPredicate<T>, mutator?: Symbol): 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>;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, skipOwn?: Symbol): Observable<SubscriptionMessage<T>>;
-    clear(completeObservable?: boolean): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[], mutator?: Symbol): Promise<[T, OpType][]>;
-    private getUpdateMutationInput;
-}
-declare class ExclusiveStorage implements StorageFacade {
-    private storage;
-    private readonly mutex;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, modelInstanceCreator: ModelInstanceCreator, adapter?: Adapter, sessionId?: string);
-    runExclusive<T>(fn: (storage: StorageClass) => Promise<T>): Promise<T>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol, patchesTuple?: [Patch[], PersistentModel]): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    delete<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition?: ModelPredicate<T>, mutator?: Symbol): 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>;
-    static getNamespace(): SchemaNamespace;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, skipOwn?: Symbol): Observable<SubscriptionMessage<T>>;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    init(): Promise<void>;
-}
-export { ExclusiveStorage };

package/lib/sync/datastoreConnectivity.d.ts

@@ -1,15 +0,0 @@
-import Observable from 'zen-observable-ts';
-declare type ConnectionStatus = {
-    online: boolean;
-};
-export default class DataStoreConnectivity {
-    private connectionStatus;
-    private observer;
-    private subscription;
-    private timeout;
-    constructor();
-    status(): Observable<ConnectionStatus>;
-    unsubscribe(): void;
-    socketDisconnected(): void;
-}
-export {};

package/lib/sync/datastoreReachability/index.d.ts

@@ -1,3 +0,0 @@
-export declare const ReachabilityMonitor: import("zen-observable-ts").default<{
-    online: boolean;
-}>;

package/lib/sync/datastoreReachability/index.native.d.ts

@@ -1,3 +0,0 @@
-export declare const ReachabilityMonitor: import("zen-observable-ts").default<{
-    online: boolean;
-}>;

package/lib/sync/index.d.ts

@@ -1,81 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { ExclusiveStorage as Storage } from '../storage/storage';
-import { ConflictHandler, ControlMessageType, ErrorHandler, InternalSchema, ModelInit, MutableModel, NamespaceResolver, PersistentModelConstructor, SchemaModel, SchemaNamespace, TypeConstructorMap, ModelPredicate, AuthModeStrategy, ManagedIdentifier, OptionallyManagedIdentifier, AmplifyContext } from '../types';
-import type { __modelMeta__ } from '../types';
-import { TransformerMutationType } from './utils';
-declare type StartParams = {
-    fullSyncInterval: number;
-};
-export declare class MutationEvent {
-    readonly [__modelMeta__]: {
-        identifier: OptionallyManagedIdentifier<MutationEvent, 'id'>;
-    };
-    readonly id: string;
-    readonly model: string;
-    readonly operation: TransformerMutationType;
-    readonly modelId: string;
-    readonly condition: string;
-    readonly data: string;
-    constructor(init: ModelInit<MutationEvent>);
-    static copyOf(src: MutationEvent, mutator: (draft: MutableModel<MutationEvent>) => void | MutationEvent): MutationEvent;
-}
-export declare class ModelMetadata {
-    readonly [__modelMeta__]: {
-        identifier: ManagedIdentifier<ModelMetadata, 'id'>;
-    };
-    readonly id: string;
-    readonly namespace: string;
-    readonly model: string;
-    readonly fullSyncInterval: number;
-    readonly lastSync?: number;
-    readonly lastFullSync?: number;
-    readonly lastSyncPredicate?: null | string;
-    constructor(init: ModelInit<ModelMetadata>);
-    static copyOf(src: ModelMetadata, mutator: (draft: MutableModel<ModelMetadata>) => void | ModelMetadata): ModelMetadata;
-}
-export declare enum ControlMessage {
-    SYNC_ENGINE_STORAGE_SUBSCRIBED = "storageSubscribed",
-    SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED = "subscriptionsEstablished",
-    SYNC_ENGINE_SYNC_QUERIES_STARTED = "syncQueriesStarted",
-    SYNC_ENGINE_SYNC_QUERIES_READY = "syncQueriesReady",
-    SYNC_ENGINE_MODEL_SYNCED = "modelSynced",
-    SYNC_ENGINE_OUTBOX_MUTATION_ENQUEUED = "outboxMutationEnqueued",
-    SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED = "outboxMutationProcessed",
-    SYNC_ENGINE_OUTBOX_STATUS = "outboxStatus",
-    SYNC_ENGINE_NETWORK_STATUS = "networkStatus",
-    SYNC_ENGINE_READY = "ready"
-}
-export declare class SyncEngine {
-    private readonly schema;
-    private readonly namespaceResolver;
-    private readonly modelClasses;
-    private readonly userModelClasses;
-    private readonly storage;
-    private readonly modelInstanceCreator;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly amplifyContext;
-    private online;
-    private readonly syncQueriesProcessor;
-    private readonly subscriptionsProcessor;
-    private readonly mutationsProcessor;
-    private readonly modelMerger;
-    private readonly outbox;
-    private readonly datastoreConnectivity;
-    private readonly modelSyncedStatus;
-    getModelSyncedStatus(modelConstructor: PersistentModelConstructor<any>): boolean;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, modelClasses: TypeConstructorMap, userModelClasses: TypeConstructorMap, storage: Storage, modelInstanceCreator: ModelInstanceCreator, conflictHandler: ConflictHandler, errorHandler: ErrorHandler, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, amplifyContext: AmplifyContext);
-    start(params: StartParams): Observable<ControlMessageType<ControlMessage>>;
-    private getModelsMetadataWithNextFullSync;
-    private syncQueriesObservable;
-    private disconnectionHandler;
-    unsubscribeConnectivity(): void;
-    private setupModels;
-    private getModelsMetadata;
-    private getModelMetadata;
-    private getModelDefinition;
-    static getNamespace(): SchemaNamespace;
-}
-export {};

package/lib/sync/merger.d.ts

@@ -1,11 +0,0 @@
-import { Storage } from '../storage/storage';
-import { ModelInstanceMetadata, OpType, PersistentModelConstructor, SchemaModel } from '../types';
-import { MutationEventOutbox } from './outbox';
-declare class ModelMerger {
-    private readonly outbox;
-    private readonly ownSymbol;
-    constructor(outbox: MutationEventOutbox, ownSymbol: Symbol);
-    merge<T extends ModelInstanceMetadata>(storage: Storage, model: T, modelDefinition: SchemaModel): Promise<OpType>;
-    mergePage(storage: Storage, modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[], modelDefinition: SchemaModel): Promise<[ModelInstanceMetadata, OpType][]>;
-}
-export { ModelMerger };

package/lib/sync/outbox.d.ts

@@ -1,27 +0,0 @@
-import { MutationEvent } from './index';
-import { ExclusiveStorage as Storage, StorageFacade, Storage as StorageClass } from '../storage/storage';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { InternalSchema, PersistentModel, PersistentModelConstructor, SchemaModel } from '../types';
-import { TransformerMutationType } from './utils';
-declare class MutationEventOutbox {
-    private readonly schema;
-    private readonly MutationEvent;
-    private readonly modelInstanceCreator;
-    private readonly ownSymbol;
-    private inProgressMutationEventId;
-    constructor(schema: InternalSchema, MutationEvent: PersistentModelConstructor<MutationEvent>, modelInstanceCreator: ModelInstanceCreator, ownSymbol: Symbol);
-    enqueue(storage: Storage, mutationEvent: MutationEvent): Promise<void>;
-    dequeue(storage: StorageClass, record?: PersistentModel, recordOp?: TransformerMutationType): Promise<MutationEvent>;
-    /**
-     * Doing a peek() implies that the mutation goes "inProgress"
-     *
-     * @param storage
-     */
-    peek(storage: StorageFacade): Promise<MutationEvent>;
-    getForModel<T extends PersistentModel>(storage: StorageFacade, model: T, userModelDefinition: SchemaModel): Promise<MutationEvent[]>;
-    getModelIds(storage: StorageFacade): Promise<Set<string>>;
-    private syncOutboxVersionsOnDequeue;
-    private mergeUserFields;
-    private removeTimestampFields;
-}
-export { MutationEventOutbox };

package/lib/sync/processors/errorMaps.d.ts

@@ -1,17 +0,0 @@
-import { ErrorType } from '../../types';
-export declare type ErrorMap = Partial<{
-    [key in ErrorType]: (error: Error) => boolean;
-}>;
-export declare const mutationErrorMap: ErrorMap;
-export declare const subscriptionErrorMap: ErrorMap;
-export declare const syncErrorMap: ErrorMap;
-export declare function getMutationErrorType(error: Error): ErrorType;
-export declare function getSubscriptionErrorType(error: Error): ErrorType;
-export declare function getSyncErrorType(error: Error): ErrorType;
-/**
- * Categorizes an error with a broad error type, intended to make
- * customer error handling code simpler.
- * @param errorMap Error names and a list of patterns that indicate them (each pattern as a regex or function)
- * @param error The underying error to categorize.
- */
-export declare function mapErrorToType(errorMap: ErrorMap, error: Error): ErrorType;

package/lib/sync/processors/mutation.d.ts

@@ -1,56 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { MutationEvent } from '../';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { ExclusiveStorage as Storage } from '../../storage/storage';
-import { AuthModeStrategy, ConflictHandler, ErrorHandler, InternalSchema, PersistentModel, PersistentModelConstructor, SchemaModel, TypeConstructorMap, AmplifyContext } from '../../types';
-import { MutationEventOutbox } from '../outbox';
-import { TransformerMutationType } from '../utils';
-declare type MutationProcessorEvent = {
-    operation: TransformerMutationType;
-    modelDefinition: SchemaModel;
-    model: PersistentModel;
-    hasMore: boolean;
-};
-declare class MutationProcessor {
-    private readonly schema;
-    private readonly storage;
-    private readonly userClasses;
-    private readonly outbox;
-    private readonly modelInstanceCreator;
-    private readonly MutationEvent;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly conflictHandler;
-    private readonly amplifyContext;
-    private observer;
-    private readonly typeQuery;
-    private processing;
-    constructor(schema: InternalSchema, storage: Storage, userClasses: TypeConstructorMap, outbox: MutationEventOutbox, modelInstanceCreator: ModelInstanceCreator, MutationEvent: PersistentModelConstructor<MutationEvent>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, conflictHandler: ConflictHandler, amplifyContext: AmplifyContext);
-    private generateQueries;
-    private isReady;
-    start(): Observable<MutationProcessorEvent>;
-    resume(): Promise<void>;
-    private jitteredRetry;
-    private createQueryVariables;
-    private opTypeFromTransformerOperation;
-    pause(): void;
-}
-declare const originalJitteredBackoff: import("@aws-amplify/core/lib-esm/types").DelayFunction;
-/**
- * @private
- * Internal use of Amplify only.
- *
- * Wraps the jittered backoff calculation to retry Network Errors indefinitely.
- * Backs off according to original jittered retry logic until the original retry
- * logic hits its max. After this occurs, if the error is a Network Error, we
- * ignore the attempt count and return MAX_RETRY_DELAY_MS to retry forever (until
- * the request succeeds).
- *
- * @param attempt ignored
- * @param _args ignored
- * @param error tested to see if `.message` is 'Network Error'
- * @returns number | false :
- */
-export declare const safeJitteredBackoff: typeof originalJitteredBackoff;
-export { MutationProcessor };

package/lib/sync/processors/subscription.d.ts

@@ -1,31 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { InternalSchema, PersistentModel, SchemaModel, ModelPredicate, AuthModeStrategy, ErrorHandler, AmplifyContext } from '../../types';
-import { TransformerMutationType } from '../utils';
-export declare enum CONTROL_MSG {
-    CONNECTED = "CONNECTED"
-}
-export declare enum USER_CREDENTIALS {
-    'none' = 0,
-    'unauth' = 1,
-    'auth' = 2
-}
-declare class SubscriptionProcessor {
-    private readonly schema;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly amplifyContext;
-    private readonly typeQuery;
-    private buffer;
-    private dataObserver;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext?: AmplifyContext);
-    private buildSubscription;
-    private getAuthorizationInfo;
-    private hubQueryCompletionListener;
-    start(): [Observable<CONTROL_MSG>, Observable<[TransformerMutationType, SchemaModel, PersistentModel]>];
-    private passesPredicateValidation;
-    private pushToBuffer;
-    private drainBuffer;
-}
-export { SubscriptionProcessor };

package/lib/sync/processors/sync.d.ts

@@ -1,26 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { InternalSchema, ModelInstanceMetadata, SchemaModel, ModelPredicate, AuthModeStrategy, ErrorHandler, AmplifyContext } from '../../types';
-declare class SyncProcessor {
-    private readonly schema;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly amplifyContext;
-    private readonly typeQuery;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext: AmplifyContext);
-    private generateQueries;
-    private graphqlFilterFromPredicate;
-    private retrievePage;
-    private jitteredRetry;
-    start(typesLastSync: Map<SchemaModel, [string, number]>): Observable<SyncModelPage>;
-}
-export declare type SyncModelPage = {
-    namespace: string;
-    modelDefinition: SchemaModel;
-    items: ModelInstanceMetadata[];
-    startedAt: number;
-    done: boolean;
-    isFullSync: boolean;
-};
-export { SyncProcessor };

package/lib/sync/utils.d.ts

@@ -1,42 +0,0 @@
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
-import { GraphQLAuthError } from '@aws-amplify/api';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { AuthorizationRule, GraphQLCondition, GraphQLFilter, ModelInstanceMetadata, OpType, PersistentModel, PersistentModelConstructor, PredicatesGroup, RelationshipType, SchemaModel, SchemaNamespace, SchemaNonModel, ModelOperation, InternalSchema, AuthModeStrategy } from '../types';
-import { MutationEvent } from './';
-declare enum GraphQLOperationType {
-    LIST = "query",
-    CREATE = "mutation",
-    UPDATE = "mutation",
-    DELETE = "mutation",
-    GET = "query"
-}
-export declare enum TransformerMutationType {
-    CREATE = "Create",
-    UPDATE = "Update",
-    DELETE = "Delete",
-    GET = "Get"
-}
-export declare function getMetadataFields(): ReadonlyArray<string>;
-export declare function generateSelectionSet(namespace: SchemaNamespace, modelDefinition: SchemaModel | SchemaNonModel): string;
-export declare function getAuthorizationRules(modelDefinition: SchemaModel): AuthorizationRule[];
-export declare function buildSubscriptionGraphQLOperation(namespace: SchemaNamespace, modelDefinition: SchemaModel, transformerMutationType: TransformerMutationType, isOwnerAuthorization: boolean, ownerField: string): [TransformerMutationType, string, string];
-export declare function buildGraphQLOperation(namespace: SchemaNamespace, modelDefinition: SchemaModel, graphQLOpType: keyof typeof GraphQLOperationType): [TransformerMutationType, string, string][];
-export declare function createMutationInstanceFromModelOperation<T extends PersistentModel>(relationships: RelationshipType, modelDefinition: SchemaModel, opType: OpType, model: PersistentModelConstructor<T>, element: T, condition: GraphQLCondition, MutationEventConstructor: PersistentModelConstructor<MutationEvent>, modelInstanceCreator: ModelInstanceCreator, id?: string): MutationEvent;
-export declare function predicateToGraphQLCondition(predicate: PredicatesGroup<any>, modelDefinition: SchemaModel): GraphQLCondition;
-export declare function predicateToGraphQLFilter(predicatesGroup: PredicatesGroup<any>): GraphQLFilter;
-export declare function getUserGroupsFromToken(token: {
-    [field: string]: any;
-}, rule: AuthorizationRule): string[];
-export declare function getModelAuthModes({ authModeStrategy, defaultAuthMode, modelName, schema, }: {
-    authModeStrategy: AuthModeStrategy;
-    defaultAuthMode: GRAPHQL_AUTH_MODE;
-    modelName: string;
-    schema: InternalSchema;
-}): Promise<{
-    [key in ModelOperation]: GRAPHQL_AUTH_MODE[];
-}>;
-export declare function getForbiddenError(error: any): any;
-export declare function getClientSideAuthError(error: any): GraphQLAuthError;
-export declare function getTokenForCustomAuth(authMode: GRAPHQL_AUTH_MODE, amplifyConfig?: Record<string, any>): Promise<string | undefined>;
-export declare function getIdentifierValue(modelDefinition: SchemaModel, model: ModelInstanceMetadata | PersistentModel): string;
-export {};