entropic-bond 1.50.0 → 1.50.2

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

@@ -1,168 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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
-}

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

@@ -1,136 +0,0 @@
-import { PersistentObject } from '../persistent/persistent'
-import { TestUser } from '../store/mocks/test-user'
-import { CloudFunctions } from './cloud-functions'
-import { CloudFunctionsMock } from './cloud-functions-mock'
-
-describe( 'Cloud functions', ()=>{
-
-	beforeEach(()=>{
-		CloudFunctions.useCloudFunctionsService( new CloudFunctionsMock({
-			testNoParam: ():Promise<string> => Promise.resolve( 'test' ),
-			testArbitraryParamAndReturn: ( data: any ): Promise<any> => Promise.resolve( data.length ),
-			testPersistentParamAndReturn: ( data: PersistentObject<TestUser> ): Promise<PersistentObject<TestUser>> => {
-				return Promise.resolve( JSON.parse( JSON.stringify( data ) ) )
-			},
-			testPersistentParamAndPlainReturn: ( data: PersistentObject<TestUser> ): Promise<number> => {
-				return Promise.resolve( data.age! )
-			},
-			testPlainParamAndPersistentReturn: ( data: number ): Promise<PersistentObject<TestUser>> => {
-				const user = new TestUser()
-				user.age = data
-				return Promise.resolve( user.toObject() )
-			},
-			testWithoutParam: (): Promise<string> => Promise.resolve( 'Hello from the other side' ),
-			testWithoutReturn: ( _data: string ): Promise<void> => Promise.resolve(),
-			testArrayParam: ( data: PersistentObject<TestUser>[] ) => Promise.resolve( data.map( d => d.id ) ),
-			testObjectParam: ( data: {[key:string]:PersistentObject<TestUser>} ) => Promise.resolve( 
-				Object.entries( data ).reduce(( obj, [k,v] ) => {
-					obj[k] = v.id
-					return obj 
-				}, {}) 
-			),
-			testArrayResult: () => Promise.resolve([ new TestUser('userA').toObject(), new TestUser('userB').toObject() ]),
-			testObjectResult: () => Promise.resolve({ user1: new TestUser('userA').toObject(), user2: new TestUser('userB').toObject() })
-		}))
-
-	})
-
-	it( 'should execute cloud function without params', async ()=>{
-		const testNoParam = CloudFunctions.instance.getRawFunction<never, string>( 'testNoParam' )
-		const result = await testNoParam()
-		expect( result ).toEqual( 'test' )
-	})
-
-	it( 'should execute cloud function with params', async ()=>{
-		const testArbitraryParamAndReturn = CloudFunctions.instance.getFunction<string, number>( 'testArbitraryParamAndReturn' )
-
-		const result = await testArbitraryParamAndReturn( 'Hello' )
-		expect( result ).toEqual( 5 )
-	})
-
-	it( 'should execute cloud function without params', async ()=>{
-		const testWithoutReturn = CloudFunctions.instance.getFunction<string>( 'testWithoutReturn' )
-
-		expect( testWithoutReturn( '' ) ).resolves.toBeUndefined()
-	})
-
-	it( 'should execute cloud function with void return', async ()=>{
-		const testWithoutParam = CloudFunctions.instance.getFunction<string>( 'testWithoutParam' )
-
-		const result = await testWithoutParam()
-		expect( result ).toEqual( 'Hello from the other side' )
-	})
-
-	it( 'should execute cloud function with params and return as Persistent', async ()=>{
-		const testPersistentParamAndReturn = CloudFunctions.instance.getFunction<TestUser, TestUser>( 'testPersistentParamAndReturn' )
-
-		const user = new TestUser()
-		user.age = 35
-		user.name = { firstName: 'Test User', lastName: 'as a user', ancestorName: {} }
-
-		const result = await testPersistentParamAndReturn( user )
-		expect( result.age ).toBe( 35 )
-		expect( result.name ).toEqual({ firstName: 'Test User', lastName: 'as a user', ancestorName: {} })
-	})
-
-	it( 'should execute cloud function with params as Persistent and return as plain', async ()=>{
-		const testPersistentParamAndPlainReturn = CloudFunctions.instance.getFunction<TestUser, number>( 'testPersistentParamAndPlainReturn' )
-
-		const user = new TestUser()
-		user.age = 35
-
-		const result = await testPersistentParamAndPlainReturn( user )
-		expect( result ).toBe( 35 )
-	})
-
-	it( 'should execute cloud function with params as plain and return as Persistent', async ()=>{
-		const testPlainParamAndPersistentReturn = CloudFunctions.instance.getFunction<number, TestUser>( 'testPlainParamAndPersistentReturn' )
-
-		const result = await testPlainParamAndPersistentReturn( 35 )
-		expect( result.age ).toEqual( 35 )
-	})
-
-	it( 'should execute cloud function with params as an array of Persistents', async ()=>{
-		const testArrayParam = CloudFunctions.instance.getFunction<TestUser[], string[]>( 'testArrayParam' )
-
-		const result = await testArrayParam([
-			new TestUser('userA'),
-			new TestUser('userB')
-		])
-
-		expect( result ).toEqual([ 'userA', 'userB' ])
-	})
-
-	it( 'should execute cloud functions that return array of Persistent', async ()=>{
-		const testArrayResult = CloudFunctions.instance.getFunction<void, TestUser[]>( 'testArrayResult' )
-
-		const result = await testArrayResult()
-
-		expect( result[0] ).toBeInstanceOf( TestUser )
-		expect( result[0]?.id ).toEqual( 'userA' )
-		expect( result[1]?.id ).toEqual( 'userB' )
-	})
-	
-	it( 'should execute cloud function with params as an object containing Persistents', async ()=>{
-		const testObjectParam = CloudFunctions.instance.getFunction<{[key: string]:TestUser}, {[key: string]:string}>( 'testObjectParam' )
-
-		const result = await testObjectParam({
-			user1: new TestUser('userA'),
-			user2: new TestUser('userB')
-	})
-
-		expect( result ).toEqual({ user1: 'userA', user2: 'userB' })
-	})
-
-	it( 'should execute cloud functions that return an object with Persistent', async ()=>{
-		const testObjectResult = CloudFunctions.instance.getFunction<void, {[key: string]:TestUser}>( 'testObjectResult' )
-
-		const result = await testObjectResult()
-
-		expect( result.user1 ).toBeInstanceOf( TestUser )
-		expect( result.user1?.id ).toEqual( 'userA' )
-		expect( result.user2?.id ).toEqual( 'userB' )
-	})
-	
-	
-})

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

@@ -1,23 +0,0 @@
-import { CloudFunction, CloudFunctionsService } from './cloud-functions'
-
-interface FunctionCollection { 
-	[key: string]: CloudFunction<any,any>
-}
-
-export class CloudFunctionsMock implements CloudFunctionsService {
-	constructor( registeredFunctions: FunctionCollection ) {
-		this._registeredFunctions = registeredFunctions
-	}
-
-	retrieveFunction<P, R>( cloudFunction: string ): CloudFunction<P,R> {
-		const func = this._registeredFunctions[ cloudFunction ]
-		if ( !func ) throw new Error( `Cloud function ${ cloudFunction } is not registered.` )
-		return func
-	}
-
-	callFunction<P, R>( func: CloudFunction<P, R>, params: P ): Promise<R> {
-		return func( params )
-	}
-
-	private _registeredFunctions: FunctionCollection
-}