entropic-bond 1.48.1 → 1.50.0

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

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

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

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

@@ -0,0 +1,83 @@
+import { Persistent, PersistentObject } from '../persistent/persistent'
+
+
+export type CloudFunction<P,R> = ( param?: P) => Promise<R>
+
+export interface CloudFunctionsService {
+	retrieveFunction<P, R>( cloudFunction: string ): CloudFunction<P, R>
+	callFunction<P,R>( func: CloudFunction<P, R>, params: P ): Promise<R>
+}
+
+export class CloudFunctions {
+	private constructor() {}
+
+	static error = { shouldBeRegistered: 'You should register a cloud functions service with useCloudFunctionsService static method before using CloudFunctions.' }
+
+	static useCloudFunctionsService( cloudFunctionsService: CloudFunctionsService ) {
+		if ( this._cloudFunctionsService != cloudFunctionsService ) {
+			this._cloudFunctionsService = cloudFunctionsService
+		}
+	}
+
+	static get instance() {
+		if ( !this._cloudFunctionsService ) throw new Error( CloudFunctions.error.shouldBeRegistered )
+		return CloudFunctions._instance || ( CloudFunctions._instance = new CloudFunctions() )
+	}
+
+	getRawFunction<P, R>( cloudFunction: string ): CloudFunction<P,R> {
+		return CloudFunctions._cloudFunctionsService.retrieveFunction( cloudFunction )
+	}
+
+	getFunction<P, R=void>( cloudFunction: string ): CloudFunction<P,R> {
+		const callFunction = CloudFunctions._cloudFunctionsService.callFunction
+		const func = this.getRawFunction<P, R>( cloudFunction )
+
+		return async ( param: P ) => {
+			const result = await callFunction( func, this.processParam( param ) )
+			return this.processResult( result )
+		}
+	}
+
+	private processParam<P>( param: P ): P | PersistentObject<P & Persistent> {
+		if ( param === undefined || param === null ) return undefined!
+
+		if ( param instanceof Persistent ) return param.toObject()
+
+		if ( Array.isArray( param ) ) {
+			return param.map( p => this.processParam( p ) ) as unknown as P
+		}
+
+		if ( typeof param === 'object' ) {
+			return Object.entries( param ).reduce(( newParam, [ key, value ])=>{
+				newParam[ key ] = this.processParam( value )
+				return newParam
+			}, {}) as P
+		}
+
+		return param
+	}
+
+	private processResult<R>( value: R | PersistentObject<R & Persistent> ): R {
+		if ( value === undefined || value === null ) return undefined!
+
+		if ( ( value as PersistentObject<R & Persistent> ).__className ) {
+			return Persistent.createInstance( value as PersistentObject<R & Persistent> ) as R
+		}
+
+		if ( Array.isArray( value ) ) {
+			return value.map( elem => this.processResult( elem ) ) as unknown as R
+		}
+
+		if ( typeof value === 'object' ) {
+			return Object.entries( value ).reduce((newVal, [ key, val ]) => {
+				newVal[ key ] = this.processResult( val )
+				return newVal
+			}, {}) as R
+		}
+
+		return value as R
+	}
+
+	private static _cloudFunctionsService: CloudFunctionsService
+	private static _instance: CloudFunctions
+}

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

