@goatlab/fluent-firebase 0.6.1 → 0.6.2

package/dist/Firebase.d.ts

@@ -0,0 +1,5 @@
+import * as admin from 'firebase-admin';
+export declare type FirebaseUser = admin.auth.DecodedIdToken;
+export declare const Firebase: Readonly<{
+    verifyIdToken: (token: string) => Promise<import("firebase-admin/lib/auth/token-verifier").DecodedIdToken>;
+}>;

package/dist/Firebase.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Firebase = void 0;
+const tslib_1 = require("tslib");
+const admin = tslib_1.__importStar(require("firebase-admin"));
+exports.Firebase = (() => {
+    const verifyIdToken = (token) => admin.auth().verifyIdToken(token);
+    return Object.freeze({ verifyIdToken });
+})();

package/dist/FirebaseConnector.d.ts

@@ -0,0 +1,42 @@
+import * as admin from 'firebase-admin';
+import { BaseFirestoreRepository } from 'fireorm';
+import { DataSource as datasource } from 'typeorm';
+import type { Filter, DaoOutput, BaseDataElement, PaginatedData, Paginator, Sure } from '@goatlab/fluent';
+import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
+export declare const DataSource: typeof datasource;
+export declare const createFirebaseRepository: (Entity: any) => {
+    repository: BaseFirestoreRepository<import("fireorm").IEntity>;
+    name: string;
+    path: string;
+    keys: string[];
+    relations: {};
+};
+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);
+    get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    getPaginated(): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
+    all(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    find(filter?: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    paginate(paginator: Paginator): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
+    raw(): admin.firestore.CollectionReference<ModelDTO>;
+    insert(data: InputDTO, forcedId?: string | number): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    insertMany(data: InputDTO[], forcedId?: string | number): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    batchInsert(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    replaceById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    clear({ sure }: Sure): Promise<unknown>;
+    deleteById(id: string): Promise<string>;
+    findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    private getPage;
+    private getPaginatorLimit;
+    private getPopulate;
+    private getGeneratedQuery;
+    private getFilters;
+    private getOrderBy;
+    private getLimit;
+    private getSkip;
+    private getSelect;
+    private deleteQueryBatch;
+}

package/dist/FirebaseConnector.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseConnector = exports.createFirebaseRepository = exports.DataSource = void 0;
+const tslib_1 = require("tslib");
+const admin = tslib_1.__importStar(require("firebase-admin"));
+const fireorm_1 = require("fireorm");
+const typeorm_1 = require("typeorm");
+const firestore_1 = require("@google-cloud/firestore");
+const fluent_1 = require("@goatlab/fluent");
+const js_utils_1 = require("@goatlab/js-utils");
+const db = admin.firestore();
+exports.DataSource = typeorm_1.DataSource;
+const createFirebaseRepository = Entity => {
+    const typeOrmRepo = fluent_1.modelGeneratorDataSource.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()] = {
+            isOneToMany: relation.isOneToMany,
+            isManyToOne: relation.isManyToOne,
+            isManyToMany: relation.isManyToMany,
+            inverseSidePropertyPath: relation.inverseSidePropertyPath,
+            propertyPath: relation.propertyName,
+            entityName: relation.inverseEntityMetadata.name,
+            tableName: relation.inverseEntityMetadata.tableName,
+            targetClass: relation.inverseEntityMetadata.target,
+            joinColumns: relation.joinColumns,
+            inverseJoinColumns: relation.inverseJoinColumns
+        };
+    }
+    try {
+        const parsed = JSON.parse(JSON.stringify(repository));
+        name = parsed.colMetadata.name;
+        path = parsed.path;
+    }
+    catch (error) {
+        name = '';
+    }
+    return {
+        repository,
+        name,
+        path,
+        keys: [...['id', '_id'], ...(0, fluent_1.getOutputKeys)(typeOrmRepo)],
+        relations
+    };
+};
+exports.createFirebaseRepository = createFirebaseRepository;
+class FirebaseConnector extends fluent_1.BaseConnector {
+    constructor(Entity, relationQuery) {
+        super();
+        const { repository, keys, name, relations } = (0, exports.createFirebaseRepository)(Entity);
+        this.relationQuery = relationQuery;
+        this.repository = repository;
+        this.collection = db.collection(name);
+        this.outputKeys = keys || [];
+        this.modelRelations = relations;
+    }
+    async get() {
+        let query = this.getGeneratedQuery();
+        if (this.relationQuery && this.relationQuery.data) {
+            const ids = this.relationQuery.data.map(d => d.id);
+            query = query.where(this.relationQuery.relation.inverseSidePropertyPath, 'in', ids);
+        }
+        const snapshot = await query.get();
+        const result = [];
+        snapshot.forEach(doc => {
+            result.push(doc.data());
+        });
+        let data = this.jsApplySelect(result);
+        data = await (0, fluent_1.loadRelations)({
+            data,
+            relations: this.relations,
+            modelRelations: this.modelRelations,
+            provider: 'firebase',
+            self: this
+        });
+        this.reset();
+        return data;
+    }
+    async getPaginated() {
+        const response = await this.get();
+        const result = this.jsApplySelect(response);
+        const results = {
+            current_page: 1,
+            data: result,
+            first_page_url: 'response[0].meta.firstPageUrl,',
+            next_page_url: 'response[0].meta.nextPageUrl',
+            path: 'response[0].meta.path',
+            per_page: 1,
+            prev_page_url: ' response[0].meta.previousPageUrl',
+            total: 10
+        };
+        return results;
+    }
+    async all() {
+        return this.get();
+    }
+    async find(filter = {}) {
+        const stringFilter = filter;
+        let parsedFilter = {};
+        try {
+            parsedFilter = JSON.parse(stringFilter);
+        }
+        catch (error) {
+            parsedFilter = {};
+        }
+        this.selectArray = (parsedFilter && parsedFilter.fields) || [];
+        this.whereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.and) || [];
+        this.orWhereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.or) || [];
+        this.limit((parsedFilter && (parsedFilter.limit || parsedFilter.take)) || 20);
+        this.offset((parsedFilter && (parsedFilter.offset || parsedFilter.skip)) || 0);
+        if (parsedFilter && parsedFilter.order) {
+            const orderB = [
+                parsedFilter.order.field,
+                parsedFilter.order.asc ? 'asc' : 'desc',
+                parsedFilter.order.type || 'string'
+            ];
+            this.chainReference.push({ method: 'orderBy', orderB });
+            this.orderByArray = orderB;
+        }
+        return this.get();
+    }
+    async paginate(paginator) {
+        if (!paginator) {
+            throw new Error('Paginator cannot be empty');
+        }
+        this.paginator = paginator;
+        const response = await this.getPaginated();
+        return response;
+    }
+    raw() {
+        return this.collection;
+    }
+    async insert(data, forcedId) {
+        const id = forcedId || js_utils_1.Ids.objectIdString();
+        const datum = await this.repository.create({ id, ...data });
+        const result = this.jsApplySelect([datum]);
+        this.reset();
+        return result[0];
+    }
+    async insertMany(data, forcedId) {
+        const batch = [];
+        data.forEach(d => {
+            const id = js_utils_1.Ids.objectIdString();
+            batch.push(this.repository.create({ id, ...d }));
+        });
+        const inserted = await Promise.all(batch);
+        const result = this.jsApplySelect(inserted);
+        this.reset();
+        return result;
+    }
+    async batchInsert(data) {
+        const batch = this.repository.createBatch();
+        data.forEach(d => {
+            const id = js_utils_1.Ids.objectIdString();
+            batch.create({ id, ...d });
+        });
+        const inserted = await batch.commit();
+        const result = this.jsApplySelect(inserted);
+        this.reset();
+        return result;
+    }
+    async updateById(id, data) {
+        const parsedId = id;
+        const dbResult = await this.repository.findById(parsedId);
+        const updateData = {
+            ...dbResult,
+            ...data
+        };
+        const updated = await this.repository.update(updateData);
+        const result = this.jsApplySelect([updated]);
+        this.reset();
+        return result[0];
+    }
+    async replaceById(id, data) {
+        const parsedId = id;
+        const value = await this.repository.findById(parsedId);
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            if (key !== 'id') {
+                flatValue[key] = null;
+            }
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue.created;
+        delete newValue.updated;
+        const entity = { ...newValue };
+        await this.repository.update(entity);
+        const val = await this.repository.findById(parsedId);
+        const returnValue = this.jsApplySelect([val]);
+        this.reset();
+        return returnValue[0];
+    }
+    async clear({ sure }) {
+        if (!sure || sure !== true) {
+            throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
+        }
+        const query = this.collection.orderBy('__name__').limit(300);
+        this.reset();
+        return new Promise((resolve, reject) => {
+            this.deleteQueryBatch(db, query, 300, resolve, reject);
+        });
+    }
+    async deleteById(id) {
+        const parsedId = id;
+        await this.repository.delete(parsedId);
+        this.reset();
+        return id;
+    }
+    async findById(id) {
+        const parsedId = id;
+        const data = await this.repository.findById(parsedId);
+        const result = this.jsApplySelect(data);
+        this.reset();
+        if (result.length === 0) {
+            return Promise.reject(new Error('Entity not found'));
+        }
+        return result[0];
+    }
+    getPage() {
+        const page = 'page=';
+        if (this.paginator && this.paginator.page) {
+            return `${page + this.paginator.page}&`;
+        }
+        return '';
+    }
+    getPaginatorLimit(filter) {
+        if (this.paginator && this.paginator.perPage) {
+            return { ...filter, limit: this.paginator.perPage };
+        }
+        return filter;
+    }
+    getPopulate() {
+        const populate = [];
+        this.populateArray.forEach(relation => {
+            if (typeof relation === 'string') {
+                populate.push({ relation });
+            }
+            else if (Array.isArray(relation)) {
+                relation.forEach(nestedRelation => {
+                    if (typeof nestedRelation === 'string') {
+                        populate.push({ relation: nestedRelation });
+                    }
+                    else if (typeof nestedRelation === 'object') {
+                        populate.push(nestedRelation);
+                    }
+                });
+            }
+            else if (typeof relation === 'object') {
+                populate.push(relation);
+            }
+        });
+        return populate;
+    }
+    getGeneratedQuery() {
+        let queryBuilder = this.getFilters();
+        const select = this.getSelect();
+        if (select.length > 0) {
+            queryBuilder = queryBuilder.select(...this.getSelect());
+        }
+        const limit = this.getLimit();
+        if (limit > 0) {
+            queryBuilder = queryBuilder.limit(limit);
+        }
+        const skip = this.getSkip();
+        if (skip) {
+            queryBuilder = queryBuilder.offset(skip);
+        }
+        const order = this.getOrderBy();
+        if (order[0] && order[0] !== '') {
+            const fieldPath = new firestore_1.FieldPath(order[0] || '');
+            const orderByOrder = order[1] || 'desc';
+            queryBuilder = queryBuilder.orderBy(fieldPath, orderByOrder);
+        }
+        return queryBuilder;
+    }
+    getFilters() {
+        const andFilters = this.whereArray;
+        const orFilters = this.orWhereArray;
+        if (!andFilters || andFilters.length === 0) {
+            return this.collection;
+        }
+        let filterQuery;
+        andFilters.forEach((condition, index) => {
+            const element = condition[0];
+            const operator = condition[1];
+            const value = condition[2];
+            if (index === 0) {
+                filterQuery = this.collection;
+            }
+            switch (operator) {
+                case '=':
+                    filterQuery = filterQuery.where(element, '==', value);
+                    break;
+                case '!=':
+                    filterQuery = filterQuery.where(element, '!=', value);
+                    break;
+                case '>':
+                    filterQuery = filterQuery.where(element, operator, value);
+                    break;
+                case '>=':
+                    filterQuery = filterQuery.where(element, operator, value);
+                    break;
+                case '<':
+                    filterQuery = filterQuery.where(element, operator, value);
+                    break;
+                case '<=':
+                    filterQuery = filterQuery.where(element, operator, value);
+                    break;
+                case 'in':
+                    filterQuery = filterQuery.where(element, 'in', value);
+                    break;
+                case 'array-contains':
+                    filterQuery = filterQuery.where(element, 'array-contains', value);
+                    break;
+                case 'nin':
+                    throw new Error('The nin Operator cannot be used in Firabase');
+                    break;
+                case 'exists':
+                    throw new Error('The nin Operator cannot be used in Firabase');
+                    break;
+                case '!exists':
+                    throw new Error('The !exists Operator cannot be used in Firabase');
+                    break;
+                case 'regexp':
+                    throw new Error('The regexp Operator cannot be used in Firabase');
+                    break;
+            }
+        });
+        return filterQuery;
+    }
+    getOrderBy() {
+        if (!this.orderByArray || this.orderByArray.length === 0) {
+            return [];
+        }
+        return [this.orderByArray[0], this.orderByArray[1].toLowerCase()];
+    }
+    getLimit() {
+        if (!this.limitNumber || this.limitNumber === 0) {
+            this.limitNumber = (this.rawQuery && this.rawQuery.limit) || 20;
+        }
+        return this.limitNumber;
+    }
+    getSkip() {
+        if (!this.offsetNumber) {
+            this.offsetNumber = (this.rawQuery && this.rawQuery.skip) || 0;
+        }
+        return this.offsetNumber;
+    }
+    getSelect() {
+        let select = this.selectArray;
+        select = select.map(s => {
+            s = s.split(' as ')[0];
+            s = s.includes('id') ? 'id' : s;
+            return s;
+        });
+        if (select.find(e => e.startsWith('data.'))) {
+            select.unshift('data');
+        }
+        if (!select) {
+            return [];
+        }
+        return select;
+    }
+    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);
+    }
+}
+exports.FirebaseConnector = FirebaseConnector;

