@entropic-bond/firebase 1.12.1 → 1.13.0

package/functions/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "functions",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "serve": "npm run build && firebase emulators:start --only functions",
+    "shell": "npm run build && firebase functions:shell",
+    "start": "npm run shell",
+    "deploy": "firebase deploy --only functions",
+    "logs": "firebase functions:log",
+    "install-build": "npm i && npm run build",
+    "postinstall": "npm run build"
+  },
+  "engines": {
+    "node": "20"
+  },
+  "main": "lib/index.js",
+  "dependencies": {
+    "firebase-admin": "^12.0.0",
+    "firebase-functions": "^4.7.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "private": true
+}

package/functions/src/index.ts

@@ -0,0 +1,33 @@
+import * as _functions from 'firebase-functions'
+import admin from 'firebase-admin'
+import { persistent, Persistent, PersistentObject, registerPersistentClass } from 'entropic-bond'
+
+@registerPersistentClass( 'ParamWrapper' )
+export class ParamWrapper extends Persistent {
+	constructor( a?: string, b?: number ) {
+		super()
+		this._a = a
+		this._b = b
+	}
+	@persistent _a: string
+	@persistent _b: number
+}
+
+
+admin.initializeApp()
+const functions = _functions.region('europe-west1')
+
+export const test = functions.https.onRequest((_req, res) => {
+  res.send('Hello from Firebase!')
+})
+
+export const testCallablePersistent = functions.https.onCall( 
+	( param: PersistentObject<ParamWrapper> ) => {
+		Persistent.registerFactory( 'ParamWrapper', ParamWrapper )
+		return param
+	}
+)
+
+export const testCallablePlain = functions.https.onCall( 
+	( param: string ) => param.length
+)

package/functions/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "outDir": "lib",
+		"resolveJsonModule": true,
+    "experimentalDecorators": true,
+    "lib": [
+      "ES2021", "WebWorker"
+    ]
+  },
+  "compileOnSave": false,
+  "include": [
+    "src"
+  ]
+}

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@entropic-bond/firebase",
-  "version": "1.12.1",
   "type": "module",
+  "version": "1.13.0",
+  "description": "Firebase plugins for Entropic Bond",
+  "main": "./lib/entropic-bond-firebase.umd.cjs",
+  "module": "./lib/entropic-bond-firebase.js",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/entropic-bond-firebase.umd.cjs",
+      "types": "./lib/index.d.ts"
+    }
+  },
   "publishConfig": {
     "access": "public",
     "branches": [
@@ -17,18 +27,10 @@
       "@semantic-release/github"
     ]
   },
-  "description": "Firebase plugins for Entropic Bond",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib"
-  ],
   "scripts": {
     "test": "npm run install-functions-dependencies && firebase emulators:exec --project demo-test vitest",
-    "build": "npm run build-cjs",
+    "build": "tsc -p tsconfig-build.json && vite build",
     "prepare": "npm run build",
-    "build-ts": "cp -r ./src/ ./lib",
-    "build-cjs": "tsc -p tsconfig-cjs.json",
     "emulators": "firebase emulators:start --project demo-test",
     "install-functions-dependencies": "cd functions && npm ci"
   },
@@ -52,13 +54,14 @@
     "@types/node": "^20.11.16",
     "git-branch-is": "^4.0.0",
     "husky": "^9.0.10",
-    "semantic-release": "^23.0.0",
+    "semantic-release": "^23.0.2",
     "typescript": "^5.3.3",
+    "vite-plugin-dts": "^3.7.2",
     "vitest": "^1.2.2",
     "xhr2": "^0.2.1"
   },
   "dependencies": {
-    "entropic-bond": "^1.49.0",
+    "entropic-bond": "^1.50.2",
     "firebase": "^10.8.0"
   }
 }

package/src/auth/firebase-auth.spec.ts

