functional-google-cloud/es6/Firestore/index.d.ts

Google Cloud Utilities functions in Functional Programming Style

import { Firestore, CollectionReference, DocumentReference, DocumentSnapshot, Query, WhereFilterOp, Timestamp } from '@google-cloud/firestore';
import * as E from 'fp-ts/lib/Either';
import * as R from 'fp-ts/lib/Reader';
import * as RE from 'fp-ts/lib/ReaderEither';
import * as RT from 'fp-ts/lib/ReaderTask';
import * as RTE from 'fp-ts/lib/ReaderTaskEither';
import * as T from 'fp-ts/lib/Task';
import * as TE from 'fp-ts/lib/TaskEither';
import QuerySnapshot = FirebaseFirestore.QuerySnapshot;
import QueryDocumentSnapshot = FirebaseFirestore.QueryDocumentSnapshot;
export declare type Model<A = unknown> = {
    id: string;
} & A;
export declare type TimestampModel<A = unknown> = Model<A> & {
    created_at: Timestamp;
    updated_at: Timestamp;
};
export declare type DateModel<A = unknown> = Model<A> & {
    created_at: Date;
    updated_at: Date;
};
export declare type SerializedModel<A = unknown> = Model<A> & {
    created_at: string;
    updated_at: string;
};
export declare type Operation = WhereFilterOp;
export declare type Condition = [string, Operation, unknown];
/**
 * ```haskell
 * isModel :: a -> bool
 * ```
 */
export declare const isModel: (a: unknown) => a is {
    id: string;
};
/**
 * ```haskell
 * isTimestampModel :: a -> bool
 * ```
 */
export declare const isTimestampModel: (a: unknown) => a is TimestampModel<unknown>;
/**
 * ```haskell
 * isDateModel :: a -> bool
 * ```
 */
export declare const isDateModel: (a: unknown) => a is DateModel<unknown>;
/**
 * ```haskell
 * isDateString :: a -> bool
 * ```
 */
export declare const isDateString: (a: unknown) => a is string;
/**
 * ```haskell
 * isSerializedModel :: a -> bool
 * ```
 */
export declare const isSerializedModel: (a: unknown) => a is SerializedModel<unknown>;
/**
 * ```haskell
 * fromTimestampModel :: TimestampModel -> DateModel
 * ```
 */
export declare const fromTimestampModel: <A = unknown>(model: TimestampModel<A>) => DateModel<A>;
/**
 * ```haskell
 * fromDateModel :: DateModel -> TimestampModel
 * ```
 */
export declare const fromDateModel: <A = unknown>(model: DateModel<A>) => TimestampModel<A>;
/**
 * ```haskell
 * serializeDateModel :: DateModel -> SerializedModel
 * ```
 */
export declare const serializeDateModel: <A = unknown>(model: DateModel<A>) => SerializedModel<A>;
/**
 * ```haskell
 * serializeTimestampModel :: TimestampModel -> SerializedModel
 * ```
 */
export declare const serializeTimestampModel: <A = unknown>(model: TimestampModel<A>) => SerializedModel<A>;
/**
 * ```haskell
 * serialize :: Model -> Either SerializedModel Error
 * ```
 */
export declare const serialize: <A = unknown>(model: Model<A>) => E.Either<Error, SerializedModel<A>>;
/**
 * ```haskell
 * getCollectionFromFirestore :: Firestore -> Reader String Collection
 * ```
 */
export declare const getCollectionFromFirestore: (firestore: Firestore) => R.Reader<string, CollectionReference>;
/**
 * ```haskell
 * getDocumentFromCollection :: Collection -> Reader Model Document
 * ```
 */
export declare const getDocumentFromCollection: (collection: CollectionReference) => R.Reader<Model, DocumentReference>;
/**
 * ```haskell
 * getQueryFromCollection :: Collection -> Reader [Condition] Document Error
 * ```
 */
export declare const getQueryFromCollection: (collection: CollectionReference) => RE.ReaderEither<Condition[], Error, Query>;
/**
 * ```haskell
 * getCollectionFromDocument :: Document -> Reader String Collection
 * ```
 */
export declare const getCollectionFromDocument: (document: DocumentReference) => R.Reader<string, CollectionReference>;
/**
 * ```haskell
 * storeModelToDocument :: Document -> ReaderTaskEither Model Model Error
 * ```
 */
export declare const storeModelToDocument: (document: DocumentReference) => RTE.ReaderTaskEither<Model, Error, Model>;
/**
 * ```haskell
 * storeModelToCollection :: Collection -> String -> ReaderTaskEither Model Model Error
 * ```
 */
export declare const storeModelToCollection: (collection: CollectionReference) => RTE.ReaderTaskEither<Model, Error, Model>;
/**
 * ```haskell
 * storeModelToFirestore :: Firestore -> Reader String (ReaderTaskEither Model Model Error)
 * ```
 */
export declare const storeModelToFirestore: (firestore: Firestore) => R.Reader<string, RTE.ReaderTaskEither<Model, Error, Model>>;
/**
 * ```haskell
 * storeModelToFirestoreWith :: Firestore -> Reader String (ReaderTaskEither (() -> Model) Model Error)
 * ```
 */
export declare const storeModelToFirestoreWith: <A>(firestore: Firestore) => R.Reader<string, R.Reader<(a: A) => Model, RTE.ReaderTaskEither<A, Error, Model>>>;
/**
 * ```haskell
 * updateModelInDocumentTask :: Collection -> ReaderTask Model Model
 * ```
 */
