@entropic-bond/firebase 1.12.0 → 1.13.0

package/src/store/firebase-datasource.spec.ts

@@ -0,0 +1,555 @@
+import dns from 'node:dns'
+import { Model, Persistent, Store } from 'entropic-bond'
+import { FirebaseDatasource } from './firebase-datasource'
+import { FirebaseHelper } from '../firebase-helper'
+import { TestUser, DerivedUser, SubClass } from '../mocks/test-user'
+import mockData from '../mocks/mock-data.json'
+
+dns.setDefaultResultOrder('ipv4first')
+
+async function loadTestData( model: Model<TestUser> ) {
+	const users = Object.values( mockData.TestUser )
+	await Promise.all(
+		users.map( userObj => {
+			const user = Persistent.createInstance<TestUser>( userObj as any )
+			return model.save( user )
+		})
+	)
+}
+
+describe( 'Firestore Model', ()=>{
+	let model: Model<TestUser>
+	let testUser: TestUser
+	const host = 'localhost'
+	const firestorePort = 9080
+
+	beforeAll(()=>{
+		FirebaseHelper.setFirebaseConfig({
+			projectId: "demo-test",
+		})
+		FirebaseHelper.useEmulator({ host, firestorePort })
+		Store.useDataSource( new FirebaseDatasource() )
+	})
+
+	beforeEach( async ()=>{
+
+		testUser = new TestUser()
+		testUser.name = {
+			firstName: 'testUserFirstName',
+			lastName: 'testUserLastName'
+		}
+		testUser.age = 35
+		testUser.skills = [ 'lazy', 'dirty' ]
+
+		model = Store.getModel<TestUser>( 'TestUser' )
+
+		await loadTestData( model )
+	})
+
+	afterEach( async ()=>{
+		await fetch( `http://${ host }:${ firestorePort }/emulator/v1/projects/demo-test/databases/(default)/documents`, {
+			method: 'DELETE'
+		})
+	})
+
+	it( 'should find document by id', async ()=>{
+		await model.save( testUser )
+
+		const user = await model.findById( testUser.id )
+
+		expect( user ).toBeInstanceOf( TestUser )
+		expect( user?.id ).toEqual( testUser.id )
+		expect( user?.name?.firstName ).toEqual( 'testUserFirstName' )
+	})
+
+	it( 'should write a document', async ()=>{
+		await model.save( testUser )
+		const newUser = await model.findById( testUser.id )
+
+		expect( newUser?.name ).toEqual({
+			firstName: 'testUserFirstName',
+			lastName: 'testUserLastName'
+		})
+	})
+
+	it( 'should delete a document by id', async ()=>{
+		await model.save( testUser )
+
+		const newUser = await model.findById( testUser.id )
+		expect( newUser?.age ).toBe( 35 )
+
+		await model.delete( testUser.id )
+
+		const deletedUser = await model.findById( testUser.id )
+		expect( deletedUser ).toBeUndefined()
+	})
+
+	it( 'should not throw if a document id doesn\'t exists', ()=>{
+		expect( async ()=>{
+			await model.findById( 'nonExistingId' )
+		}).not.toThrow()
+	})
+
+	it( 'should return undefined if a document id doesn\'t exists', async ()=>{
+		expect( await model.findById( 'nonExistingId' ) ).toBeUndefined()
+	})
+
+	it( 'should retrieve array fields', async ()=>{
+		await model.save( testUser )
+		const newUser = await model.findById( testUser.id )
+
+		expect( Array.isArray( newUser?.skills ) ).toBeTruthy()
+		expect( newUser?.skills ).toEqual( expect.arrayContaining([ 'lazy', 'dirty' ]) )
+	})
+
+	it( 'should retrieve object fields', async ()=>{
+		await model.save( testUser )
+		const newUser = await model.findById( testUser.id )
+
+		expect( newUser?.name ).toEqual({
+			firstName: 'testUserFirstName',
+			lastName: 'testUserLastName'
+		})
+	})
+
+	describe( 'Generic find', ()=>{
+		it( 'should query all admins with query object', async ()=>{
+			testUser.admin = true
+			await model.save( testUser )
+
+			const admins = await model.query({
+				operations: [{
+					property: 'admin',
+					operator: '==',
+					value: true
+				}]
+			})
+
+			expect( admins.length ).toBeGreaterThanOrEqual( 1 )
+			expect( admins[ 0 ] ).toBeInstanceOf( TestUser )
+		})
+
+		it( 'should find all admins with where methods', async ()=>{
+			const admins = await model.find().where( 'admin', '==', true ).get()
+
+			expect( admins.length ).toBeGreaterThanOrEqual( 1 )
+			expect( admins[ 0 ] ).toBeInstanceOf( TestUser )
+		})
+
+		it( 'should find admins with age less than 56', async ()=>{
+			const admins = await model.find()
+				.where( 'admin', '==', true )
+				.where( 'age', '<', 50 )
+				.get()
+
+			expect( admins.length ).toBeGreaterThanOrEqual( 1 )
+			expect( admins[ 0 ]?.age ).toBeLessThan( 50 )
+		})
+
+		it( 'should query by subproperties', async ()=>{
+			const users = await model.query({
+				operations: [
+					{
+						property: 'name',
+						operator: '==',
+						value: { firstName: 'userFirstName3' }
+					},
+					{ property: 'age', operator: '!=', value: 134	}
+				]
+			})
+
+			expect( users[0]?.id ).toBe( 'user3' )
+		})
+
+		it( 'should find by subproperties', async ()=>{
+			const users = await model.find()
+				.where( 'name', '==', { firstName: 'userFirstName3' })
+				.get()
+
+			expect( users[0]?.id ).toBe( 'user3' )
+		})
+		
+		it( 'should find by property path', async ()=>{
+			const users = await model.find()
+				.whereDeepProp( 'name.firstName', '==', 'userFirstName3' )
+				.get()
+
+				expect( users[0]?.id ).toBe( 'user3' )
+		})
+		
+		it( 'should find by superdeep property path', async ()=>{
+			const users = await model.find()
+				.whereDeepProp( 'name.ancestorName.father', '==', 'user3Father')
+				.get()
+
+			expect( users[0]?.id ).toEqual( 'user3' )
+		})
+
+		it( 'should find by swallow property path', async ()=>{
+			const users = await model.find()
+				.whereDeepProp( 'age', '==', 21 )
+				.get()
+
+			expect( users[0]?.id ).toEqual( 'user2' )
+		})
+	})
+
+
+	describe( 'Compound queries', ()=>{
+		it( 'should find documents using `AND` compound query', async ()=>{
+			const admins = await model.find()
+				.where( 'admin', '==', true )
+				.where( 'age', '<', 50 )
+				.get()
+
+			expect( admins ).toHaveLength( 1 )
+			expect( admins[0]?.age ).toBeLessThan( 50 )
+		})
+
+		it( 'should find using `OR` query', async ()=>{
+			const docs = await model.find().or( 'age', '==', 23 ).or( 'age', '==', 41 ).get()
+
+			expect( docs ).toHaveLength( 2 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', age: 23 }),
+				expect.objectContaining({ id: 'user5', age: 41 })
+			]))
+		})
+
+		it( 'should find combining `OR` query and `where` query', async ()=>{
+			const docs = await model.find().where( 'age', '>', 50 ).or( 'age', '==', 23 ).or( 'age', '==', 41 ).get()
+
+			expect( docs ).toHaveLength( 3 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', age: 23 }),
+				expect.objectContaining({ id: 'user5', age: 41 }),
+				expect.objectContaining({ id: 'user3', age: 56 })
+			]))
+		})
+
+		it( 'should find combining `OR` query and `where` query in a range', async ()=>{
+			const docs = await model.find().where( 'age', '<', 22 ).or( 'age', '>', 50 ).get()
+
+			expect( docs ).toHaveLength( 2 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user2', age: 21 }),
+				expect.objectContaining({ id: 'user3', age: 56 })
+			]))
+		})
+
+		it( 'should find combining `OR` query and `where` query on different fields', async ()=>{
+			const docs = await model.find().where( 'age', '==', 23 ).or( 'admin', '!=', true ).get()
+
+			expect( docs ).toHaveLength( 3 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', admin: true, age: 23 }),
+				expect.objectContaining({ id: 'user2', admin: false, age: 21 }),
+				expect.objectContaining({ id: 'user4', admin: false, age: 35 }),
+			]))
+		})
+
+		it( 'should throw if a `where` query is used after an `or` query', ()=>{
+			expect( 
+				()=> model.find().or( 'age', '==', 23 ).where( 'age', '>', 50 )
+			).toThrow( Model.error.invalidQueryOrder )
+		})
+
+		it( 'should evaluate mixing operands', async ()=>{
+			const docs = await model.find().where( 'age', '>', 39 ).and( 'age', '<', 57 ).or( 'age', '==', 23 ).or( 'age', '==', 21 ).get()
+			expect( docs ).toHaveLength( 5 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', age: 23 }),
+				expect.objectContaining({ id: 'user2', age: 21 }),
+				expect.objectContaining({ id: 'user3', age: 56 }),
+				expect.objectContaining({ id: 'user5', age: 41 }),
+				expect.objectContaining({ id: 'user6', age: 40 })
+			]))
+
+			const docs1 = await model.find().where( 'age', '==', 41 ).and( 'age', '==', 56 ).or( 'age', '==', 23 ).or( 'age', '==', 21 ).get()
+			expect( docs1 ).toHaveLength( 2 )
+			expect( docs1 ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', age: 23 }),
+				expect.objectContaining({ id: 'user2', age: 21 })
+			]))
+
+			const docs2 = await model.find().where( 'age', '==', 41 ).or( 'age', '==', 56 ).or( 'age', '==', 23 ).or( 'age', '==', 21 ).get()
+			expect( docs2 ).toHaveLength( 4 )
+			expect( docs2 ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user1', age: 23 }),
+				expect.objectContaining({ id: 'user2', age: 21 }),
+				expect.objectContaining({ id: 'user3', age: 56 }),
+				expect.objectContaining({ id: 'user5', age: 41 })
+			]))
+		})
+
+	})
+
+	describe( 'Searchable array property', ()=>{
+
+		it( 'should find documents using `containsAny` operator', async ()=>{
+			const colleague1 = new TestUser( 'colleague1' )
+			const colleague2 = new TestUser( 'colleague2' )
+			const docs = await model.find().where( 'colleagues', 'containsAny', [ colleague1, colleague2 ]).get()
+
+			expect( docs ).toHaveLength( 3 )
+			expect( docs ).toEqual( expect.arrayContaining([
+				expect.objectContaining({ id: 'user2' }),
+				expect.objectContaining({ id: 'user4' }),
+				expect.objectContaining({ id: 'user6' })
+			]))
+		})
+
+		it( 'should find documents using `contains` operator', async ()=>{
+			const colleague2 = new TestUser( 'colleague2' )
+			const docs = await model.find().where( 'colleagues', 'contains', colleague2 ).get()
+
+			expect( docs ).toHaveLength( 2 )
+			expect( docs ).toEqual([
+				expect.objectContaining({ id: 'user4' }),
+				expect.objectContaining({ id: 'user6' })
+			])
+		})
+
+	})
+
+	describe( 'Derived classes should fit on parent collection', ()=>{
+
+		it( 'should save derived object in parent collection', async ()=>{
+			const derived = new DerivedUser()
+			derived.name = { firstName: 'Fulanito', lastName: 'Derived' }
+			derived.salary = 3900
+
+			await model.save( derived )
+
+			const newUser = await model.findById( derived.id ) as DerivedUser
+			expect( newUser ).toBeInstanceOf( DerivedUser )
+			expect( newUser.salary ).toBe( 3900 )
+			expect( newUser.className ).toEqual( 'DerivedUser' )
+		})
+	})
+
+	describe( 'References to documents', ()=>{
+		let ref1: SubClass, ref2: SubClass
+
+		beforeEach( async ()=>{
+			testUser.documentRef = new SubClass()
+			testUser.documentRef.year = 2045
+			ref1 = new SubClass(); ref1.year = 2081
+			ref2 = new SubClass(); ref2.year = 2082
+			testUser.manyRefs.push( ref1 )
+			testUser.manyRefs.push( ref2 )
+			testUser.derived = new DerivedUser()
+			testUser.derived!.salary = 1350
+			testUser.manyDerived = [ new DerivedUser(), new DerivedUser() ]
+			testUser.manyDerived![ 0 ]!.salary = 990
+			testUser.manyDerived![ 1 ]!.salary = 1990
+
+			await model.save( testUser )
+		})
+
+		it( 'should save a document as a reference', async ()=>{
+			const subClassModel = Store.getModel( 'SubClass' )
+			expect( subClassModel ).toBeDefined()
+
+			const newDocument = await subClassModel.findById( testUser.documentRef!.id ) as SubClass
+
+			expect( newDocument ).toBeInstanceOf( SubClass )
+			expect( newDocument.year ).toBe( 2045 )
+		})
+
+		it( 'should read a swallow document reference', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+
+			expect( loadedUser?.documentRef ).toBeInstanceOf( SubClass )
+			expect( loadedUser?.documentRef?.id ).toBeDefined()
+			expect( loadedUser?.documentRef?.year ).toBeUndefined()
+		})
+
+		it( 'should fill data of swallow document reference', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+
+			await Store.populate( loadedUser!.documentRef! )
+			expect( loadedUser?.documentRef?.id ).toBeDefined()
+			expect( loadedUser?.documentRef?.year ).toBe( 2045 )
+		})
+
+
+		it( 'should save and array of references', async ()=>{
+			const subClassModel = Store.getModel( 'SubClass' )
+
+			const newDocument = await subClassModel.findById( testUser.documentRef!.id ) as SubClass
+
+			expect( newDocument ).toBeInstanceOf( SubClass )
+			expect( newDocument.year ).toBe( 2045 )
+		})
+
+		it( 'should read an array of references', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+			
+			expect( loadedUser?.manyRefs ).toHaveLength( 2 )
+			expect( loadedUser?.manyRefs[0] ).toBeInstanceOf( SubClass )
+			expect( loadedUser?.manyRefs[0]?.id ).toEqual( testUser.manyRefs[0]!.id )
+			expect( loadedUser?.manyRefs[0]?.year ).toBeUndefined()
+			expect( loadedUser?.manyRefs[1] ).toBeInstanceOf( SubClass )
+			expect( loadedUser?.manyRefs[1]?.id ).toEqual( testUser.manyRefs[1]!.id )
+			expect( loadedUser?.manyRefs[1]?.year ).toBeUndefined()
+		})
+
+		it( 'should fill array of refs', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+			await Store.populate( loadedUser!.manyRefs )
+
+			expect( loadedUser?.manyRefs[ 0 ]?.year ).toBe( 2081 )
+			expect( loadedUser?.manyRefs[ 1 ]?.year ).toBe( 2082 )
+		})
+
+		it( 'should save a reference when declared @persistentAt', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+
+			expect( loadedUser?.derived?.id ).toEqual( testUser.derived!.id )
+			expect( loadedUser?.derived?.salary ).toBeUndefined()
+
+			await Store.populate( loadedUser!.derived! )
+
+			expect( loadedUser?.derived?.salary ).toBe( 1350 )
+			expect( loadedUser?.derived?.id ).toBe( testUser.derived!.id )
+		})
+
+		it( 'should populate from special collection when declared with @persistentRefAt', async ()=>{
+			const loadedUser = await model.findById( 'user6' )
+			await Store.populate( loadedUser!.derived! )
+
+			expect( loadedUser?.derived?.salary ).toBe( 2800 )
+			expect( loadedUser?.derived?.id ).toBe( 'user4' )
+		})
+		
+		it( 'should save a reference when declared @persistentAt as array', async ()=>{
+			const loadedUser = await model.findById( testUser.id )
+
+			expect( loadedUser?.manyDerived?.[0]?.id ).toEqual( testUser.manyDerived![0]!.id )
+			expect( loadedUser?.manyDerived?.[0]?.salary ).toBeUndefined()
+			expect( loadedUser?.manyDerived?.[1]?.salary ).toBeUndefined()
+
+			await Store.populate( loadedUser!.manyDerived! )
+
+			expect( loadedUser?.manyDerived?.[0]?.salary ).toBe( 990 )
+			expect( loadedUser?.manyDerived?.[0]?.id ).toBe( testUser.manyDerived![0]!.id )
+			expect( loadedUser?.manyDerived?.[1]?.salary ).toBe( 1990 )
+			expect( loadedUser?.manyDerived?.[1]?.id ).toBe( testUser.manyDerived?.[1]?.id )
+		})
+
+		it( 'should not overwrite not filled ref in collection', async ()=>{
+			const loadedUser = await model.findById( 'user6' )
+			await model.save( loadedUser! )
+			const refInCollection = await model.findById<DerivedUser>( 'user4' )
+
+			expect( refInCollection?.salary ).toBe( 2800 )
+		})
+
+		it( 'should save loaded ref with assigned new instance', async ()=>{
+			const loadedUser = await model.findById( 'user6' )
+			loadedUser!.derived = new DerivedUser()
+			loadedUser!.derived!.salary = 345
+			await model.save( loadedUser! )
+
+			const refInCollection = await model.findById<DerivedUser>( loadedUser!.derived.id )
+			expect( refInCollection?.salary ).toBe( 345 )
+		})
+
+		it( 'should save loaded ref with modified ref data', async ()=>{
+			const loadedUser = await model.findById( 'user6' )
+			await Store.populate( loadedUser!.derived! )
+			loadedUser!.derived!.salary = 1623
+			await model.save( loadedUser! )
+
+			const refInCollection = await model.findById<DerivedUser>( 'user4' )
+			expect( refInCollection?.salary ).toBe( 1623 )
+		})
+	})
+
+	describe( 'Operations on queries', ()=>{
+		it( 'should limit the result set', async ()=>{
+			const unlimited = await model.find().get()
+			const limited = await model.find().limit( 2 ).get()
+
+			expect( unlimited.length ).not.toBe( limited.length )
+			expect( limited ).toHaveLength( 2 )
+		})
+
+		it( 'should sort ascending the result set', async ()=>{
+			const docs = await model.find().orderBy( 'age' ).get()
+
+			expect( docs[ 0 ]?.id ).toEqual( 'user2' )
+			expect( docs[ 1 ]?.id ).toEqual( 'user1' )
+		})
+
+		it( 'should sort descending the result set', async ()=>{
+			const docs = await model.find().orderBy( 'age', 'desc' ).get()
+
+			expect( docs[ 0 ]?.id ).toEqual( 'user3' )
+			expect( docs[ 1 ]?.id ).toEqual( 'user5' )
+		})
+
+		it( 'should sort by deep property path', async ()=>{
+			const docs = await model.find().orderByDeepProp( 'name.firstName', 'desc' ).get()
+
+			expect( docs[ 0 ]?.id ).toEqual( 'user6' )
+			expect( docs[ 1 ]?.id ).toEqual( 'user5' )
+		})
+
+		it( 'should sort by swallow property path', async ()=>{
+			const docs = await model.find().orderByDeepProp( 'age' ).get()
+
+			expect( docs[ 0 ]?.id ).toEqual( 'user2' )
+			expect( docs[ 1 ]?.id ).toEqual( 'user1' )
+		})
+
+		it( 'should count documents in collection', async ()=>{
+			expect( await model.find().count() ).toBe( 6 )
+		})
+		
+
+		describe( 'Data Cursors', ()=>{
+			beforeEach( async ()=>{
+				await model.find().get( 2 )
+			})
+
+			it( 'should get next result set', async ()=>{
+				const docs = await model.next()
+				const mockDataArr = Object.values( mockData.TestUser )
+				
+				expect( docs ).toHaveLength( 2 )
+				expect( docs[0]?.id ).toEqual( mockDataArr[2]!.id )
+				expect( docs[ 0 ]?.id ).toEqual( 'user3' )
+			})
+
+			it( 'should not go beyond the end of result set', async ()=>{
+				await model.next()
+				await model.next()
+				const docs = await model.next()
+				expect( docs ).toHaveLength( 0 )
+			})
+
+		})
+	})
+
+	describe( 'SubCollections', ()=>{
+		let model: Model<SubClass>
+	
+		beforeEach(()=>{
+			model = Store.getModelForSubCollection( testUser, 'SubClass' )
+		})
+	
+		it( 'should retrieve from subcollection', async ()=>{
+			const subClass = new SubClass()
+			subClass.year = 3452
+
+			await model.save( subClass )
+
+			const loaded = await model.findById( subClass.id )
+
+			expect( loaded?.year ).toBe( 3452 )
+		})
+	})
+
+})

