functional-google-cloud
Version:
Google Cloud Utilities functions in Functional Programming Style
341 lines • 13.2 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getModelsInFirestore = exports.getModelsInCollection = exports.getModelsInFirestoreWhere = exports.getModelsInCollectionWhere = exports.getModelsFromQuery = exports.getModelsFromQuerySnapshot = exports.getDocumentSnapshotsFromQuerySnapshot = exports.getSnapshotFromQuery = exports.getSnapshotFromQueryTask = exports.getModelFromDocument = exports.listDocumentsInFirestore = exports.listDocumentsInCollection = exports.listDocumentsInCollectionTask = exports.listCollectionsInFirestore = exports.getModelFromFirestore = exports.getModelFromCollection = exports.validateModel = exports.validateSnapshotExistence = exports.getSnapshotFromDocument = exports.getSnapshotFromDocumentTask = exports.updateModelInDocument = exports.updateModelInDocumentTask = exports.storeModelToFirestoreWith = exports.storeModelToFirestore = exports.storeModelToCollection = exports.storeModelToDocument = exports.getCollectionFromDocument = exports.getQueryFromCollection = exports.getDocumentFromCollection = exports.getCollectionFromFirestore = exports.serialize = exports.serializeTimestampModel = exports.serializeDateModel = exports.fromDateModel = exports.fromTimestampModel = exports.isSerializedModel = exports.isDateString = exports.isDateModel = exports.isTimestampModel = exports.isModel = void 0;
const firestore_1 = require("@google-cloud/firestore");
const A = __importStar(require("fp-ts/lib/Array"));
const E = __importStar(require("fp-ts/lib/Either"));
const R = __importStar(require("fp-ts/lib/Reader"));
const RTE = __importStar(require("fp-ts/lib/ReaderTaskEither"));
const TE = __importStar(require("fp-ts/lib/TaskEither"));
const TEUtils = __importStar(require("functional-types/lib/fp-ts/TaskEither"));
const ramda_1 = require("ramda");
/**
* ```haskell
* isModel :: a -> bool
* ```
*/
exports.isModel = (a) => ramda_1.allPass([ramda_1.is(Object), ramda_1.propIs(String, 'id')])(a);
/**
* ```haskell
* isTimestampModel :: a -> bool
* ```
*/
exports.isTimestampModel = (a) => ramda_1.allPass([
exports.isModel,
ramda_1.propIs(firestore_1.Timestamp, 'created_at'),
ramda_1.propIs(firestore_1.Timestamp, 'updated_at'),
])(a);
/**
* ```haskell
* isDateModel :: a -> bool
* ```
*/
exports.isDateModel = (a) => ramda_1.allPass([exports.isModel, ramda_1.propIs(Date, 'created_at'), ramda_1.propIs(Date, 'updated_at')])(a);
/**
* ```haskell
* isDateString :: a -> bool
* ```
*/
exports.isDateString = (a) => ramda_1.allPass([ramda_1.is(String), ramda_1.pipe(Date.parse, isNaN, ramda_1.not)])(a);
/**
* ```haskell
* isSerializedModel :: a -> bool
* ```
*/
exports.isSerializedModel = (a) => ramda_1.allPass([
exports.isModel,
ramda_1.propSatisfies(exports.isDateString, 'created_at'),
ramda_1.propSatisfies(exports.isDateString, 'updated_at'),
])(a);
/**
* ```haskell
* getDateFromTimestamp :: Timestamp -> Date
* ```
*/
const getDateFromTimestamp = (timestamp) => timestamp.toDate();
/**
* ```haskell
* getTimestampFromDate :: Date -> Timestamp
* ```
*/
const getTimestampFromDate = (date) => firestore_1.Timestamp.fromDate(date);
/**
* ```haskell
* serializeDate :: Date -> String
* ```
*/
const serializeDate = (date) => date.toISOString();
/**
* ```haskell
* fromTimestampModel :: TimestampModel -> DateModel
* ```
*/
exports.fromTimestampModel = (model) => ramda_1.evolve({
created_at: getDateFromTimestamp,
updated_at: getDateFromTimestamp,
})(model);
/**
* ```haskell
* fromDateModel :: DateModel -> TimestampModel
* ```
*/
exports.fromDateModel = (model) => ramda_1.evolve({
created_at: getTimestampFromDate,
updated_at: getTimestampFromDate,
})(model);
/**
* ```haskell
* serializeDateModel :: DateModel -> SerializedModel
* ```
*/
exports.serializeDateModel = (model) => ramda_1.evolve({
created_at: serializeDate,
updated_at: serializeDate,
})(model);
/**
* ```haskell
* serializeTimestampModel :: TimestampModel -> SerializedModel
* ```
*/
exports.serializeTimestampModel = ramda_1.pipe(exports.fromTimestampModel, exports.serializeDateModel);
/**
* ```haskell
* serialize :: Model -> Either SerializedModel Error
* ```
*/
exports.serialize = ramda_1.ifElse(exports.isSerializedModel, E.right, ramda_1.pipe(ramda_1.ifElse(exports.isDateModel, E.right, ramda_1.pipe(E.fromPredicate(exports.isTimestampModel, () => new Error('Model is not a TimestampModel.')), E.map(exports.fromTimestampModel))), E.map(exports.serializeDateModel)));
/**
* ```haskell
* getCollectionFromFirestore :: Firestore -> Reader String Collection
* ```
*/
exports.getCollectionFromFirestore = (firestore) => (table) => firestore.collection(table);
/**
* ```haskell
* getDocumentFromCollection :: Collection -> Reader Model Document
* ```
*/
exports.getDocumentFromCollection = (collection) => (model) => collection.doc(model.id);
/**
* ```haskell
* getQueryFromCollection :: Collection -> Reader [Condition] Document Error
* ```
*/
exports.getQueryFromCollection = (collection) => {
return ramda_1.pipe(E.fromPredicate(ramda_1.pipe(ramda_1.isEmpty, ramda_1.not), () => new Error('No condition has been provided.')), E.map(ramda_1.reduce((query, condition) => query.where(...condition), collection)));
};
/**
* ```haskell
* getCollectionFromDocument :: Document -> Reader String Collection
* ```
*/
exports.getCollectionFromDocument = (document) => (table) => document.collection(table);
/**
* @internal
* ```haskell
* storeModelToDocumentTask :: Document -> Reader Model (Task Model)
* ```
*/
const storeModelToDocumentTask = (document) => (model) => async () => {
await document.set(model);
return model;
};
/**
* ```haskell
* storeModelToDocument :: Document -> ReaderTaskEither Model Model Error
* ```
*/
exports.storeModelToDocument = ramda_1.pipe(storeModelToDocumentTask, R.map(TEUtils.fromTask));
/**
* ```haskell
* storeModelToCollection :: Collection -> String -> ReaderTaskEither Model Model Error
* ```
*/
exports.storeModelToCollection = ramda_1.pipe(exports.getDocumentFromCollection, R.chain(exports.storeModelToDocument));
/**
* ```haskell
* storeModelToFirestore :: Firestore -> Reader String (ReaderTaskEither Model Model Error)
* ```
*/
exports.storeModelToFirestore = ramda_1.pipe(exports.getCollectionFromFirestore, R.map(exports.storeModelToCollection));
/**
* ```haskell
* storeModelToFirestoreWith :: Firestore -> Reader String (ReaderTaskEither (() -> Model) Model Error)
* ```
*/
exports.storeModelToFirestoreWith = (firestore) => (table) => (fn) => ramda_1.pipe(fn, exports.storeModelToFirestore(firestore)(table));
/**
* ```haskell
* updateModelInDocumentTask :: Collection -> ReaderTask Model Model
* ```
*/
exports.updateModelInDocumentTask = (document) => (model) => async () => {
await document.update(model);
return model;
};
/**
* ```haskell
* updateModelInDocument :: Collection -> ReaderTaskEither Model Model Error
* ```
*/
exports.updateModelInDocument = ramda_1.pipe(exports.updateModelInDocumentTask, R.map(TEUtils.fromTask));
/**
* ```haskell
* getSnapshotFromDocumentTask :: Document -> Task Snapshot
* ```
*/
exports.getSnapshotFromDocumentTask = (document) => () => document.get();
/**
* ```haskell
* getSnapshotFromDocument :: Document -> TaskEither Snapshot Error
* ```
*/
exports.getSnapshotFromDocument = ramda_1.pipe(exports.getSnapshotFromDocumentTask, TEUtils.fromTask);
/**
* @internal
* ```haskell
* getSnapshotFromCollection :: Collection -> ReaderTaskEither Model Snapshot Error
* ```
*/
const getSnapshotFromCollection = ramda_1.pipe(exports.getDocumentFromCollection, R.map(exports.getSnapshotFromDocument));
/**
* @internal
* ```haskell
* getDataFromSnapshot :: Snapshot -> a
* ```
*/
const getDataFromSnapshot = (snapshot) => snapshot.data();
/**
* ```haskell
* validateSnapshotExistence :: snapshot -> Either a Error
* ```
*/
exports.validateSnapshotExistence = ramda_1.ifElse(ramda_1.prop('exists'), E.right, () => E.left(new Error('Item does not exist.')));
/**
* ```haskell
* validateModel :: a -> Either Model Error
* ```
*/
exports.validateModel = ramda_1.ifElse(exports.isModel, E.right, () => E.left(new Error('Item is not a valid model.')));
/**
* ```haskell
* getModelFromDocumentSnapshot :: Snapshot -> Either Model Error
* ```
*/
const getModelFromDocumentSnapshot = ramda_1.pipe(exports.validateSnapshotExistence, E.map(getDataFromSnapshot), E.chain(exports.validateModel));
/**
* ```haskell
* getModelFromCollection :: Collection -> ReaderTaskEither Model Model Error
* ```
*/
exports.getModelFromCollection = ramda_1.pipe(getSnapshotFromCollection, RTE.chainEitherK(getModelFromDocumentSnapshot));
/**
* ```haskell
* getModelFromFirestore :: Firestore -> Reader String (ReaderTaskEither Model Model Error)
* ```
*/
exports.getModelFromFirestore = ramda_1.pipe(exports.getCollectionFromFirestore, R.map(exports.getModelFromCollection));
/**
* ```haskell
* listCollectionsInFirestore :: Firestore -> Task [Collection]
* ```
*/
exports.listCollectionsInFirestore = (firestore) => () => firestore.listCollections();
/**
* ```haskell
* listDocumentsInCollectionTask :: Collection -> Task [Document]
* ```
*/
exports.listDocumentsInCollectionTask = (collection) => () => collection.listDocuments();
/**
* ```haskell
* listDocumentsInCollection :: Collection -> TaskEither [Document] Error
* ```
*/
exports.listDocumentsInCollection = ramda_1.pipe(exports.listDocumentsInCollectionTask, TEUtils.fromTask);
/**
* ```haskell
* listDocumentsInFirestore :: Firestore ReaderTaskEither String [Document] Error
* ```
*/
exports.listDocumentsInFirestore = ramda_1.pipe(exports.getCollectionFromFirestore, R.map(exports.listDocumentsInCollection));
/**
* ```haskell
* getModelFromDocument :: Document -> TaskEither Model Error
* ```
*/
exports.getModelFromDocument = ramda_1.pipe(exports.getSnapshotFromDocument, TE.chainEitherK(getModelFromDocumentSnapshot));
/**
* ```haskell
* getSnapshotFromQueryTask :: Query -> Task Snapshot
* ```
*/
exports.getSnapshotFromQueryTask = (query) => () => query.get();
/**
* ```haskell
* getSnapshotFromQuery :: Query -> TaskEither Snapshot Error
* ```
*/
exports.getSnapshotFromQuery = ramda_1.pipe(exports.getSnapshotFromQueryTask, TEUtils.fromTask);
/**
* ```haskell
* getDocumentSnapshotsFromQuerySnapshot :: QuerySnapshot -> [DocumentSnapshot]
* ```
*/
exports.getDocumentSnapshotsFromQuerySnapshot = ramda_1.prop('docs');
/**
* ```haskell
* getModelsFromQuerySnapshot :: QuerySnapshot -> Either [Model] Error
* ```
*/
exports.getModelsFromQuerySnapshot = ramda_1.pipe(exports.getDocumentSnapshotsFromQuerySnapshot, ramda_1.map(getModelFromDocumentSnapshot), A.array.sequence(E.either));
/**
* ```haskell
* getModelsFromQuery :: Query -> TaskEither [Model] Error
* ```
*/
exports.getModelsFromQuery = ramda_1.pipe(exports.getSnapshotFromQuery, TE.chainEitherK(exports.getModelsFromQuerySnapshot));
/**
* ```haskell
* getModelsInCollectionWhere :: Collection -> ReaderTaskEither [Condition] [Model] Error
* ```
*/
exports.getModelsInCollectionWhere = ramda_1.pipe(exports.getQueryFromCollection, RTE.fromReaderEither, RTE.chainTaskEitherK(exports.getModelsFromQuery));
/**
* ```haskell
* getModelsInFirestoreWhere :: Firestore -> Reader String (ReaderTaskEither [Condition] [Model] Error)
* ```
*/
exports.getModelsInFirestoreWhere = ramda_1.pipe(exports.getCollectionFromFirestore, R.map(exports.getModelsInCollectionWhere));
/**
* ```haskell
* getModelsInCollection :: Collection -> TaskEither [Model] Error
* ```
*/
exports.getModelsInCollection = ramda_1.pipe(exports.listDocumentsInCollection, TE.chain(ramda_1.pipe(ramda_1.map(exports.getModelFromDocument), A.array.sequence(TE.taskEither))));
/**
* ```haskell
* getModelsInFirestore :: Firestore -> ReaderTaskEither String [Model] Error
* ```
*/
exports.getModelsInFirestore = ramda_1.pipe(exports.getCollectionFromFirestore, R.map(exports.getModelsInCollection));
//# sourceMappingURL=index.js.map