@goatlab/fluent-firebase 0.6.9 → 0.6.12

package/dist/FirebaseConnector.d.ts

@@ -1,8 +1,8 @@
 import * as admin from 'firebase-admin';
 import { BaseFirestoreRepository } from 'fireorm';
 import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '@goatlab/fluent';
-import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
-export declare const createFirebaseRepository: (Entity: any) => {
+import { BaseConnector, DataSource, FluentConnectorInterface } from '@goatlab/fluent';
+export declare const createFirebaseRepository: (Entity: any, dataSource: DataSource) => {
     repository: BaseFirestoreRepository<import("fireorm").IEntity>;
     name: string;
     path: string;
@@ -11,8 +11,8 @@ export declare const createFirebaseRepository: (Entity: any) => {
 };
 export declare class FirebaseConnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, DaoOutput<InputDTO, OutputDTO>> {
     private repository;
-    private collection;
-    constructor(Entity: any, relationQuery?: any);
+    private readonly collection;
+    constructor(Entity: any, dataSource: DataSource, relationQuery?: any);
     get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     getPaginated(): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
     all(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
@@ -27,6 +27,7 @@ export declare class FirebaseConnector<ModelDTO = BaseDataElement, InputDTO = Mo
     clear({ sure }: Sure): Promise<unknown>;
     deleteById(id: string): Promise<string>;
     findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    findByIds(ids: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[] | null>;
     private getPage;
     private getPaginatorLimit;
     private getPopulate;

package/dist/FirebaseConnector.js

@@ -7,14 +7,14 @@ const fireorm_1 = require("fireorm");
 const firestore_1 = require("@google-cloud/firestore");
 const fluent_1 = require("@goatlab/fluent");
 const js_utils_1 = require("@goatlab/js-utils");
-const createFirebaseRepository = Entity => {
-    const typeOrmRepo = fluent_1.modelGeneratorDataSource.getRepository(Entity);
+const createFirebaseRepository = (Entity, dataSource) => {
+    const typeOrmRepo = dataSource.getRepository(Entity);
     const repository = (0, fireorm_1.getRepository)(Entity);
     let name = '';
     let path = '';
     const relations = {};
     for (const relation of typeOrmRepo.metadata.relations) {
-        relations[relation.inverseEntityMetadata.givenTableName.toLowerCase()] = {
+        relations[relation.propertyName] = {
             isOneToMany: relation.isOneToMany,
             isManyToOne: relation.isManyToOne,
             isManyToMany: relation.isManyToMany,
@@ -45,9 +45,9 @@ const createFirebaseRepository = Entity => {
 };
 exports.createFirebaseRepository = createFirebaseRepository;
 class FirebaseConnector extends fluent_1.BaseConnector {
-    constructor(Entity, relationQuery) {
+    constructor(Entity, dataSource, relationQuery) {
         super();
-        const { repository, keys, name, relations } = (0, exports.createFirebaseRepository)(Entity);
+        const { repository, keys, name, relations } = (0, exports.createFirebaseRepository)(Entity, dataSource);
         this.relationQuery = relationQuery;
         this.repository = repository;
         this.collection = admin.firestore().collection(name);
@@ -56,9 +56,28 @@ class FirebaseConnector extends fluent_1.BaseConnector {
     }
     async get() {
         let query = this.getGeneratedQuery();
-        if (this.relationQuery && this.relationQuery.data) {
+        let pivotData = [];
+        if (this.relationQuery && this.relationQuery.data && this.relationQuery.relation) {
             const ids = this.relationQuery.data.map(d => d.id);
-            query = query.where(this.relationQuery.relation.inverseSidePropertyPath, 'in', ids);
+            if (this.relationQuery?.relation?.isManyToMany) {
+                const pivotForeignKey = this.relationQuery.relation.joinColumns[0].propertyName;
+                const pivotInverseKey = this.relationQuery.relation.inverseJoinColumns[0].propertyName;
+                const { pivot } = this.relationQuery;
+                pivotData = await pivot.where(key => key[pivotForeignKey], "in", ids).get();
+                if (!pivotData.length) {
+                    return [];
+                }
+                const inverseIds = [...new Set(pivotData.map(d => d[pivotInverseKey]))];
+                if (!inverseIds.length) {
+                    return [];
+                }
+                if (inverseIds.length) {
+                    query = query.where("id", 'in', inverseIds);
+                }
+            }
+            else {
+                query = query.where(this.relationQuery.relation.inverseSidePropertyPath, 'in', ids);
+            }
         }
         const snapshot = await query.get();
         const result = [];
@@ -71,8 +90,15 @@ class FirebaseConnector extends fluent_1.BaseConnector {
             relations: this.relations,
             modelRelations: this.modelRelations,
             provider: 'firebase',
-            self: this
+            self: this,
+            returnPivot: Boolean(this.relationQuery?.returnPivot)
         });
+        if (pivotData.length && this.relationQuery?.returnPivot) {
+            const pivotInverseKey = this.relationQuery.relation.inverseJoinColumns[0].propertyName;
+            data = data.map(d => {
+                return { ...d, pivot: pivotData.find(p => p[pivotInverseKey] === d.id) };
+            });
+        }
         this.reset();
         return data;
     }
@@ -215,10 +241,23 @@ class FirebaseConnector extends fluent_1.BaseConnector {
         const result = this.jsApplySelect(data);
         this.reset();
         if (result.length === 0) {
-            return Promise.reject(new Error('Entity not found'));
+            return null;
         }
         return result[0];
     }
+    async findByIds(ids) {
+        const data = await this.raw().where('id', 'in', ids).get();
+        if (data.empty) {
+            return null;
+        }
+        const res = [];
+        data.forEach(doc => {
+            res.push(doc.data());
+        });
+        const results = this.jsApplySelect(res);
+        this.reset();
+        return results;
+    }
     getPage() {
         const page = 'page=';
         if (this.paginator && this.paginator.page) {

package/dist/test/advanced/advancedTestSuite.js

@@ -48,40 +48,40 @@ const advancedTestSuite = Model => {
     });
     it('pluck() should return a single array', async () => {
         await insertTestData(Model);
-        const data = await Model.pluck(Model._keys.test);
+        const data = await Model.pluck(keys => keys.test);
         expect(typeof data[0]).toBe('boolean');
     });
     it('orderBy() should order results desc', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
-            .orderBy(Model._keys.order, 'desc')
+        const forms = await Model.select(keys => [keys.test, keys.nestedTest.b.c, keys.order])
+            .orderBy(keys => keys.order, 'desc')
             .get();
         expect(forms[0].order).toBe(3);
         expect(forms[0].nestedTest.b.c).toBe(true);
     });
     it('orderBy() should order results asc', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
-            .orderBy(Model._keys.order, 'asc')
+        const forms = await Model.select(keys => [keys.test, keys.nestedTest.b.c, keys.order])
+            .orderBy(keys => keys.order, 'asc')
             .get();
         expect(forms[0].order).toBe(1);
     });
     it('orderBy() should order by Dates with Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
-            .orderBy(Model._keys.created, 'asc', 'date')
+        const forms = await Model.select(keys => [keys.created, keys.order])
+            .orderBy(keys => keys.created, 'asc', 'date')
             .get();
         expect(forms[0].order).toBe(3);
     });
     it('orderBy() should order by Dates without Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.orderBy(Model._keys.created, 'asc', 'date').get();
+        const forms = await Model.orderBy(keys => keys.created, 'asc', 'date').get();
         expect(forms[0].order).toBe(3);
     });
     it('limit() should limit the amount of results', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
-            .orderBy(Model._keys.created, 'asc', 'date')
+        const forms = await Model.select(keys => [keys.created, keys.order])
+            .orderBy(keys => keys.created, 'asc', 'date')
             .limit(2)
             .get();
         expect(forms.length > 0).toBe(true);
@@ -89,7 +89,7 @@ const advancedTestSuite = Model => {
     });
     it('offset() should start at the given position', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
+        const forms = await Model.select(keys => [keys.created, keys.order])
             .offset(1)
             .limit(1)
             .get();
@@ -97,7 +97,7 @@ const advancedTestSuite = Model => {
     });
     it('where() should filter the data', async () => {
         await insertTestData(Model);
-        const forms = await Model.where(Model._keys.nestedTest.c, '>=', 3).get();
+        const forms = await Model.where(keys => keys.nestedTest.c, '>=', 3).get();
         expect(forms.length > 0).toBe(true);
         forms.forEach(form => {
             expect(form.nestedTest.c >= 3).toBe(true);
@@ -105,8 +105,8 @@ const advancedTestSuite = Model => {
     });
     it('first() should take the first result from data', async () => {
         await insertTestData(Model);
-        const form = await Model.select(Model._keys.nestedTest.c, Model._keys.id)
-            .where(Model._keys.nestedTest.c, '>=', 3)
+        const form = await Model.select(keys => [keys.nestedTest.c, keys.id])
+            .where(keys => keys.nestedTest.c, '>=', 3)
             .first();
         expect(typeof form.nestedTest.c).toBe('number');
     });

package/dist/test/advanced/firebase.repository.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirebaseRepository = void 0;
 const FirebaseConnector_1 = require("../../FirebaseConnector");
 const typeOrm_entity_1 = require("./typeOrm.entity");
+const fluent_1 = require("@goatlab/fluent");
 class FirebaseRepository extends FirebaseConnector_1.FirebaseConnector {
     constructor(relations) {
-        super(typeOrm_entity_1.TypeORMDataModel, 'runningTest');
+        super(typeOrm_entity_1.TypeORMDataModel, fluent_1.modelGeneratorDataSource, relations);
     }
 }
 exports.FirebaseRepository = FirebaseRepository;

package/dist/test/relations/relationsTestsSuite.js

@@ -13,7 +13,7 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user = await Model.where(Model.cars()._keys.id, '=', insertedUser.id).load();
+        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const cars = await user.cars().attach({ name: 'Another new car' });
         expect(Array.isArray(cars)).toBe(true);
         expect(cars[0].name).toBe('Another new car');
@@ -24,23 +24,23 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(Model._keys.id, '=', insertedUser.id).load();
+        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const cars = await user1.cars().attach({ name: 'My new car' });
         expect(Array.isArray(cars)).toBe(true);
-        const searchUserWithRelation = await Model.where(Model._keys.id, '=', insertedUser.id)
-            .with({ cars: true })
+        const searchUserWithRelation = await Model.where(keys => keys.id, '=', insertedUser.id)
+            .with({ cars: ManyToManyModel })
             .get();
         expect(Array.isArray(searchUserWithRelation[0].cars)).toBe(true);
         expect(searchUserWithRelation[0].cars.length > 0).toBe(true);
         const searchCar = await user1
             .cars()
-            .where(Model.cars()._keys.name, '=', 'My new car')
+            .where(keys => keys.name, '=', 'My new car')
             .get();
         expect(Array.isArray(searchCar)).toBe(true);
         expect(searchCar.length > 0).toBe(true);
         const searchCar2 = await user1
             .cars()
-            .where(Model.cars()._keys.name, '=', 'My.......')
+            .where(keys => keys.name, '=', 'My.......')
             .get();
         expect(Array.isArray(searchCar2)).toBe(true);
         expect(searchCar2.length === 0).toBe(true);
@@ -51,7 +51,7 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(Model.cars()._keys.id, '=', insertedUser.id).load();
+        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         await user1.cars().attach({ name: 'My new car' });
         const results = await BelongsToModel.with({ users: true }).get();
         expect(Array.isArray(results)).toBe(true);
@@ -67,11 +67,11 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
         const adminRole = await ManyToManyModel.insert({
             name: 'Administrator'
         });
-        const user = await Model.where(Model._keys.id, '=', insertedUser.id).load();
+        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const associated = await user.roles().associate(adminRole.id);
         expect(associated[0].userId).toBe(insertedUser.id);
         expect(associated[0].roleId).toBe(adminRole.id);
-        const searchUserWithRelation = await Model.where(Model._keys.id, '=', insertedUser.id)
+        const searchUserWithRelation = await Model.where(keys => keys.id, '=', insertedUser.id)
             .with({
             roles: true
         })
@@ -79,7 +79,7 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
         expect(Array.isArray(searchUserWithRelation[0].roles)).toBe(true);
         expect(searchUserWithRelation[0].roles.length > 0).toBe(true);
         expect(typeof searchUserWithRelation[0].roles[0].name).toBe('string');
-        const roles = await ManyToManyModel.where(ManyToManyModel._keys.name, '=', 'Administrator')
+        const roles = await ManyToManyModel.where(keys => keys.name, '=', 'Administrator')
             .with({
             users: true
         })