entropic-bond 1.48.1 → 1.50.0

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "entropic-bond",
-  "version": "1.48.1",
+  "type": "module",
+  "version": "1.50.0",
+  "description": "Tidy up your messy components",
+  "main": "./lib/entropic-bond.umd.cjs",
+  "module": "./lib/entropic-bond.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/entropic-bond.umd.cjs"
+    }
+  },
   "publishConfig": {
     "access": "public",
     "branches": [
@@ -16,19 +27,10 @@
       "@semantic-release/github"
     ]
   },
-  "description": "Tidy up your messy components",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib"
-  ],
   "scripts": {
     "test": "vitest",
-    "build": "npm run build-cjs",
-    "prepare": "npm run build",
-    "build-ts": "cp -r ./src/ ./lib",
-    "build-cjs": "tsc -p tsconfig-cjs.json",
-    "build-next": "tsc -p tsconfig.json"
+    "build": "tsc -p tsconfig-build.json && vite build",
+    "prepare": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -50,14 +52,16 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@type-challenges/utils": "^0.1.1",
-    "@types/uuid": "^9.0.6",
+    "@types/node": "^20.11.16",
+    "@types/uuid": "^9.0.8",
     "git-branch-is": "^4.0.0",
-    "husky": "^8.0.3",
-    "semantic-release": "^22.0.5",
-    "typedoc": "^0.25.2",
-    "typedoc-plugin-markdown": "^3.16.0",
-    "typescript": "^5.2.2",
-    "vitest": "^0.34.6"
+    "husky": "^9.0.10",
+    "semantic-release": "^23.0.0",
+    "typedoc": "^0.25.7",
+    "typedoc-plugin-markdown": "^3.17.1",
+    "typescript": "^5.3.3",
+    "vite-plugin-dts": "^3.7.2",
+    "vitest": "^1.2.2"
   },
   "dependencies": {
     "uuid": "^9.0.1"

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

@@ -0,0 +1,168 @@
+import { Auth } from './auth'
+import { AuthMock } from './auth-mock'
+import { UserCredentials } from './user-auth-types'
+
+interface CustomCredentials {
+	role: string
+	customer: string
+}
+
+describe( 'Auth Mock', ()=>{
+	let authChangeSpy = vi.fn()
+	let mockAuthService: AuthMock
+	const fakeUseCredentials = {
+		email: 'fakeUser@test.com',
+		emailVerified: true,
+		creationDate: new Date( '2017-01-01' ).getDate(),
+		lastLogin: new Date( '2017-01-03' ).getDate(),
+		customData: {
+			role: 'testRole',
+			customer: 'testCustomer'
+		},
+		id: 'fakeUser',
+	} as UserCredentials<CustomCredentials>
+
+	beforeEach(()=>{
+		Auth.useAuthService( mockAuthService = new AuthMock() )
+		Auth.instance.onAuthStateChange( authChangeSpy ) 
+
+		mockAuthService.fakeRegisteredUser( fakeUseCredentials )
+
+	})
+
+	it( 'should throw if AuthService not set', ()=>{
+		Auth.useAuthService( undefined! )
+		expect(
+			()=>Auth.instance
+		).toThrow( Auth.error.shouldBeRegistered )
+	})
+	
+
+	it( 'should emulate sign-up', async ()=>{
+		const userCredentials = await Auth.instance.signUp({
+			authProvider: 'google',
+			email: 'test@test.com',
+			password: 'password'
+		})
+
+		expect( userCredentials.email ).toEqual( 'test@test.com' )
+		expect( authChangeSpy ).toHaveBeenCalledWith( userCredentials )
+	})
+
+	it( 'should emulate failed sign-up', async ()=>{
+		try {
+			var userCredentials = await Auth.instance.signUp({
+				authProvider: 'email',
+				email: 'test@test.com',
+				password: 'fail'
+			})
+		}
+		catch {}
+
+		expect( userCredentials! ).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'
+		})
+
+		const modUserCredentials = { 
+			...fakeUseCredentials, 
+			id: fakeUseCredentials.id
+		}
+
+		expect( userCredentials ).toEqual( modUserCredentials )
+		expect( authChangeSpy ).toHaveBeenCalledWith( modUserCredentials )
+	})
+
+	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 )
+	})
+	
+	it( 'should throw if email does not exists in resetEmailPassword', async ()=>{
+		return expect(
+			Auth.instance.resetEmailPassword( 'non-existing-email@test.com' )
+		).rejects.toEqual( expect.objectContaining({ code: 'userNotFound' }) )
+	})
+
+	it( 'should retrieve custom credentials', async ()=>{
+		const userCredentials = await Auth.instance.login<CustomCredentials>({
+			email: 'fakeUser@test.com',
+			password: 'password',
+			authProvider: 'google'
+		})
+
+		expect( userCredentials.customData?.role ).toEqual( 'testRole' )
+	})
+
+	it( 'should throw if login and not email in email auth provider', ()=>{
+		return expect(
+			Auth.instance.login({
+				authProvider: 'email',
+				email: '',
+				password: '****'
+			})
+		).rejects.toEqual( expect.objectContaining({ code: 'missingEmail' }))
+	})
+	
+	it( 'should throw if login and not password in email auth provider', ()=>{
+		return expect(
+			Auth.instance.login({
+				authProvider: 'email',
+				email: 'test@test.com',
+				password: ''
+			})
+		).rejects.toEqual( expect.objectContaining({ code: 'missingPassword' }))
+	})
+	
+	it( 'should throw if signup and not email in email auth provider', ()=>{
+		return expect(
+			Auth.instance.signUp({
+				authProvider: 'email',
+				email: '',
+				password: '****'
+			})
+		).rejects.toEqual( expect.objectContaining({ code: 'missingEmail' }))
+	})
+	
+	it( 'should throw if signup and not password in email auth provider', ()=>{
+		return expect(
+			Auth.instance.signUp({
+				authProvider: 'email',
+				email: 'test@test.com',
+				password: ''
+			})
+		).rejects.toEqual( expect.objectContaining({ code: 'missingPassword' }))
+	})
+	
+})

