@rxdi/firestore 0.7.118

package/README.md

@@ -0,0 +1,161 @@
+# Firebase firestore reactive database mixins
+
+- TypeSafe, Reactive
+- Firebase cloud function and AWS Lambda compatability
+
+#### Install
+```bash
+npm i @rxdi/firestore
+```
+
+#### Initialize firebase module
+```typescript
+
+import { Module } from '@rxdi/core';
+import { FirebaseModule } from '@rxdi/firestore';
+import * as functions from 'firebase-functions';
+import * as admin from 'firebase-admin';
+
+@Module({
+  imports: [
+    FirebaseModule.forRoot({
+      projectId: 'your-firebase-project-id',
+      credential: process.env.IS_NOT_LAMBDA
+        ? admin.credential.applicationDefault()
+        : functions.config().firebase
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+#### Set environment variable `GOOGLE_APPLICATION_CREDENTIALS` representing your Firebase configuration
+
+> More info can be found here https://firebase.google.com/docs/admin/setup
+
+```bash
+export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
+```
+
+```json
+{
+    "type": "service_account",
+    "project_id": "",
+    "private_key_id": "",
+    "private_key": "-----BEGIN PRIVATE KEY-----\n-----END PRIVATE KEY-----\n",
+    "client_email": "",
+    "client_id": "",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-eb9yl%40xx-xx-xx.iam.gserviceaccount.com"
+  }
+```
+
+When executing `admin.credential.applicationDefault()` firebase will get path from `GOOGLE_APPLICATION_CREDENTIALS` and try to read and load the credentials.
+
+
+
+#### Define your reactive firestore collections
+
+
+```typescript
+import { Injectable, Inject } from '@rxdi/core';
+import { GenericFirebaseModel, Firestore } from '@rxdi/firestore';
+
+interface IUserType {
+  id: string;
+  displayName: string;
+  email: string;
+}
+
+@Injectable()
+export class UserCollection extends GenericFirebaseModel<IUserType> {
+  constructor(@Inject(Firestore) firestore: Firestore) {
+    super('users', firestore);
+  }
+}
+
+```
+
+#### import `UserCollection` inside `AppModule` as a provider/service
+
+```typescript
+import { Module } from '@rxdi/core';
+import { FirebaseModule } from '@rxdi/firestore';
+import { ModelsModule } from '../database/models.module';
+import * as functions from 'firebase-functions';
+import * as admin from 'firebase-admin';
+import { UserCollection } from './models/user';
+
+@Module({
+  imports: [
+    FirebaseModule.forRoot({
+      projectId: 'your-firebase-project-id',
+      credential: process.env.IS_NOT_LAMBDA
+        ? admin.credential.applicationDefault()
+        : functions.config().firebase
+    }),
+  ],
+  providers: [UserCollection]
+})
+export class AppModule {}
+
+```
+
+
+#### Use created mixins
+
+
+```typescript
+import { Injectable } from '@rxdi/core';
+import { UserCollection } from '../models/user';
+
+@Injectable()
+export class UserCollectionService {
+  constructor(
+    private userCollection: UserCollection
+  ) {}
+}
+
+```
+
+#### Mixins provide the following instance methods
+
+```typescript
+import { CollectionReference, Firestore } from '@google-cloud/firestore';
+import { StaticMethods } from './static-mixins';
+export declare class FirestoreCollection<T> extends StaticMethods {
+    private collection;
+    constructor(collectionName: string, firestore: Firestore);
+    getCollectionRef(): CollectionReference;
+    getFirestoreRef(): Firestore;
+    getRef(doc: string): FirebaseFirestore.DocumentReference;
+    create(payload: T, doc?: string): Promise<T>;
+    get(doc: string): Promise<T>;
+    delete(doc: string): Promise<FirebaseFirestore.WriteResult>;
+    update(doc: string, payload: T): Promise<T>;
+    findAll(where?: T): Promise<T[]>;
+    find(payload: T): Promise<T>;
+    build<T>(payload: T): T;
+}
+```
+
+
+#### Mixins provide also static methods
+
+```typescript
+import { FirestoreCollection } from './mixins';
+export declare class StaticMethods {
+    static create<T>(payload: T, doc?: string): Promise<T>;
+    static getCollectionRef(): FirebaseFirestore.CollectionReference;
+    static getFirestoreRef(): FirebaseFirestore.Firestore;
+    static getRef(doc: string): FirebaseFirestore.DocumentReference;
+    static get<T>(doc: string): Promise<T>;
+    static delete(doc: string): Promise<FirebaseFirestore.WriteResult>;
+    static update<T>(doc: string, payload: T): Promise<T>;
+    static findAll<T>(where?: T): Promise<T[]>;
+    static find<T>(payload: T): Promise<T>;
+    static build<T>(payload: T): T;
+}
+```

package/dist/firebase.tokens.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@rxdi/core';
+export declare const Firestore: InjectionToken<FirebaseFirestore.Firestore>;
+export interface Firestore extends FirebaseFirestore.Firestore {
+}

package/dist/firebase.tokens.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Firestore = void 0;
+const core_1 = require("@rxdi/core");
+exports.Firestore = new core_1.InjectionToken('firestore-database');

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ModuleWithProviders } from '@rxdi/core';
+import * as admin from 'firebase-admin';
+export declare class FirebaseModule {
+    static forRoot(config: admin.AppOptions): ModuleWithProviders;
+}
+export * from './firebase.tokens';
+export * from './mixins';

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+var FirebaseModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseModule = void 0;
+const core_1 = require("@rxdi/core");
+const admin = require("firebase-admin");
+const firebase_tokens_1 = require("./firebase.tokens");
+let FirebaseModule = FirebaseModule_1 = class FirebaseModule {
+    static forRoot(config) {
+        return {
+            module: FirebaseModule_1,
+            providers: [
+                {
+                    provide: firebase_tokens_1.Firestore,
+                    useFactory: () => {
+                        admin.initializeApp(config);
+                        return admin.firestore();
+                    }
+                }
+            ]
+        };
+    }
+};
+FirebaseModule = FirebaseModule_1 = __decorate([
+    core_1.Module()
+], FirebaseModule);
+exports.FirebaseModule = FirebaseModule;
+__exportStar(require("./firebase.tokens"), exports);
+__exportStar(require("./mixins"), exports);

package/dist/mixins.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="firebase-admin/node_modules/@google-cloud/firestore" />
+import { CollectionReference, Firestore } from '@google-cloud/firestore';
+import { StaticMethods } from './static-mixins';
+export declare class FirestoreCollection<T> extends StaticMethods {
+    private collection;
+    constructor(collectionName: string, firestore: Firestore);
+    getCollectionRef(): CollectionReference<FirebaseFirestore.DocumentData>;
+    getFirestoreRef(): Firestore;
+    getRef(doc: string): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
+    create(payload: T, doc?: string): Promise<T>;
+    get(doc: string): Promise<T>;
+    delete(doc: string): Promise<FirebaseFirestore.WriteResult>;
+    update(doc: string, payload: T): Promise<T>;
+    findAll(where?: T): Promise<T[]>;
+    find(payload: T): Promise<T>;
+    build<T>(payload: T): T;
+}

package/dist/mixins.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirestoreCollection = void 0;
+const static_mixins_1 = require("./static-mixins");
+class FirestoreCollection extends static_mixins_1.StaticMethods {
+    constructor(collectionName, firestore) {
+        super();
+        this.collection = firestore.collection(collectionName);
+        FirestoreCollection.setStaticSelf(this);
+    }
+    getCollectionRef() {
+        return this.collection;
+    }
+    getFirestoreRef() {
+        return this.collection.firestore;
+    }
+    getRef(doc) {
+        return this.collection.doc(doc);
+    }
+    create(payload, doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ref = this.collection.doc();
+            if (doc) {
+                ref = this.getRef(doc);
+            }
+            payload['id'] = ref.id;
+            const document = yield ref.set(payload);
+            return Object.assign({ writeTime: document.writeTime }, payload);
+        });
+    }
+    get(doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getRef(doc).get()).data();
+        });
+    }
+    delete(doc) {
+        return this.getRef(doc).delete();
+    }
+    update(doc, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getRef(doc).update(payload);
+            return this.get(doc);
+        });
+    }
+    findAll(where) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!where) {
+                const snapshot = yield this.collection.get();
+                return snapshot.docs.map(doc => doc.data());
+            }
+            let query;
+            Object.keys(where).forEach(k => {
+                if (!query) {
+                    query = this.collection.where(k, '==', where[k]);
+                }
+                query.where(k, '==', where[k]);
+            });
+            return (yield query.get()).docs.map(doc => doc.data());
+        });
+    }
+    find(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const docs = yield this.findAll(payload);
+            if (docs.length > 1) {
+                throw new Error('More than one documents found for this query');
+            }
+            if (docs.length) {
+                return docs[0];
+            }
+            return null;
+        });
+    }
+    build(payload) {
+        return payload;
+    }
+}
+exports.FirestoreCollection = FirestoreCollection;

package/dist/static-mixins.d.ts

@@ -0,0 +1,15 @@
+import { FirestoreCollection } from './mixins';
+export declare class StaticMethods {
+    static model: FirestoreCollection<any>;
+    static setStaticSelf<T>(self: FirestoreCollection<T>): void;
+    static create<T>(payload: T, doc?: string): Promise<T>;
+    static getCollectionRef(): FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData>;
+    static getFirestoreRef(): FirebaseFirestore.Firestore;
+    static getRef(doc: string): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
+    static get<T>(doc: string): Promise<T>;
+    static delete(doc: string): Promise<FirebaseFirestore.WriteResult>;
+    static update<T>(doc: string, payload: T): Promise<T>;
+    static findAll<T>(where?: T): Promise<T[]>;
+    static find<T>(payload: T): Promise<T>;
+    static build<T>(payload: T): T;
+}

package/dist/static-mixins.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticMethods = void 0;
+class StaticMethods {
+    static setStaticSelf(self) {
+        StaticMethods.model = self;
+    }
+    static create(payload, doc) {
+        return StaticMethods.model.create(payload, doc);
+    }
+    static getCollectionRef() {
+        return StaticMethods.model.getCollectionRef();
+    }
+    static getFirestoreRef() {
+        return StaticMethods.model.getFirestoreRef();
+    }
+    static getRef(doc) {
+        return StaticMethods.model.getRef(doc);
+    }
+    static get(doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return StaticMethods.model.get(doc);
+        });
+    }
+    static delete(doc) {
+        return StaticMethods.model.delete(doc);
+    }
+    static update(doc, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return StaticMethods.model.update(doc, payload);
+        });
+    }
+    static findAll(where) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return StaticMethods.model.findAll(where);
+        });
+    }
+    static find(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return StaticMethods.model.find(payload);
+        });
+    }
+    static build(payload) {
+        return payload;
+    }
+}
+exports.StaticMethods = StaticMethods;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@rxdi/firestore",
+  "version": "0.7.118",
+  "main": "./dist/index.js",
+  "author": "Kristiyan Tachev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rxdi/firestore"
+  },
+  "scripts": {
+    "build": "tsc || true"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "dependencies": {
+    "firebase-admin": "^8.2.0",
+    "@google-cloud/firestore": "2.2.1",
+    "firebase-functions": "^3.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^3.9.3",
+    "@rxdi/core": "^0.7.117"
+  }
+}