@@ -0,0 +1,90 @@
+import { Auth } from 'entropic-bond'
+import { FirebaseHelper } from '../firebase-helper'
+import { FirebaseAuth } from './firebase-auth'
+
+// NOTE: Firebase auth emulator requires a modification of the code to test which
+//       violates testing best practices. Therefore, this test is disabled.
+
+describe( 'Firebase Auth', ()=>{
+	it( 'should pass', ()=>{
+		expect( true ).toBe( true )
+	})
+	
+// 	let authChangeSpy = vi.fn()
+// 	FirebaseHelper.setFirebaseConfig({
+// 		projectId: "demo-test",
+// 	})
+// 	FirebaseHelper.useEmulator({ authPort: 9099 })
+
+// 	beforeEach(()=>{
+// 		Auth.registerAuthService( new FirebaseAuth() )
+// 		Auth.instance.onAuthStateChange( authChangeSpy ) 
+// 	})
+
+// 	it( 'should emulate sign-up', async ()=>{
+// 		const userCredential = await Auth.instance.signUp({
+// 			authProvider: 'google',
+// 			email: 'test@test.com',
+// 			password: 'password'
+// 		})
+
+// 		expect( userCredential.email ).toEqual( 'test@test.com' )
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( userCredential )
+// 	})
+
+// 	it( 'should emulate failed sign-up', async ()=>{
+// 		try {
+// 			var userCredential = await Auth.instance.signUp({
+// 				authProvider: 'fail',
+// 				email: 'test@test.com',
+// 				password: 'password'
+// 			})
+// 		}
+// 		catch {}
+
+// 		expect( userCredential ).toBeUndefined()
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
+// 	})
+
+// 	it( 'should login with fake registered user', async ()=>{
+// 		const userCredentials = await Auth.instance.login({
+// 			email: 'fakeUser@test.com',
+// 			password: 'password',
+// 			authProvider: 'google'
+// 		})
+
+// 		expect( userCredentials ).toEqual( 'fakeUseCredentials' )
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( 'fakeUseCredentials' )
+// 	})
+
+// 	it( 'should fail login with email auth provider if does not match fake user credentials', async ()=>{
+// 		try {
+// 			var userCredentials = await Auth.instance.login({
+// 				email: 'test@test.com',
+// 				password: 'password',
+// 				authProvider: 'email'
+// 			})
+// 		} catch {}
+
+// 		expect( userCredentials ).toEqual( undefined )
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
+// 	})
+	
+// 	it( 'should NOT fail login with non email auth provider even if does not match fake user credentials', async ()=>{
+// 		const userCredentials = await Auth.instance.login({
+// 			email: 'test@test.com',
+// 			password: 'password',
+// 			authProvider: 'google'
+// 		})
+
+// 		expect( userCredentials.email ).toEqual( 'test@test.com' )
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
+// 	})
+
+// 	it( 'should logout', async ()=>{
+// 		await Auth.instance.logout()
+
+// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
+// 	})
+	
+})

package/src/auth/firebase-auth.ts

