@goatlab/fluent-firebase 0.7.2 → 0.7.6

package/changelog-template.hbs

@@ -0,0 +1,52 @@
+{{#each releases}}
+  #
+  {{title}}
+  [{{isoDate}}]
+
+  {{! lit commits with feature: in message, use feature: or Feature: }}
+  {{#commit-list
+    commits
+    heading='### Features'
+    message='(feat: )|(Feature: )'
+    exclude='(fix: )|(Fix: )|(break: )|(Break: )'
+  }}
+    *
+    {{subject}}
+    ([`{{shorthash}}`]({{href}}))
+  {{/commit-list}}
+
+  {{! use fix: or Fix: }}
+  {{#commit-list
+    commits
+    heading='### Fixes'
+    message='(fix: )|(Fix: )'
+    exclude='(break: )|(Break: )|(Feature: )|(feat: )'
+  }}
+    *
+    {{subject}}
+    ([`{{shorthash}}`]({{href}}))
+  {{/commit-list}}
+
+  {{! user break: or Break: }}
+  {{#commit-list
+    commits
+    heading='### Breaking changes'
+    message='(break: )|(Break: )'
+    exclude='(fix: )|(Fix: )|(Feat: )|(feat: )'
+  }}
+    *
+    {{subject}}
+    ([`{{shorthash}}`]({{href}}))
+  {{/commit-list}}
+
+  {{#commit-list
+    commits
+    heading='### Other Changes'
+    exclude='(fix: )|(Fix: )|(break: )|(Break: ) (feat: )|(Feat: )'
+  }}
+    *
+    {{subject}}
+    ([`{{shorthash}}`]({{href}}))
+  {{/commit-list}}
+
+{{/each}}

package/dist/FirebaseConnector.d.ts

@@ -2,8 +2,6 @@ import * as admin from 'firebase-admin';
 import { AnyObject, FluentQuery, LoadedResult, QueryOutput } from '@goatlab/fluent';
 import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
 import { z } from 'zod';
-import { FindByIdFilter } from '@goatlab/fluent';
-import { SingleQueryOutput } from '@goatlab/fluent';
 export interface FirebaseConnectorParams<Input, Output> {
     entity: any;
     inputSchema: z.ZodType<Input>;
@@ -17,20 +15,18 @@ export declare class FirebaseConnector<ModelDTO = AnyObject, InputDTO = ModelDTO
     constructor({ entity, inputSchema, outputSchema }: FirebaseConnectorParams<InputDTO, OutputDTO>);
     insert(data: InputDTO): Promise<OutputDTO>;
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
-    raw(): admin.firestore.CollectionReference<ModelDTO>;
-    rawFirebase(): admin.firestore.Firestore;
-    protected loadRelatedData(data: any[], loadedKeys: AnyObject): Promise<admin.firestore.DocumentData[]>;
     findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    loadFirst(query?: FluentQuery<ModelDTO>): FirebaseConnector<ModelDTO, InputDTO, OutputDTO>;
-    private getGeneratedQueries;
-    private getFirebaseWhereQuery;
     updateById(id: string, data: InputDTO): Promise<OutputDTO>;
     replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
+    deleteById(id: string): Promise<string>;
     clear(): Promise<boolean>;
-    private deleteQueryBatch;
+    loadFirst(query?: FluentQuery<ModelDTO>): LoadedResult<this>;
     loadById(id: string): LoadedResult<this>;
+    raw(): admin.firestore.CollectionReference<ModelDTO>;
+    rawFirebase(): admin.firestore.Firestore;
+    private deleteQueryBatch;
     protected clone(): any;
-    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
-    findById<T extends FindByIdFilter<ModelDTO>>(id: string, q?: T): Promise<SingleQueryOutput<T, ModelDTO, OutputDTO>>;
-    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
+    protected loadRelatedData(data: any[], loadedKeys: AnyObject): Promise<admin.firestore.DocumentData[]>;
+    private getGeneratedQueries;
+    private getFirebaseWhereQuery;
 }

package/dist/FirebaseConnector.js

@@ -57,24 +57,6 @@ class FirebaseConnector extends fluent_2.BaseConnector {
             return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
         }));
     }
-    raw() {
-        return this.collection;
-    }
-    rawFirebase() {
-        return admin.firestore();
-    }
-    async loadRelatedData(data, loadedKeys) {
-        let pivotData = [];
-        const result = await (0, fluent_2.loadRelations)({
-            data,
-            relations: loadedKeys,
-            modelRelations: this.modelRelations,
-            provider: 'firebase',
-            self: this,
-            returnPivot: false
-        });
-        return result;
-    }
     async findMany(query) {
         const [andQuery, orQueries] = this.getGeneratedQueries(query);
         const results = [];
@@ -121,14 +103,127 @@ class FirebaseConnector extends fluent_2.BaseConnector {
         }
         return this.outputSchema?.array().parse(found);
     }