package/dist/FirebaseInit.d.ts

@@ -0,0 +1,8 @@
+interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    databaseName?: string;
+    serviceAccountPath?: string;
+}
+export declare const FirebaseInit: ({ host, port, databaseName, serviceAccountPath }: ConnectionOptions) => void;
+export {};

package/dist/FirebaseInit.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseInit = void 0;
+const tslib_1 = require("tslib");
+const admin = tslib_1.__importStar(require("firebase-admin"));
+const fireorm = tslib_1.__importStar(require("fireorm"));
+const FirebaseInit = ({ host, port, databaseName, serviceAccountPath }) => {
+    if (admin.apps.length) {
+        return;
+    }
+    if (host && port) {
+        process.env.FIRESTORE_EMULATOR_HOST = `${host}:${port}`;
+    }
+    const serviceAccount = serviceAccountPath
+        ? require(serviceAccountPath)
+        : undefined;
+    admin.initializeApp({
+        projectId: databaseName,
+        credential: serviceAccount
+            ? admin.credential.cert(serviceAccount)
+            : admin.credential.applicationDefault()
+    });
+    const fireStore = admin.firestore();
+    fireStore.settings({ ignoreUndefinedProperties: true });
+    fireorm.initialize(fireStore);
+    if (!fireStore) {
+        throw new Error('Could not initialize FireStore');
+    }
+};
+exports.FirebaseInit = FirebaseInit;

