entropic-bond 1.50.0 → 1.50.2

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

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

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

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

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

@@ -1,102 +0,0 @@
-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>()
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-export * from './observable/observable'
-export * from './persistent/entropic-component'
-export * from './persistent/persistent'
-export * from './store/data-source'
-export * from './store/json-data-source'
-export * from './store/store'
-export * from './store/model'
-export * from './types/utility-types'
-export * from './cloud-storage/cloud-storage'
-export * from './cloud-storage/mock-cloud-storage'
-export * from './cloud-storage/stored-file'
-export * from './auth/auth'
-export * from './auth/user-auth-types'
-export * from './auth/auth-mock'
-export * from './cloud-functions/cloud-functions'
-export * from './cloud-functions/cloud-functions-mock'
-export * from './server-auth/server-auth'
-export * from './server-auth/server-auth-mock'
-export * from './utils/utils'

package/src/observable/observable.spec.ts

@@ -1,105 +0,0 @@
-import {Observable} from './observable'
-
-class ObserverTest {
-	public changed: boolean = true
-	userChanged() {
-		this.changed = true
-	}
-}
-
-interface MockEvent {
-	[ idx: string ]: any
-}
-
-describe('observer', () => {
-	let observable: Observable<MockEvent | void>
-
-	beforeEach(()=>{
-		observable = new Observable<MockEvent | void>()
-	})
-
-	it('should subscribe ', () => {
-		const mockObserver = new ObserverTest();
-		const changedSpy = vi.spyOn( mockObserver, 'userChanged' )
-		
-		observable.subscribe( ()=>mockObserver.userChanged() )
-		observable.notify()
-		
-		expect( changedSpy ).toBeCalledTimes(1)
-	})
-	
-	it('should notify', ()=>{
-		const myCallback = vi.fn()
-
-		observable.subscribe( myCallback )
-		observable.notify()
-
-		expect( myCallback ).toHaveBeenCalledTimes(1)
-	})
-
-	it('should notify all subscribers', () => {
-		const callbackOne = vi.fn()
-		const callbackTwo = vi.fn()
-		const callbackThree = vi.fn()
-		observable.subscribe(callbackOne)
-		observable.subscribe(callbackTwo)
-		observable.subscribe(callbackThree)
-		
-		observable.notify()
-
-		expect(callbackOne).toHaveBeenCalledTimes(1)
-		expect(callbackTwo).toHaveBeenCalledTimes(1)
-		expect(callbackThree).toHaveBeenCalledTimes(1)
-	})
-
-	it( 'should notify with event', ()=>{
-		const myCallback = vi.fn()
-		const obj: MockEvent = {name: 'Juan'};
-
-		observable.subscribe( myCallback )
-		observable.notify(obj)
-
-		expect( myCallback ).toHaveBeenCalledWith( obj )
-	})
-
-	it('should not notify removed listeners', ()=>{
-		const callbackOne = vi.fn()
-		const callbackTwo = vi.fn()
-		const callbackThree = vi.fn()
-		observable.subscribe(callbackOne)
-		observable.subscribe(callbackTwo)
-		observable.subscribe(callbackThree)
-		
-		observable.notify()
-
-		expect(callbackOne).toHaveBeenCalledTimes(1)
-		expect(callbackTwo).toHaveBeenCalledTimes(1)
-		expect(callbackThree).toHaveBeenCalledTimes(1)
-
-		observable.unsubscribe( callbackThree )
-
-		observable.notify()
-
-		expect(callbackOne).toHaveBeenCalledTimes(2)
-		expect(callbackTwo).toHaveBeenCalledTimes(2)
-		expect(callbackThree).toHaveBeenCalledTimes(1)
-	})
-
-	it( 'should return an unsubscribe function on subscribe', ()=>{
-		const cb = vi.fn()
-		const unsubscriber = observable.subscribe( cb )	
-		unsubscriber()
-
-		observable.notify()
-		expect( cb ).not.toHaveBeenCalled()
-	})
-	
-	it( 'should return the number of subscribers', ()=>{
-		const cb = vi.fn()
-		observable.subscribe( cb )
-		observable.subscribe( cb )
-		observable.subscribe( vi.fn() )
-
-		expect( observable.subscribersCount ).toBe( 2 )
-	})
-})