@@ -0,0 +1,207 @@
+import { Persistent, persistent, registerPersistentClass } from '../persistent/persistent'
+import { JsonDataSource } from '../store/json-data-source'
+import { Model } from '../store/model'
+import { Store } from '../store/store'
+import { CloudStorage } from './cloud-storage'
+import { MockCloudStorage } from './mock-cloud-storage'
+import { StoredFile, StoredFileEvent } from './stored-file'
+
+function MockFile(this: any,  data: any[], filename: string ) {
+	this.data = data as any[]
+	this.name = filename
+}
+
+global.File = MockFile as any
+
+@registerPersistentClass( 'Test' )
+class Test extends Persistent {
+
+	get file(): StoredFile {
+		return this._file
+	}
+	
+	@persistent private _file: StoredFile = new StoredFile()
+}
+
+describe( 'Cloud Storage', ()=>{
+	let testObj: Test
+	let file: StoredFile
+	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]);
+	const fileData = new MockFile( [blobData1], 'pepe.dat' )
+
+	const mockCloudStorage = new MockCloudStorage( 'mock-data-folder/' )
+
+	beforeEach(()=>{
+		CloudStorage.useCloudStorage( mockCloudStorage )
+		testObj = new Test()
+		file = new StoredFile()
+	})
+
+	afterEach( ()=> mockCloudStorage.mockFileSystem = {} )
+
+	it( 'should save a file from Blob', async ()=>{
+		await file.save({ data: blobData1 })
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toBeDefined()		
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toEqual( JSON.stringify( blobData1 ) )		
+	})
+	
+	it( 'should save a file from File', async ()=>{
+		await file.save({ data: fileData })
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toBeDefined()		
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toEqual( JSON.stringify( {data:[blobData1], name: 'pepe.dat'} ) )		
+		expect( file.originalFileName ).toEqual( 'pepe.dat'  )
+		expect( file.url ).toEqual( 'mock-data-folder/pepe.dat' )
+	})
+	
+	it( 'should get a url', async ()=>{
+		await file.save({ data: blobData1 })
+
+		expect( file.url ).toEqual( 'mock-data-folder/' + 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( 'MockCloudStorage' )
+	})
+
+	it( 'should delete file', async ()=>{
+		await file.save({ data: blobData1 })
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toBeDefined()		
+
+		await file.delete()
+		expect( file.url ).toBeUndefined()
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).not.toBeDefined()		
+	})
+
+	it( 'should throw if not stored file', async ()=>{
+		let thrown = false
+		
+		try{
+			await file.delete()
+		}
+		catch {
+			thrown = true
+		}
+
+		expect( thrown ).toBeTruthy()
+	})
+	
+
+	it( 'should overwrite file on subsequent writes', async ()=>{
+		const deleteSpy = vi.spyOn( file, 'delete' )
+
+		await file.save({ data: 'first write' as any })
+		expect( deleteSpy ).not.toHaveBeenCalled()
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toEqual( '"first write"' )		
+
+		await file.save({ data: 'second write' as any })
+		expect( deleteSpy ).toHaveBeenCalled()
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toEqual( '"second write"' )		
+	})
+
+	it( 'should save from pending file', async ()=>{
+		file.setDataToStore( fileData )
+		await file.save()
+
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toBeDefined()		
+		expect( mockCloudStorage.mockFileSystem[ file.id ] ).toEqual( JSON.stringify( {data:[blobData1], name: 'pepe.dat'} ) )		
+	})
+
+	describe( 'Notify on change', ()=>{
+		let spy: vi.Mock
+
+		beforeEach(()=>{
+			spy = vi.fn()
+			file.onChange( spy )
+		})
+
+		afterEach( ()=>	spy.mockClear() )
+
+		it( 'should notify on seting pendind data to store', ()=>{
+			file.setDataToStore( fileData )
+			expect( spy ).toHaveBeenNthCalledWith( 1, { 
+				event: StoredFileEvent.pendingDataSet,
+				pendingData: fileData,
+				storedFile: file 
+			})
+		})
+
+		it( 'should notify on data store', async ()=>{
+			await file.save( fileData )
+			expect( spy ).toHaveBeenNthCalledWith( 1, { 
+				event: StoredFileEvent.stored,
+				storedFile: file 
+			})
+		})
+
+		it( 'should notify on delete', async ()=>{
+			await file.save( fileData )
+			spy.mockClear()
+
+			await file.delete()
+			expect( spy ).toHaveBeenNthCalledWith( 1, { 
+				event: StoredFileEvent.deleted,
+				storedFile: file 
+			})
+		})
+	})	
+
+	describe( 'Streaming', ()=>{
+		const database = {}
+		let model: Model<Test>
+		let testObj: Test
+
+		beforeEach(()=>{
+			Store.useDataSource( new JsonDataSource( database ) )
+			testObj = new Test()
+			model = Store.getModel<Test>( testObj )
+		})
+
+		it( 'should save object with StoredFile', async ()=>{
+			await testObj.file.save({ data: blobData1, fileName: 'test.dat' })
+			await model.save( testObj )
+
+			expect( database[ testObj.className ][ testObj.id ].file ).toBeDefined()
+			expect( database[ testObj.className ][ testObj.id ].file.reference ).toEqual( testObj.file.id )
+			expect( database[ testObj.className ][ testObj.id ].file.url ).toEqual( 'mock-data-folder/' + testObj.file.id )
+			expect( database[ testObj.className ][ testObj.id ].file.cloudStorageProviderName ).toEqual( 'MockCloudStorage' )
+			expect( database[ testObj.className ][ testObj.id ].file.originalFileName ).toEqual( 'test.dat' )
+		})
+
+		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 ).toEqual( 'mock-data-folder/' + 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 ).toEqual( 'mock-data-folder/' + testObj.file.id )
+			expect( deleteSpy ).not.toHaveBeenCalled()
+
+			testObj.file.setDataToStore( blobData2 )
+			await testObj.file.save()
+
+			expect( 
+				mockCloudStorage.mockFileSystem[ testObj.file.id ] 
+			).toEqual( JSON.stringify( blobData2 ) )
+
+			expect( deleteSpy ).toHaveBeenCalled()
+		})		
+
+	})
+})

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