package/dist/firebaseConnector.http_spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebaseConnector.http_spec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const car_entity_1 = require("./test/relations/car/car.entity");
+const car_repositoryFirebase_1 = require("./test/relations/car/car.repositoryFirebase");
+const firebase_repository_1 = require("./test/advanced/firebase.repository");
+const fluent_1 = require("@goatlab/fluent");
+const goat_entity_1 = require("./test/basic/goat.entity");
+const goat_repository_1 = require("./test/goat.repository");
+const roles_entity_1 = require("./test/relations/roles/roles.entity");
+const roles_repositoryFirebase_1 = require("./test/relations/roles/roles.repositoryFirebase");
+const roles_user_entity_1 = require("./test/relations/roles/roles_user.entity");
+const typeOrm_entity_1 = require("./test/advanced/typeOrm.entity");
+const user_repositoryFirebase_1 = require("./test/relations/user/user.repositoryFirebase");
+const user_entity_1 = require("./test/relations/user/user.entity");
+const advancedTestSuite_1 = require("./test/advanced/advancedTestSuite");
+const basicTestSuite_1 = require("./test/basic/basicTestSuite");
+const relationsTestsSuite_1 = require("./test/relations/relationsTestsSuite");
+jest.setTimeout(3 * 60 * 1000);
+beforeAll(async () => {
+    await fluent_1.Fluent.models([
+        goat_entity_1.GoatEntity,
+        typeOrm_entity_1.TypeORMDataModel,
+        car_entity_1.CarsEntity,
+        user_entity_1.UsersEntity,
+        roles_entity_1.RoleEntity,
+        roles_user_entity_1.RolesUser
+    ]);
+});
+describe('Execute all basic test Suite', () => {
+    (0, basicTestSuite_1.basicTestSuite)(goat_repository_1.GoatEntityRepository);
+});
+describe('Execute all advanced', () => {
+    (0, advancedTestSuite_1.advancedTestSuite)(firebase_repository_1.FirebaseRepository);
+});
+describe('Execute all relations test suite', () => {
+    (0, relationsTestsSuite_1.relationsTestSuite)(user_repositoryFirebase_1.UserRepository, car_repositoryFirebase_1.CarsRepository, roles_repositoryFirebase_1.RoleRepository);
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { FirebaseConnector } from './FirebaseConnector';
+import { FirebaseInit } from './FirebaseInit';
+export { FirebaseConnector, FirebaseInit };

package/dist/index.js

@@ -5,4 +5,3 @@ const FirebaseConnector_1 = require("./FirebaseConnector");
 Object.defineProperty(exports, "FirebaseConnector", { enumerable: true, get: function () { return FirebaseConnector_1.FirebaseConnector; } });
 const FirebaseInit_1 = require("./FirebaseInit");
 Object.defineProperty(exports, "FirebaseInit", { enumerable: true, get: function () { return FirebaseInit_1.FirebaseInit; } });
-//# sourceMappingURL=index.js.map

package/dist/test/advanced/advancedTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const advancedTestSuite: (Model: any) => void;

package/dist/test/advanced/advancedTestSuite.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.advancedTestSuite = void 0;
+const advancedTestSuite = Model => {
+    beforeAll(() => {
+        try {
+            Model = new Model();
+        }
+        catch (error) { }
+    });
+    const insertTestData = async (Repository) => {
+        await Repository.insert({
+            created: '2018-12-03',
+            nestedTest: {
+                a: [6, 5, 4],
+                b: { c: true, d: [2, 1, 0] },
+                c: 4
+            },
+            order: 1,
+            test: true
+        });
+        await Repository.insert({
+            created: '2017-12-03',
+            nestedTest: {
+                a: [3, 2, 1],
+                b: { c: true, d: [1, 1, 0] },
+                c: 3
+            },
+            order: 2,
+            test: false
+        });
+        await Repository.insert({
+            created: '2016-12-03',
+            nestedTest: {
+                a: [0, -1, -2],
+                b: { c: true, d: [0, 1, 0] },
+                c: 2
+            },
+            order: 3,
+            test: false
+        });
+    };
+    it('Should get local data', async () => {
+        await insertTestData(Model);
+        const data = await Model.all();
+        expect(Array.isArray(data)).toBe(true);
+        expect(typeof data[0].nestedTest.b.c).toBe('boolean');
+    });
+    it('pluck() should return a single array', async () => {
+        await insertTestData(Model);
+        const data = await Model.pluck(Model._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')
+            .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')
+            .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')
+            .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();
+        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')
+            .limit(2)
+            .get();
+        expect(forms.length > 0).toBe(true);
+        expect(forms.length <= 2).toBe(true);
+    });
+    it('offset() should start at the given position', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .offset(1)
+            .limit(1)
+            .get();
+        expect(forms.length).toBe(1);
+    });
+    it('where() should filter the data', async () => {
+        await insertTestData(Model);
+        const forms = await Model.where(Model._keys.nestedTest.c, '>=', 3).get();
+        expect(forms.length > 0).toBe(true);
+        forms.forEach(form => {
+            expect(form.nestedTest.c >= 3).toBe(true);
+        });
+    });
+    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)
+            .first();
+        expect(typeof form.nestedTest.c).toBe('number');
+    });
+};
+exports.advancedTestSuite = advancedTestSuite;

package/dist/test/advanced/firebase.repository.d.ts

@@ -0,0 +1,5 @@
+import { FirebaseConnector } from '../../FirebaseConnector';
+import { TypeORMDataModel } from './typeOrm.entity';
+export declare class FirebaseRepository extends FirebaseConnector<TypeORMDataModel> {
+    constructor(relations?: any);
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseRepository = void 0;
+const FirebaseConnector_1 = require("../../FirebaseConnector");
+const typeOrm_entity_1 = require("./typeOrm.entity");
+class FirebaseRepository extends FirebaseConnector_1.FirebaseConnector {
+    constructor(relations) {
+        super(typeOrm_entity_1.TypeORMDataModel, 'runningTest');
+    }
+}
+exports.FirebaseRepository = FirebaseRepository;