package/src/auth/auth-mock.ts

@@ -0,0 +1,129 @@
+import { Collection } from '../types/utility-types'
+import { AuthService, RejectedCallback, ResovedCallback } from "./auth"
+import { UserCredentials, SignData, AuthProvider } from "./user-auth-types"
+
+export class AuthMock extends AuthService {
+
+	signUp<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
+		const { verificationLink, email, password, authProvider } = signData
+	
+		const promise = new Promise<UserCredentials<T>>( async ( resolve: ResovedCallback<T>, reject: RejectedCallback ) => {
+			if ( authProvider === 'email' ) {
+				if ( !email ) reject({ code: 'missingEmail', message: 'missingEmail' })
+				if ( !password ) reject({ code: 'missingPassword', message: 'missingPassword' })
+			}
+			if ( password !== 'fail' && email !== 'fail' ) {
+				this._loggedUser = this.userCredentials<T>( signData )
+				this._fakeRegisteredUsers[ this._loggedUser.id ] = this._loggedUser 
+				resolve( this._loggedUser as UserCredentials<T> )
+				this.notifyChange?.( this._loggedUser )
+			} 
+			else {
+				reject({ code: 'userNotFound', message: verificationLink || 'Test auth error' })
+				this.notifyChange?.( undefined )
+			}
+		})
+		this.pendingPromises.push( promise )
+		return promise
+	}
+
+	login<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
+		const fakeUser = Object.values( this._fakeRegisteredUsers ).find( 
+			user => user.email === signData.email 
+		)
+
+		if ( signData.authProvider === 'email' && !fakeUser && signData.email) {
+			signData.email = 'fail'
+		}
+
+		return this.signUp( signData )
+	}
+
+	onAuthStateChange<T extends {}>( onChange: ( userCredentials: UserCredentials<T> )=>void ) {
+		this.notifyChange = onChange
+		this.notifyChange( this._loggedUser )
+	}
+
+	async logout(): Promise<void> {
+		const promise = new Promise<void>( resolve => {
+			this._loggedUser = undefined
+			resolve() 
+			this.notifyChange?.( undefined )
+		})
+		this.pendingPromises.push( promise )
+		return promise
+	}
+
+	resetEmailPassword( email: string ) {
+		const fakeUserExists = Object.values( this._fakeRegisteredUsers ).find( 
+			user => user.email === email 
+		)
+
+		if ( fakeUserExists ) return Promise.resolve()
+		else return Promise.reject({ code: 'userNotFound', message: 'Test auth error' })
+	}
+
+	resendVerificationEmail( email: string, _password: string, _verificationLink: string ) {
+		const fakeUserExists = Object.values( this._fakeRegisteredUsers ).find( 
+			user => user.email === email 
+		)
+
+		if ( fakeUserExists ) return Promise.resolve()
+		else return Promise.reject({ code: 'userNotFound', message: 'Test auth error' })
+	}
+
+	override refreshToken(): Promise<void> {
+		return Promise.resolve()
+	}
+
+	linkAdditionalProvider( provider: AuthProvider ): Promise<unknown> {
+		throw new Error('Not implemented.')
+	}
+	
+	unlinkProvider( provider: AuthProvider ): Promise<unknown> {
+		throw new Error('Not implemented.')
+	}
+	
+	async flush() {
+		await Promise.all(this.pendingPromises)
+    this.pendingPromises = []
+	}
+
+	fakeRegisteredUser<T extends {}>( userCredentials: UserCredentials<T> ) {
+		if ( this._fakeRegisteredUsers[ userCredentials.id ] ) throw new Error( `User with id ${ userCredentials.id } already exists in fake user list`)
+		this._fakeRegisteredUsers[ userCredentials.id ] = userCredentials
+		return this
+	}
+
+	get fakeRegisteredUsers() {
+		return this._fakeRegisteredUsers
+	}
+
+	private userCredentials<T extends {}>( signData: SignData ): UserCredentials<T> {
+		const fakeUser = Object.values( this._fakeRegisteredUsers ).find( 
+			user => user.email === signData.email 
+		)
+		
+		if ( fakeUser ) {
+			return { ...fakeUser as UserCredentials<T> }
+		}
+		else {
+			return ({
+				id: signData.authProvider || `testUID${ signData.email? '-' + signData.email : '' }`,
+				email: signData.email || 'testEmail',
+				name: signData.authProvider || `testName${ signData.email? ' ' + signData.email : '' }` ,
+				phoneNumber: 'testPhone',
+				customData: {
+					role: 'test'
+				} as unknown as T,
+				lastLogin: 0,
+				creationDate: 0
+			} as UserCredentials<T>)
+		}
+	}
+
+	private pendingPromises: Promise<any>[] = []
+	private _loggedUser: UserCredentials<{}> | undefined
+	private notifyChange: (( userCredentials: UserCredentials<{}> | undefined ) => void ) | undefined
+	private _fakeRegisteredUsers: Collection<UserCredentials<{}>> = {}
+}