@@ -0,0 +1,60 @@
+export type UploadProgress = ( uploadedBytes: number, fileSize: number ) => void
+
+type CloudStorageFactory = ()=>CloudStorage
+
+interface CloudStorageFactoryMap { 
+	[ cloudStorageProviderName: string ] : CloudStorageFactory 
+}
+
+export interface UploadControl {
+	pause: ()=>void
+	resume: ()=>void
+	cancel: ()=>void
+	onProgress: ( callback: UploadProgress )=>void
+}
+
+export type StorableData = File | Blob | Uint8Array | ArrayBuffer
+
+export abstract class CloudStorage {
+	abstract save( id: string, data: StorableData, progress?: UploadProgress ): Promise<string>
+	abstract getUrl( reference: string ): Promise<string>
+	abstract uploadControl(): UploadControl
+	abstract delete( reference: string ): Promise<void>
+
+	static registerCloudStorage( cloudStorageProviderName: string, factory: CloudStorageFactory ) {
+		CloudStorage._cloudStorageFactoryMap[ cloudStorageProviderName ] = factory
+	}
+
+	static createInstance( providerName: string ) {
+		const provider = CloudStorage._cloudStorageFactoryMap[ providerName ]
+		if ( !provider ) {
+			throw new Error( `You should register the ${ providerName } cloud storage provider prior to use it`)
+		}
+
+		return provider()
+	}
+
+	get className(): string {
+		return this[ '__className' ];
+	}
+
+	static useCloudStorage( provider: CloudStorage ) {
+		CloudStorage._defaultCloudStorage = provider
+	}
+
+	static get defaultCloudStorage() {
+		if ( !CloudStorage._defaultCloudStorage ) {
+			throw new Error( 'You should define a default cloud storage provider prior to use it')
+		}
+		return CloudStorage._defaultCloudStorage
+	}
+	static _defaultCloudStorage: CloudStorage
+	private static _cloudStorageFactoryMap: CloudStorageFactoryMap = {}
+}
+
+export function registerCloudStorage( cloudStorageProviderName: string, factory: CloudStorageFactory ) {
+	CloudStorage.registerCloudStorage( cloudStorageProviderName, factory )
+	return ( constructor: Function ) => {
+		constructor.prototype.__className = cloudStorageProviderName
+	}
+}

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

@@ -0,0 +1,72 @@
+import { CloudStorage, registerCloudStorage, StorableData, UploadControl, UploadProgress } from './cloud-storage'
+
+@registerCloudStorage( 'MockCloudStorage', ()=>new MockCloudStorage() )
+export class MockCloudStorage extends CloudStorage {
+	constructor( pathToMockFiles: string = '' ) {
+		super()
+		this._pathToMockFiles = pathToMockFiles
+	}
+
+	/**
+	 * Introduce a delay in the execution of operations to simulate a real data source
+	 * @param miliSeconds the number of milliseconds to delay the execution of operations
+	 * @returns a chainable reference to this object
+	 */
+	simulateDelay( miliSeconds: number ) {
+		this._simulateDelay = miliSeconds
+		return this
+	}
+
+	private resolveWithDelay<T>( data?: T ): Promise<T> {
+		if ( this._simulateDelay <= 0 ) return Promise.resolve( data! )
+
+		const promise = new Promise<T>( resolve => {
+			setTimeout(
+				()=> resolve( data! ),
+				this._simulateDelay
+			)
+		})
+		this._pendingPromises.push( promise )
+		promise.finally(
+			()=> this._pendingPromises = this._pendingPromises.filter( p => p === promise )
+		)
+		return promise
+	}
+
+	save( id: string, data: StorableData ): Promise<string> {
+		const fullPath = id
+
+		if ( this._onProgress ) this._onProgress( 0, 100 )
+
+		this.mockFileSystem[ id ] = JSON.stringify( data ) 
+
+		if ( this._onProgress ) this._onProgress( 100, 100 )
+
+		const ref = data instanceof File? data.name : fullPath
+		return this.resolveWithDelay( ref )
+	}
+
+	uploadControl(): UploadControl {
+		return {
+			resume: ()=>{},
+			pause: ()=>{},
+			cancel: ()=>{},
+			onProgress: callback => this._onProgress = callback
+		}
+	}
+
+	getUrl( reference: string ): Promise<string> {
+		return Promise.resolve( this._pathToMockFiles + reference )
+	}
+
+	delete( reference: string ) {
+		delete this.mockFileSystem[ reference ]
+		return this.resolveWithDelay<void>()
+	}
+
+	private _simulateDelay: number = 0
+	private _pendingPromises: Promise<any>[] = []
+	private _onProgress: UploadProgress | undefined
+	private _pathToMockFiles: string
+	public mockFileSystem = {}
+}