package/src/store/firebase-datasource.ts

@@ -0,0 +1,146 @@
+import { and, collection, connectFirestoreEmulator, deleteDoc, doc, DocumentData, getCountFromServer, getDoc, getDocs, limit, or, orderBy, Query, query, QueryDocumentSnapshot, QueryFieldFilterConstraint, QueryNonFilterConstraint, startAfter, where, WhereFilterOp, writeBatch } from 'firebase/firestore'
+import { Collections, DataSource, DocumentObject, QueryObject, QueryOperator } from 'entropic-bond'
+import { EmulatorConfig, FirebaseHelper, FirebaseQuery } from '../firebase-helper'
+
+interface ConstraintsContainer {
+	andConstraints: QueryFieldFilterConstraint[]
+	orConstraints: QueryFieldFilterConstraint[]
+	nonFilterConstraints: QueryNonFilterConstraint[]
+}
+
+export class FirebaseDatasource extends DataSource {
+	constructor( emulator?: EmulatorConfig ) {
+		super()
+		if ( emulator ) FirebaseHelper.useEmulator( emulator )
+		
+		if ( FirebaseHelper.emulator?.emulate ) {
+			const { host, firestorePort } = FirebaseHelper.emulator
+			connectFirestoreEmulator( FirebaseHelper.instance.firestore(), host, firestorePort )
+		}
+	}
+
+	findById( id: string, collectionName: string ): Promise< DocumentObject > {
+		const db = FirebaseHelper.instance.firestore()
+		
+		return new Promise<DocumentObject>( async resolve => {
+			try {
+				const docSnap = await getDoc( doc( db, collectionName, id ) )
+				resolve( docSnap.data() as DocumentObject )
+			} 
+			catch( error ) {
+				console.log( error )
+				return null
+			}
+		})
+	}
+
+	save( collections: Collections ): Promise< void > {
+		const db = FirebaseHelper.instance.firestore()
+		const batch = writeBatch( db )
+
+		Object.entries( collections ).forEach(([ collectionName, collection ]) => {
+			collection?.forEach( document => {
+					const ref = doc( db, collectionName, document.id )
+					batch.set( ref, document ) 
+			})
+		})
+
+		return batch.commit()
+	}
+
+	find( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise< DocumentObject[] > {
+		const query = this.queryObjectToQueryConstraints( queryObject, collectionName )
+		return this.getFromQuery( query )
+	}
+
+	async count( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise<number> {
+		const query = this.queryObjectToQueryConstraints( queryObject, collectionName )
+		
+		const snapShot = await getCountFromServer( query )
+		return snapShot.data().count
+	}
+
+	delete( id: string, collectionName: string ): Promise< void > {
+		const db = FirebaseHelper.instance.firestore()
+
+		return deleteDoc( doc( db, collectionName, id ) )
+	}
+
+	next( maxDocs?: number ): Promise< DocumentObject[] > {
+		if( !this._lastConstraints || !this._lastCollectionName ) throw new Error('You should perform a query prior to using method next')
+
+		const db = FirebaseHelper.instance.firestore()
+		this._lastLimit = maxDocs || this._lastLimit
+
+		const constraints = this._lastConstraints.nonFilterConstraints.concat(
+			limit( this._lastLimit ),
+			startAfter( this._lastDocRetrieved )
+		)
+
+		return this.getFromQuery( query( collection( db, this._lastCollectionName ), ...constraints ) )
+	}
+
+	// prev should be used with next in reverse order
+	// prev( limit?: number ): Promise< DocumentObject[] > {
+	// }
+
+	private queryObjectToQueryConstraints( queryObject: QueryObject<DocumentObject>, collectionName: string ): Query {
+		const db = FirebaseHelper.instance.firestore()
+		const andConstraints: QueryFieldFilterConstraint[] = []
+		const orConstraints: QueryFieldFilterConstraint[] = []
+		const nonFilterConstraints: QueryNonFilterConstraint[] = []
+
+		DataSource.toPropertyPathOperations( queryObject.operations as any ).forEach( operation =>	{
+			const operator = this.toFirebaseOperator( operation.operator )
+			if ( operation.aggregate ) orConstraints.push( where( operation.property, operator, operation.value ) )
+			else andConstraints.push( where( operation.property, operator, operation.value ) )
+		})
+
+		if ( queryObject.sort?.propertyName ) {
+			nonFilterConstraints.push( orderBy( queryObject.sort.propertyName, queryObject.sort.order ) )
+		}
+		
+		this._lastConstraints = {
+			orConstraints,
+			andConstraints,
+			nonFilterConstraints
+		}
+
+		this._lastCollectionName = collectionName
+
+		if( queryObject.limit ) {
+			this._lastLimit = queryObject.limit
+			nonFilterConstraints.push( limit( queryObject.limit ) )
+		}
+
+		return query( collection( db, collectionName ), or( ...orConstraints, and( ...andConstraints ) ), ...nonFilterConstraints )
+	}
+
+	toFirebaseOperator( operator: QueryOperator ): WhereFilterOp {
+		switch( operator ) {
+			case '==': 
+			case '!=':
+			case '<':
+			case '<=':
+			case '>':
+			case '>=': return operator
+			case 'contains': return 'array-contains'
+			case 'containsAny': return 'array-contains-any'
+			default: return operator
+		}
+	}
+
+	private getFromQuery( query: FirebaseQuery ) {
+		return new Promise< DocumentObject[] >( async resolve => {
+			const doc = await getDocs( query )
+			this._lastDocRetrieved = doc.docs[ doc.docs.length-1 ]
+
+			resolve( doc.docs.map( doc => doc.data() as DocumentObject ) ) 
+		})
+	}
+
+	private _lastDocRetrieved: QueryDocumentSnapshot<DocumentData> | undefined
+	private _lastConstraints: ConstraintsContainer | undefined
+	private _lastLimit: number = 0
+	private _lastCollectionName: string | undefined
+}

package/storage.rules

@@ -0,0 +1,8 @@
+rules_version = '2';
+service firebase.storage {
+  match /b/{bucket}/o {
+    match /{allPaths=**} {
+      allow read, write
+    }
+  }
+}