export declare const updateModelInDocumentTask: (document: DocumentReference) => RT.ReaderTask<Model, Model>;
/**
 * ```haskell
 * updateModelInDocument :: Collection -> ReaderTaskEither Model Model Error
 * ```
 */
export declare const updateModelInDocument: (document: DocumentReference) => RTE.ReaderTaskEither<Model, Error, Model>;
/**
 * ```haskell
 * getSnapshotFromDocumentTask :: Document -> Task Snapshot
 * ```
 */
export declare const getSnapshotFromDocumentTask: (document: DocumentReference) => T.Task<DocumentSnapshot>;
/**
 * ```haskell
 * getSnapshotFromDocument :: Document -> TaskEither Snapshot Error
 * ```
 */
export declare const getSnapshotFromDocument: (document: DocumentReference) => TE.TaskEither<Error, DocumentSnapshot>;
/**
 * ```haskell
 * validateSnapshotExistence :: snapshot -> Either a Error
 * ```
 */
export declare const validateSnapshotExistence: (snapshot: DocumentSnapshot) => E.Either<Error, DocumentSnapshot>;
/**
 * ```haskell
 * validateModel :: a -> Either Model Error
 * ```
 */
export declare const validateModel: (a: unknown) => E.Either<Error, Model>;
/**
 * ```haskell
 * getModelFromCollection :: Collection -> ReaderTaskEither Model Model Error
 * ```
 */
export declare const getModelFromCollection: (collection: CollectionReference) => RTE.ReaderTaskEither<Model, Error, Model>;
/**
 * ```haskell
 * getModelFromFirestore :: Firestore -> Reader String (ReaderTaskEither Model Model Error)
 * ```
 */
export declare const getModelFromFirestore: (firestore: Firestore) => R.Reader<string, RTE.ReaderTaskEither<Model, Error, Model>>;
/**
 * ```haskell
 * listCollectionsInFirestore :: Firestore -> Task [Collection]
 * ```
 */
export declare const listCollectionsInFirestore: (firestore: Firestore) => T.Task<CollectionReference[]>;
/**
 * ```haskell
 * listDocumentsInCollectionTask :: Collection -> Task [Document]
 * ```
 */
export declare const listDocumentsInCollectionTask: (collection: CollectionReference) => T.Task<DocumentReference[]>;
/**
 * ```haskell
 * listDocumentsInCollection :: Collection -> TaskEither [Document] Error
 * ```
 */
export declare const listDocumentsInCollection: (collection: CollectionReference) => TE.TaskEither<Error, DocumentReference[]>;
/**
 * ```haskell
 * listDocumentsInFirestore :: Firestore ReaderTaskEither String [Document] Error
 * ```
 */
export declare const listDocumentsInFirestore: (firestore: Firestore) => RTE.ReaderTaskEither<string, Error, DocumentReference[]>;
/**
 * ```haskell
 * getModelFromDocument :: Document -> TaskEither Model Error
 * ```
 */
export declare const getModelFromDocument: (document: DocumentReference) => TE.TaskEither<Error, Model>;
/**
 * ```haskell
 * getSnapshotFromQueryTask :: Query -> Task Snapshot
 * ```
 */
export declare const getSnapshotFromQueryTask: (query: Query) => T.Task<QuerySnapshot>;
/**
 * ```haskell
 * getSnapshotFromQuery :: Query -> TaskEither Snapshot Error
 * ```
 */
export declare const getSnapshotFromQuery: (query: Query) => TE.TaskEither<Error, QuerySnapshot>;
/**
 * ```haskell
 * getDocumentSnapshotsFromQuerySnapshot :: QuerySnapshot -> [DocumentSnapshot]
 * ```
 */
export declare const getDocumentSnapshotsFromQuerySnapshot: (snapshot: QuerySnapshot) => QueryDocumentSnapshot[];
/**
 * ```haskell
 * getModelsFromQuerySnapshot :: QuerySnapshot -> Either [Model] Error
 * ```
 */
export declare const getModelsFromQuerySnapshot: (snapshot: QuerySnapshot) => E.Either<Error, Model[]>;
/**
 * ```haskell
 * getModelsFromQuery :: Query -> TaskEither [Model] Error
 * ```
 */
export declare const getModelsFromQuery: (query: Query) => TE.TaskEither<Error, Model[]>;
/**
 * ```haskell
 * getModelsInCollectionWhere :: Collection -> ReaderTaskEither [Condition] [Model] Error
 * ```
 */
export declare const getModelsInCollectionWhere: (collection: CollectionReference) => RTE.ReaderTaskEither<Condition[], Error, Model[]>;
/**
 * ```haskell
 * getModelsInFirestoreWhere :: Firestore -> Reader String (ReaderTaskEither [Condition] [Model] Error)
 * ```
 */
export declare const getModelsInFirestoreWhere: (firestore: Firestore) => R.Reader<string, RTE.ReaderTaskEither<Condition[], Error, Model[]>>;
/**
 * ```haskell
 * getModelsInCollection :: Collection -> TaskEither [Model] Error
 * ```
 */
export declare const getModelsInCollection: (collection: CollectionReference) => TE.TaskEither<Error, Model[]>;
/**
 * ```haskell
 * getModelsInFirestore :: Firestore -> ReaderTaskEither String [Model] Error
 * ```
 */
export declare const getModelsInFirestore: (firestore: Firestore) => RTE.ReaderTaskEither<string, Error, Model[]>;