@@ -0,0 +1,212 @@
+import { AuthProvider, SignData, UserCredentials, AuthService, RejectedCallback, ResovedCallback, AuthErrorCode, camelCase } from 'entropic-bond'
+import { connectAuthEmulator, createUserWithEmailAndPassword, FacebookAuthProvider, GoogleAuthProvider, linkWithPopup, sendEmailVerification, signInAnonymously, signInWithEmailAndPassword, signInWithPopup, TwitterAuthProvider, updateProfile, unlink, User, UserCredential, sendPasswordResetEmail } from 'firebase/auth'
+import { EmulatorConfig, FirebaseHelper } from '../firebase-helper'
+
+interface CredentialProviders {
+	[ name: string ]: ( signData: SignData ) => Promise<UserCredential>
+}
+
+const providerFactory = {
+	'twitter': () => new TwitterAuthProvider(),
+	'facebook': () => new FacebookAuthProvider(),
+	'google': () => new GoogleAuthProvider()
+}
+
+export class FirebaseAuth extends AuthService {
+	constructor( emulator?: EmulatorConfig ) {
+		super()
+		if ( emulator ) FirebaseHelper.useEmulator( emulator )
+		
+		if ( FirebaseHelper.emulator?.emulate ) {
+			const { host, authPort } = FirebaseHelper.emulator
+			if ( !host || !authPort ) throw new Error( `You should define a host and an auth emulator port to use the emulator` )
+
+			connectAuthEmulator( FirebaseHelper.instance.auth(), `http://${ host }:${ authPort }` )
+		}
+
+		this.registerCredentialProviders()
+	}
+
+	signUp<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
+		const { authProvider, verificationLink } = signData
+	
+		if ( authProvider.slice( 0, 5 ) === 'email' ) {
+			return new Promise<UserCredentials<T>>( async ( resolve: ResovedCallback<T>, reject: RejectedCallback ) => {
+				try {
+					const credentialFactory = this.credentialProviders[ 'email-sign-up' ]
+					if ( !credentialFactory ) throw new Error( `The provider ${ authProvider } is not registered` )
+
+					const userCredentials = await credentialFactory( signData )
+
+					if ( signData.name ) {
+						await updateProfile( userCredentials.user, {
+							displayName: signData.name
+						})
+					}
+					
+					if ( verificationLink ) {
+						await sendEmailVerification( userCredentials.user, {
+							url: verificationLink
+						})
+					}
+
+					resolve( await this.toUserCredentials( userCredentials.user ) )
+				}
+				catch( error ) {
+					reject({ 
+						code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode, 
+						message: error.message 
+					})
+				}
+			})
+		}
+		else return this.login( signData )
+	}
+
+	login<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
+		const { authProvider } = signData
+
+		return new Promise<UserCredentials<T>>( async ( resolve: ResovedCallback<T>, reject: RejectedCallback ) => {
+			try {
+				const credentialFactory = this.credentialProviders[ authProvider ]
+				if ( !credentialFactory ) throw new Error( `The provider ${ authProvider } is not registered` )
+				const userCredentials = await credentialFactory( signData )
+				resolve( await this.toUserCredentials<T>( userCredentials.user ) )
+			}
+			catch( error ) {
+				reject({ 
+					code: error.code === 400? 'missingPassword' : camelCase( error.code.slice( 5 )) as AuthErrorCode, 
+					message: error.message
+				})
+			}
+		})
+	}
+
+	logout(): Promise<void> {
+		return FirebaseHelper.instance.auth().signOut()
+	}
+
+	resetEmailPassword( email: string ) {
+		return new Promise<void>( async ( resolve, reject ) => {
+			try {
+				await sendPasswordResetEmail( FirebaseHelper.instance.auth(), email )
+				resolve()
+			}
+			catch( error ) {
+				reject({
+					code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode,
+					message: error.message
+				})
+			}
+		})
+	}
+
+	resendVerificationEmail( email: string, password: string, verificationLink: string ): Promise<void> {
+		return new Promise<void>( async ( resolve, reject ) => {
+			try {
+				await signInWithEmailAndPassword( FirebaseHelper.instance.auth(), email, password )
+				const user = FirebaseHelper.instance.auth().currentUser
+				if ( !user ) { 
+					reject({
+						code: 'userNotFound',
+						message: `There is no logged in user`
+					})
+					return
+				}
+
+				await sendEmailVerification( user, {
+					url: verificationLink
+				})
+				resolve()
+			}
+			catch( error ) {
+				reject({
+					code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode,
+					message: verificationLink
+				})
+			}
+		})
+	}
+
+	override refreshToken(): Promise<void> {
+		return FirebaseHelper.instance.auth().currentUser?.getIdToken( true ) as unknown as Promise<void>
+	}
+
+	onAuthStateChange<T extends {}>( onChange: (userCredentials: UserCredentials<T> | undefined) => void ) {
+		FirebaseHelper.instance.auth().onAuthStateChanged( async credentials =>{
+			onChange( credentials? await this.toUserCredentials( credentials ) : undefined )
+		})
+	}
+
+	linkAdditionalProvider( provider: AuthProvider ): Promise<unknown> {
+		const providerInstance = providerFactory[ provider ]()
+		const currentUser = FirebaseHelper.instance.auth().currentUser
+		if ( !currentUser ) throw new Error( `There is no logged in user` )
+
+		return linkWithPopup( currentUser, providerInstance )
+	}
+
+	unlinkProvider( provider: AuthProvider ): Promise<unknown> {
+		const { currentUser } = FirebaseHelper.instance.auth()
+		if ( !currentUser ) throw new Error( `There is no logged in user` )
+
+		currentUser.providerData
+		return unlink( currentUser, providerFactory[ provider ]().providerId )
+	}
+
+	private async toUserCredentials<T extends {}>( nativeUserCredential: User ): Promise<UserCredentials<T>> {
+		if ( !nativeUserCredential ) throw new Error( `The user in user credentials is not defined` )
+		
+		const claims = ( await nativeUserCredential.getIdTokenResult() ).claims as T
+
+		return FirebaseAuth.convertCredentials<T>( nativeUserCredential, claims )
+	}
+
+	static convertCredentials<T extends {}>( nativeUserCredential: User, claims: T ): UserCredentials<T> {
+		return ({
+			id: nativeUserCredential.uid,
+			email: nativeUserCredential.email ?? '',
+			name: nativeUserCredential.displayName ?? undefined,
+			pictureUrl: nativeUserCredential.photoURL ?? undefined,
+			phoneNumber: nativeUserCredential.phoneNumber ?? undefined,
+			emailVerified: nativeUserCredential.emailVerified,
+			customData: {...claims},
+			lastLogin: Date.now(),
+			creationDate: nativeUserCredential.metadata.creationTime? new Date( nativeUserCredential.metadata.creationTime ).getTime() : undefined,
+		})
+	}
+
+	registerCredentialProvider( name: string, providerFactory: ( singData: SignData ) => Promise<UserCredential> ) {
+		this.credentialProviders[ name ] = providerFactory		
+	}
+
+	private registerCredentialProviders() { //TODO: refactor. Not needed anymore
+		this.registerCredentialProvider( 'email-sign-up', signData => {
+			if ( !signData.email || !signData.password ) throw new Error( `Email and password are required` )
+			return createUserWithEmailAndPassword(	FirebaseHelper.instance.auth(), signData.email, signData.password )
+		})
+		this.registerCredentialProvider( 'email', signData => {
+			if ( !signData.email || !signData.password ) throw new Error( `Email and password are required` )
+			return signInWithEmailAndPassword( FirebaseHelper.instance.auth(), signData.email, signData.password )
+		})
+		this.registerCredentialProvider( 'google', () => signInWithPopup(
+			FirebaseHelper.instance.auth(), new GoogleAuthProvider()
+		))
+		this.registerCredentialProvider( 'facebook', () => signInWithPopup(
+			FirebaseHelper.instance.auth(), new FacebookAuthProvider()
+		))
+		this.registerCredentialProvider( 'twitter', () => signInWithPopup(
+			FirebaseHelper.instance.auth(), new TwitterAuthProvider()
+		))
+		this.registerCredentialProvider( 'link-twitter', () => {
+			const currentUser = FirebaseHelper.instance.auth().currentUser
+			if ( !currentUser ) throw new Error( `There is no logged in user` )
+			return linkWithPopup(	currentUser, new TwitterAuthProvider() )
+		})
+		this.registerCredentialProvider( 'anonymous', () => signInAnonymously(
+			FirebaseHelper.instance.auth()
+		))
+	}
+
+	private credentialProviders: CredentialProviders = {}
+}