package/src/cloud-storage/stored-file.ts

@@ -0,0 +1,102 @@
+import { Callback, Observable } from '../observable/observable'
+import { persistent, Persistent, registerPersistentClass } from '../persistent/persistent'
+import { CloudStorage, StorableData, UploadControl, UploadProgress } from './cloud-storage'
+
+export enum  StoredFileEvent { stored, pendingDataSet, deleted }
+export interface StoredFileChange {
+	event: StoredFileEvent
+	pendingData?: StorableData
+	storedFile: StoredFile
+}
+
+export interface StoreParams {
+	data?: StorableData, 
+	fileName?: string, 
+	progress?: UploadProgress, 
+	cloudStorageProvider?: CloudStorage 
+}
+
+@registerPersistentClass( 'StoredFile' )
+export class StoredFile extends Persistent{
+
+	async save({ data, fileName, progress, cloudStorageProvider }: StoreParams = {}): Promise<void> {
+		const dataToStore = data || this._pendingData
+		if ( !dataToStore ) return
+		if ( this._reference ) await this.delete()
+
+		this.provider = cloudStorageProvider || CloudStorage.defaultCloudStorage
+		this._originalFileName = fileName || ( dataToStore instanceof File? dataToStore.name : undefined )
+
+		this._reference = await this.provider.save( this.id, dataToStore, progress )
+		this._url = await this.provider.getUrl( this._reference )
+
+		this._pendingData = undefined
+		this._onChange.notify({ event: StoredFileEvent.stored, storedFile: this })
+	}
+
+	uploadControl(): UploadControl {
+		return this.provider.uploadControl()
+	}
+
+	async delete(): Promise<void> {
+		if ( !this._reference ) throw new Error( 'Cannot delete a not stored file' )
+		await this.provider.delete( this._reference )
+		this._reference = undefined
+		this._url = undefined
+		this._onChange.notify({ event: StoredFileEvent.deleted, storedFile: this })
+	}
+
+	set provider( value: CloudStorage ) {
+		this._provider = value
+		this._cloudStorageProviderName = value.className
+	}
+
+	get provider() {
+		if ( !this._provider ) {
+			try {
+				this._provider = CloudStorage.createInstance( this._cloudStorageProviderName! )
+			} 
+			catch {
+				this._provider = CloudStorage.defaultCloudStorage
+			}
+ 		}
+		return this._provider
+	}
+
+	get url() {
+		return this._url
+	}
+
+	get mimeType() {
+		return this._mimeType
+	}
+
+	setDataToStore( data: StorableData ) {
+		this._pendingData = data
+		this._originalFileName = data instanceof File? data.name : undefined
+		this._mimeType = data instanceof Blob? data.type : undefined
+		this._onChange.notify({ 
+			event: StoredFileEvent.pendingDataSet, 
+			pendingData: data,
+			storedFile: this 
+		})
+		return this
+	}
+
+	get originalFileName() {
+		return this._originalFileName
+	}
+
+	onChange( listenerCallback: Callback<StoredFileChange> ) {
+		return this._onChange.subscribe( listenerCallback )
+	}
+
+	@persistent private _reference: string | undefined
+	@persistent private _url: string | undefined
+	@persistent private _cloudStorageProviderName: string | undefined
+	@persistent private _originalFileName: string | undefined
+	@persistent private _mimeType: string | undefined
+	private _provider: CloudStorage | undefined
+	private _pendingData: StorableData | undefined
+	private _onChange: Observable<StoredFileChange> = new Observable<StoredFileChange>()
+}