+    async updateById(id, data) {
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        await this.collection.doc(id).update({
+            ...validatedData,
+            id
+        });
+        const dbResult = await this.findById(id);
+        if (!dbResult) {
+            throw new Error(`Object not found: ${id}`);
+        }
+        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
+    }
+    async replaceById(id, data) {
+        const value = await this.findById(id);
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            flatValue[key] = null;
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue._id;
+        delete newValue.id;
+        delete newValue.created;
+        delete newValue.updated;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        await this.collection
+            .doc(id)
+            .update(validatedData);
+        const val = await this.requireById(id);
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
+    }
+    async deleteById(id) {
+        await this.collection.doc(id).delete();
+        return id;
+    }
+    async clear() {
+        const query = this.collection.orderBy('__name__').limit(300);
+        return new Promise((resolve, reject) => {
+            this.deleteQueryBatch(admin.firestore(), query, 300, resolve, reject);
+        });
+    }
     loadFirst(query) {
-        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-        detachedClass.setRelatedQuery({
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                ...query,
+                limit: 1
+            }
+        });
+        return newInstance;
+    }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
             entity: this.entity,
             repository: this,
-            query
+            query: {
+                where: {
+                    id
+                }
+            }
         });
-        return detachedClass;
+        return newInstance;
+    }
+    raw() {
+        return this.collection;
+    }
+    rawFirebase() {
+        return admin.firestore();
+    }
+    deleteQueryBatch(db, query, batchSize, resolve, reject) {
+        query
+            .get()
+            .then(snapshot => {
+            if (snapshot.size == 0) {
+                return 0;
+            }
+            const batch = db.batch();
+            snapshot.docs.forEach(doc => {
+                batch.delete(doc.ref);
+            });
+            return batch.commit().then(() => snapshot.size);
+        })
+            .then(numDeleted => {
+            if (numDeleted === 0) {
+                resolve();
+                return;
+            }
+            process.nextTick(() => {
+                this.deleteQueryBatch(db, query, batchSize, resolve, reject);
+            });
+        })
+            .catch(reject);
+    }
+    clone() {
+        return new this.constructor();
+    }
+    async loadRelatedData(data, loadedKeys) {
+        const result = await (0, fluent_2.loadRelations)({
+            data,
+            relations: loadedKeys,
+            modelRelations: this.modelRelations,
+            provider: 'firebase',
+            self: this,
+            returnPivot: false
+        });
+        return result;
     }
     getGeneratedQueries(query) {
         let { andWhere, orWhere } = this.getFirebaseWhereQuery(query?.where);
@@ -313,123 +408,5 @@ class FirebaseConnector extends fluent_2.BaseConnector {
             orWhere: orWhereQueries
         };
     }
-    async updateById(id, data) {
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        await this.collection.doc(id).update({
-            ...validatedData,
-            id
-        });
-        const dbResult = await this.findById(id);
-        if (!dbResult) {
-            throw new Error(`Object not found: ${id}`);
-        }
-        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
-    }
-    async replaceById(id, data) {
-        const value = await this.findById(id);
-        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
-        Object.keys(flatValue).forEach(key => {
-            flatValue[key] = null;
-        });
-        const nullObject = js_utils_1.Objects.nest(flatValue);
-        const newValue = { ...nullObject, ...data };
-        delete newValue._id;
-        delete newValue.id;
-        delete newValue.created;
-        delete newValue.updated;
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        await this.collection
-            .doc(id)
-            .update(validatedData);
-        const val = await this.findById(id);
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
-    }
-    async clear() {
-        const query = this.collection.orderBy('__name__').limit(300);
-        return new Promise((resolve, reject) => {
-            this.deleteQueryBatch(admin.firestore(), query, 300, resolve, reject);
-        });
-    }
-    deleteQueryBatch(db, query, batchSize, resolve, reject) {
-        query
-            .get()
-            .then(snapshot => {
-            if (snapshot.size == 0) {
-                return 0;
-            }
-            const batch = db.batch();
-            snapshot.docs.forEach(doc => {
-                batch.delete(doc.ref);
-            });
-            return batch.commit().then(() => snapshot.size);
-        })
-            .then(numDeleted => {
-            if (numDeleted === 0) {
-                resolve();
-                return;
-            }
-            process.nextTick(() => {
-                this.deleteQueryBatch(db, query, batchSize, resolve, reject);
-            });
-        })
-            .catch(reject);
-    }
-    loadById(id) {
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                where: {
-                    id
-                }
-            }
-        });
-        return newInstance;
-    }
-    clone() {
-        return new this.constructor();
-    }
-    async findByIds(ids, q) {
-        let data = await this.findMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            limit: q?.limit,
-            select: q?.select,
-            include: q?.include
-        });
-        return this.outputSchema?.array().parse(data);
-    }
-    async findById(id, q) {
-        const found = await this.findByIds([id], q);
-        return found[0];
-    }
-    async requireById(id, q) {
-        let found = await this.findById(id, {
-            select: q?.select,
-            include: q?.include,
-            limit: 1
-        });
-        if (!found) {
-            throw new Error(`Object ${id} not found`);
-        }
-        found = this.clearEmpties(js_utils_1.Objects.deleteNulls(found));
-        return this.outputSchema?.parse(found);
-    }
 }
 exports.FirebaseConnector = FirebaseConnector;