package/src/cloud-functions/firebase-cloud-functions.spec.ts

@@ -0,0 +1,47 @@
+import { CloudFunctions, Persistent, persistent, registerPersistentClass } from 'entropic-bond'
+import { FirebaseHelper } from '../firebase-helper'
+import { FirebaseCloudFunctions } from './firebase-cloud-functions'
+
+@registerPersistentClass( 'ParamWrapper' )
+export class ParamWrapper extends Persistent {
+	constructor( a?: string, b?: number ) {
+		super()
+		this._a = a
+		this._b = b
+	}
+	@persistent _a: string | undefined
+	@persistent _b: number | undefined
+}
+
+describe( 'Cloud functions', ()=>{
+
+	beforeEach(()=>{
+		FirebaseHelper.setFirebaseConfig({
+			projectId: 'demo-test',
+			storageBucket: 'default-bucket'
+		})
+		
+		FirebaseHelper.useEmulator()
+		CloudFunctions.useCloudFunctionsService( 
+			new FirebaseCloudFunctions( 'europe-west1', { emulate: true })
+		)
+	})
+
+	it( 'should call cloud functions with plain types', async ()=>{
+		const testCallablePlain = CloudFunctions.instance.getFunction<string, number>( 'testCallablePlain' )
+		const result = await testCallablePlain( 'Hello' )
+
+		expect( result ).toBe( 5 )
+	})
+	
+	it( 'should call cloud function for Persistent', async ()=>{
+		const testCallablePersistent = CloudFunctions.instance.getFunction<ParamWrapper, ParamWrapper>( 'testCallablePersistent' )
+		const paramWrapper = new ParamWrapper( 'test', 30 )
+
+		const a = paramWrapper.toObject()
+
+		const result = await testCallablePersistent( paramWrapper )
+		expect( result._a ).toEqual( 'test' )
+		expect( result._b ).toEqual( 30 )
+	})
+})