package/src/auth/auth.ts

@@ -0,0 +1,185 @@
+import { Observable } from '../observable/observable'
+import { AuthProvider, SignData, UserCredentials } from "./user-auth-types"
+
+/**
+ * The AuthService class is an abstract class that defines the interface of an authentication service.
+ * You should derive from this class to implement your own authentication service.
+ */
+export abstract class AuthService {
+	abstract signUp<T extends {}>( signData: SignData ): Promise<UserCredentials<T>>
+	abstract login<T extends {}>( signData: SignData ): Promise<UserCredentials<T>>
+	abstract logout(): Promise<void>
+	abstract resetEmailPassword( email: string ): Promise<void>
+	abstract refreshToken(): Promise<void>
+	abstract linkAdditionalProvider( provider: AuthProvider ): Promise<unknown>
+	abstract unlinkProvider( provider: AuthProvider ): Promise<unknown>
+	abstract onAuthStateChange<T extends {}>( onChange: (userCredentials: UserCredentials<T> | undefined) => void ): void
+	abstract resendVerificationEmail( email: string, password: string, verificationLink: string ): Promise<void>
+}
+
+export type AuthErrorCode = 'wrongPassword' | 'popupClosedByUser' | 'userNotFound' | 'invalidEmail' | 'missingPassword' | 'missingEmail'
+
+export interface AuthError {
+	code: AuthErrorCode
+	message: string
+}
+
+/**
+ * Types the callback to accept a user credentials object
+ */
+export type ResovedCallback<T extends {}> = ( credentials: UserCredentials<T> ) => void
+export type RejectedCallback = ( reason: AuthError ) => void
+
+/**
+ * The Auth class is a singleton that provides a unified interface to the authentication service.
+ * You should register an authentication service by using `Auth.useAuthService` 
+ * method before using the Auth class.
+ */
+export class Auth extends AuthService {
+	static error = { shouldBeRegistered: 'You should register an auth service before using Auth.' }
+
+	protected constructor() {
+		super()
+		if (!Auth._authService ) throw ( new Error( Auth.error.shouldBeRegistered ) )
+		Auth._authService.onAuthStateChange( 
+			userCredentials => this.authStateChanged( userCredentials ) 
+		)
+	}
+
+	/**
+	 * Registers an authentication service to be used by the Auth class.
+	 * You need to register an authentication service before using the Auth class.
+	 * @param authService the authentication service to be used by the Auth class
+	 */
+	static useAuthService( authService: AuthService ) {
+		if ( Auth._authService != authService ) {
+			Auth._authService = authService
+			this._instance = undefined
+		}
+	}
+
+	/**
+	 * The instance of the Auth class
+	 * @returns the authentication service
+	 */
+	static get instance() {
+		return this._instance || (this._instance = new this() )
+	}
+
+	/**
+	 * Signs up a new user
+	 * @param singData the data to be used to sign up the user
+	 * @returns a promise that resolves to the user credentials
+	 * @example
+	 * // Sign up a new user with email and password
+	 * Auth.instance.signUp({ authProvider: 'email', email: 'john@test.com', password: '123456' })
+	 * // Sign up a new user with a Google account
+	 * Auth.instance.signUp({ authProvider: 'google'})
+	 */
+	signUp<T extends {}>( singData: SignData ): Promise<UserCredentials<T>> {
+		return Auth._authService.signUp( singData )
+	}
+
+	/**
+	 * Logs in an existing user
+	 * @param singData the data to be used to log in the user
+	 * @returns a promise that resolves to the user credentials
+	 * @example
+	 * // Log in an existing user with email and password
+	 * Auth.instance.login({ authProvider: 'email', email: 'john@test.com', password: '123456' })
+	 * // Log in an existing user with a Google account
+	 * Auth.instance.login({ authProvider: 'google'})
+	 */
+	login<T extends {}>( singData: SignData ): Promise<UserCredentials<T>> {
+		return Auth._authService.login( singData )
+	}
+	
+	/**
+	 * Logs out the current user
+	 * @returns a promise that resolves when the user is logged out
+	 */
+	logout(): Promise<void> {
+		return Auth._authService.logout()
+	}
+
+	/**
+	 * Resets the password associated with the email.
+	 * @param email the email address of the user to reset the password
+	 * @returns a promise that resolves when the process is done
+	 */
+	resetEmailPassword( email: string ) {
+		return Auth._authService.resetEmailPassword( email )
+	}
+
+	/**
+	 * Resends the email verification to the user.
+	 * @returns a promise that resolves when the process is done
+	 */
+	override resendVerificationEmail( email: string, password: string, verificationLink: string ): Promise<void> {
+		return Auth._authService.resendVerificationEmail( email, password, verificationLink )
+	}
+
+	override refreshToken(): Promise<void> {
+		return Auth._authService.refreshToken()
+	}
+
+	/**
+	 * Adds a listener to be called when the authentication state changes.
+	 * @param onChange the listener to be called when the authentication state changes.
+	 * The listener is called with the user credentials as a parameter.
+	 * If the user is logged out, the listener is called with `undefined` as a parameter.
+	 * @returns a function to remove the listener
+	 * @example
+	 * // Add a listener to be called when the authentication state changes
+	 * const removeListener = Auth.instance.onAuthStateChange( userCredentials => {
+	 * 	if ( userCredentials ) {
+	 * 		// The user is logged in
+	 * 	} else {
+	 * 		// The user is logged out
+	 * 	}
+	 * })
+	 */
+	onAuthStateChange<T extends {}>( onChange: ( userCredentials: UserCredentials<T> )=>void ) {
+		return this._onAuthStateChange.subscribe( onChange )
+	}
+
+	/**
+	 * Removes a listener that was added by `onAuthStateChange` method.
+	 * @param onChange the listener to be removed
+	 */
+	removeAuthStateChange<T extends {}>( onChange: ( userCredentials: UserCredentials<T> )=>void ) {
+		this._onAuthStateChange.unsubscribe( onChange )
+	}
+
+	/**
+	 * Links an additional authentication provider to the authenticated user.
+	 * @param provider the provider to be linked
+	 * @returns a promise that resolves when the process is done
+	 * @example
+	 * // Link a Google account to the auth service
+	 * Auth.instance.linkAdditionalProvider({ authProvider: 'google' })
+	 */
+	linkAdditionalProvider( provider: AuthProvider ): Promise<unknown> {
+		return Auth._authService.linkAdditionalProvider( provider )
+	}
+
+	/**
+	 * Unlinks an authentication provider from the authenticated user.
+	 * @param provider the provider to be unlinked
+	 * @returns a promise that resolves when the process is done
+	 * @example
+	 * // Unlink the Google account from the auth service
+	 * Auth.instance.unlinkProvider({ authProvider: 'google' })
+	 */
+	unlinkProvider( provider: AuthProvider ): Promise<unknown> {
+		return Auth._authService.unlinkProvider( provider )
+	}
+
+	private authStateChanged( userCredentials: UserCredentials<{}> | undefined ) {
+		this._onAuthStateChange.notify( userCredentials )
+	}
+
+	private static _instance: Auth | undefined = undefined
+	private static _authService: AuthService
+	private _onAuthStateChange: Observable<UserCredentials<{}>> = new Observable<UserCredentials<{}>>()
+}

package/src/auth/user-auth-types.ts

@@ -0,0 +1,21 @@
+export interface UserCredentials<T extends {} = {}> {
+	id: string
+	email: string
+	name?: string
+	pictureUrl?: string
+	phoneNumber?: string
+	emailVerified?: boolean
+	customData?: T
+	lastLogin?: number
+	creationDate?: number
+}
+
+export type AuthProvider = 'email' | 'facebook' | 'google' | 'twitter'
+
+export interface SignData {
+	authProvider: AuthProvider
+	email?: string
+	password?: string
+	name?: string
+	verificationLink?: string
+}