package/src/cloud-functions/firebase-cloud-functions.ts

@@ -0,0 +1,25 @@
+import { CloudFunction, CloudFunctionsService } from 'entropic-bond'
+import { connectFunctionsEmulator, httpsCallable } from 'firebase/functions'
+import { EmulatorConfig, FirebaseHelper } from '../firebase-helper'
+
+export class FirebaseCloudFunctions implements CloudFunctionsService {
+	constructor( region?: string, emulator?: Partial<EmulatorConfig> ) {
+		if ( region ) FirebaseHelper.setRegion( region )
+		if ( emulator ) FirebaseHelper.useEmulator( emulator )
+		
+		if ( FirebaseHelper.emulator?.emulate ) {
+			const { host, functionsPort } = FirebaseHelper.emulator
+			connectFunctionsEmulator( FirebaseHelper.instance.functions(), host, functionsPort )
+		}
+
+	}
+
+	retrieveFunction<P, R>( cloudFunction: string ): CloudFunction<P, R> {
+		return httpsCallable<P,R>( FirebaseHelper.instance.functions(), cloudFunction ) as unknown as CloudFunction<P, R>
+	}
+
+	async callFunction<P, R>( func: CloudFunction<P, R>, params: P ): Promise<R> {
+		const res = await func( params ) as any
+		return res.data
+	}
+}

package/src/cloud-storage/firebase-cloud-storage.spec.ts

@@ -0,0 +1,135 @@
+(global as any).XMLHttpRequest = require('xhr2')
+import { FirebaseCloudStorage } from './firebase-cloud-storage'
+import { FirebaseHelper } from '../firebase-helper'
+import { FirebaseDatasource } from '../store/firebase-datasource'
+import { CloudStorage, Model, Persistent, persistent, registerPersistentClass, Store, StoredFile } from 'entropic-bond'
+
+// Note about tests leaking. I've been checking and looks like firebase.storage 
+// methods are the responsible for the test leaking (as firebase v. 8.6.3).
+
+class File {	
+	data: Uint8Array | undefined
+	name: string | undefined
+	lastModified: any
+	size: number | undefined
+	type: any
+	arrayBuffer: any
+	slice: any
+	stream: any
+	text: any
+}
+global['File'] = File as any
+
+@registerPersistentClass( 'Test' )
+class Test extends Persistent {
+
+	get file(): StoredFile {
+		return this._file
+	}
+	
+	@persistent private _file: StoredFile = new StoredFile()
+}
+
+describe( 'Firebase Cloud Storage', ()=>{
+	const blobData1 = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21]);
+	const blobData2 = new Uint8Array([0x6c, 0x6c, 0x6f, 0x2c, 0x48, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21]);
+	let file: StoredFile
+
+	FirebaseHelper.setFirebaseConfig({
+		projectId: 'demo-test',
+		storageBucket: 'default-bucket'
+	})
+	FirebaseHelper.useEmulator({ firestorePort: 9080 })
+	Store.useDataSource( new FirebaseDatasource() )
+
+	beforeEach(()=>{
+		CloudStorage.useCloudStorage( new FirebaseCloudStorage() )
+		file = new StoredFile()
+	})
+
+	it( 'should save and get a url', async ()=>{
+		await file.save({ data:blobData1 })
+
+		expect( file.url ).toContain( file.id )
+	})
+	
+	it( 'should report metadata', async ()=>{
+		await file.save({ data: blobData1, fileName: 'test.dat' })
+
+		expect( file.originalFileName ).toEqual( 'test.dat' )
+		expect( file.provider.className ).toEqual( 'FirebaseCloudStorage' )
+	})
+
+	it( 'should delete file', async ()=>{
+		await file.save({ data:blobData1 })
+
+		await file.delete()
+		expect( file.url ).not.toBeDefined()		
+	})
+
+	it( 'should overwrite file on subsequent writes', async ()=>{
+		await file.save({ data:blobData1 })
+		const firstUrl = file.url
+		let resp = await fetch( file.url! )
+		expect( await resp.text() ).toEqual( 'Hello, world!')
+
+		await file.save({ data:blobData2 })
+		resp = await fetch( file.url! )
+		expect( 
+			file.url?.slice( 0, file.url.indexOf('token') ) 
+		).toEqual( 
+			firstUrl?.slice( 0, firstUrl.indexOf('token') ) 
+		)
+		expect( await resp.text() ).toEqual( 'llo,He world!')
+	})
+
+	it( 'should trigger events', async () => {
+		const cb = vi.fn()
+
+		const savePromise = file.save({ data:blobData1 })
+		file.uploadControl().onProgress( cb )
+		await savePromise
+
+		expect( cb ).toHaveBeenCalledTimes( 2 )
+	})
+
+	describe( 'Streaming', ()=>{
+		let model: Model<Test>
+		let testObj: Test
+
+		beforeEach(()=>{
+			testObj = new Test()
+			model = Store.getModel<Test>( testObj )
+		})
+
+		it( 'should load object with StoredFile', async ()=>{
+			await testObj.file.save({ data: blobData1, fileName: 'test.dat' })
+			await model.save( testObj )
+
+			const newTestObj = await model.findById( testObj.id )
+
+			expect( newTestObj?.file ).toBeInstanceOf( StoredFile )
+			expect( newTestObj?.file.url ).toContain( testObj.file.id )
+		})
+
+		it( 'should replace file on save after load', async ()=>{
+			const deleteSpy = vi.spyOn( testObj.file, 'delete' )
+
+			await testObj.file.save({ data: blobData1, fileName: 'test.dat' })
+			await model.save( testObj )
+
+			const newTestObj = await model.findById( testObj.id )
+
+			expect( newTestObj?.file ).toBeInstanceOf( StoredFile )
+			expect( newTestObj?.file.url ).toContain( testObj.file.id )
+			expect( deleteSpy ).not.toHaveBeenCalled()
+
+			testObj.file.setDataToStore( blobData2 )
+			await testObj.file.save()
+
+			expect( deleteSpy ).toHaveBeenCalled()
+		})		
+
+	})
+
+})