entropic-bond 1.48.1 → 1.50.0

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

@@ -0,0 +1,45 @@
+import { UserCredentials } from '../auth/user-auth-types'
+import { Collection } from '../types/utility-types'
+import { ServerAuthService, CustomCredentials } from './server-auth'
+
+export class ServerAuthMock extends ServerAuthService {
+	constructor( userCredentials: Collection<UserCredentials<{}>> ) {
+		super()
+		this._userCredentials = userCredentials
+	}
+
+	getUser<T extends CustomCredentials>( userId: string ): Promise<UserCredentials<T> | undefined> {
+		if ( !this._userCredentials[ userId ] ) Promise.resolve( undefined )
+
+		return Promise.resolve( this._userCredentials[ userId ] as UserCredentials<T> )
+	}
+
+	setCustomCredentials<T extends CustomCredentials>( userId: string, customCredentials: T ): Promise<void> {
+		const userCredentials = this._userCredentials[ userId ]
+		if ( !userCredentials ) throw new Error( `User ${ userId } not found in the auth system` )
+		userCredentials.customData = { ...customCredentials }
+
+		return Promise.resolve()
+	}
+
+	updateUser<T extends CustomCredentials>( userId: string, credentials: Partial<UserCredentials<T>> ): Promise<UserCredentials<T>> {
+		this._userCredentials[ userId ] = {
+			...this._userCredentials,
+			...credentials,
+			id: userId
+		} as UserCredentials<T>
+
+		return Promise.resolve( this._userCredentials[ userId ] as UserCredentials<T> )
+	}
+
+	deleteUser( userId: string ): Promise<void> {
+		delete this._userCredentials[ userId ]
+		return Promise.resolve()
+	}
+
+	get userCredentials() {
+		return this._userCredentials
+	}
+
+	private _userCredentials: Collection<UserCredentials<{}>>
+}

package/src/server-auth/server-auth.ts

@@ -0,0 +1,49 @@
+import { UserCredentials } from '../auth/user-auth-types'
+
+export interface CustomCredentials {
+	[ key: string ]: unknown
+}
+
+export abstract class ServerAuthService {
+	abstract setCustomCredentials<T extends CustomCredentials>( userId: string, customCredentials: T ): Promise<void>
+	abstract getUser<T extends CustomCredentials>( userId: string ): Promise<UserCredentials<T> | undefined>
+	abstract updateUser<T extends CustomCredentials>( userId: string, credentials: Partial<UserCredentials<T>> ): Promise<UserCredentials<T>>
+	abstract deleteUser( userId: string ): Promise<void>
+}
+
+export class ServerAuth extends ServerAuthService {
+	static error = { shouldBeRegistered: 'You should register a Server Auth service before using the Server Auth.' }
+
+	protected constructor(){ super() }
+
+	static useServerAuthService( authService: ServerAuthService ) {
+		if ( ServerAuth._authService != authService ) {
+			ServerAuth._authService = authService
+			this._instance = undefined
+		}
+	}
+
+	static get instance() {
+		if ( !ServerAuth._authService ) throw new Error( ServerAuth.error.shouldBeRegistered )
+		return this._instance || (this._instance = new ServerAuth() )
+	}
+	
+	getUser<T extends CustomCredentials>( userId: string ): Promise<UserCredentials<T> | undefined> {
+		return ServerAuth._authService.getUser( userId )
+	}
+
+	updateUser<T extends CustomCredentials>( userId: string, credentials: Partial<UserCredentials<T>> ): Promise<UserCredentials<T>> {
+		return ServerAuth._authService.updateUser( userId, credentials )
+	}
+	
+	setCustomCredentials<T extends CustomCredentials>( userId: string, customCredentials: T ): Promise<void> {
+		return ServerAuth._authService.setCustomCredentials( userId, customCredentials )
+	}
+
+	deleteUser( userId: string ) {
+		return ServerAuth._authService.deleteUser( userId )
+	}
+
+	private static _instance: ServerAuth | undefined = undefined
+	private static _authService: ServerAuthService
+}

package/src/store/data-source.ts

@@ -0,0 +1,186 @@
+import { Persistent, PersistentObject, Collections } from '../persistent/persistent'
+import { ClassPropNames } from '../types/utility-types'
+
+export type DocumentObject = PersistentObject<Persistent>
+
+/**
+ * The query operators
+ * @param == equal
+ * @param != not equal
+ * @param < less than
+ * @param <= less than or equal
+ * @param > greater than
+ * @param >= greater than or equal
+ * @param contains array contains
+ * @param containsAny array contains any
+ * @param in in
+ * @param !in not in
+ */
+export type QueryOperator = '==' | '!=' | '<' | '<=' | '>' | '>=' | 'contains' | 'containsAny'// | 'in' | '!in'
+
+/**
+ * A representation of a query operation
+ * @param property the name of the property to be used in the query
+ * @param operator the operator to be used in the query
+ * @param value the value to be used in the query
+ * @param aggregate if true, the query results will be aggregated using an `or` operator
+ */
+export type QueryOperation<T> = {
+	property: ClassPropNames<T>
+	operator: QueryOperator
+	value: Partial<T[ClassPropNames<T>]> | {[key:string]: unknown}
+	aggregate?: boolean
+}
+
+/**
+ * The sort order
+ * @param asc ascending order
+ * @param desc descending order
+ */
+export type QueryOrder = 'asc' | 'desc'
+
+/**
+ * A representation of a full query
+ * @param operations the query operations to be performed
+ * @param limit the maximum number of items to be retrieved
+ * @param sort sort info
+ * @param sort.order the sort order
+ * @param sort.propertyName the name of the property to be used for sorting
+ */
+export type QueryObject<T> = {
+	operations?: QueryOperation<T>[]
+	limit?: number
+	sort?: {
+		order: QueryOrder
+		propertyName: ClassPropNames<T> | string
+	}
+}
+
+/**
+ * The data source interface.
+ * It defines the methods that must be implemented by a data source
+ * A data source is able to retrieve and save data i.e: from a database, a file, a RestAPI, etc.
+ * You can derive from this class to implement your own data source with the 
+ * A data source is used by the store to retrieve and save data.
+ */
+export abstract class DataSource {
+
+	/**
+	 * Retrieves a document by id
+	 * Implement the required logic to retrieve a document by id from your concrete
+	 * the data source
+	 * @param id the id of the document to be retrieved
+	 * @param collectionName the name of the collection where the document is stored
+	 * @returns a promise resolving to the document object. The document object is 
+	 * a plain object with the properties of the document class.
+	 */
+	abstract findById( id: string, collectionName: string ): Promise< DocumentObject >
+
+	/**
+	 * Retrieves all documents matching the query stored in the query object
+	 * Implement the required logic to retrieve the documents that match the 
+	 * requirements in the query object from your concrete the data source
+	 * @param queryObject the query object containing the query operations
+	 * @param collectionName the name of the collection where the documents are stored
+	 * @returns a promise resolving to an array of document objects. The document object is
+	 * a plain object with the properties of the document class.
+	 * @see QueryObject
+	 * @see QueryOperation
+	 * @see QueryOperator
+	 * @see QueryOrder
+	 * @see DocumentObject
+	 */
+	abstract find( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise< DocumentObject[] >
+
+	/**
+	 * Saves a document
+	 * Implement the required logic to save the document in your concrete the data source
+	 * @param object A collection of documents to be saved
+	 * @returns a promise
+	 */
+	abstract save( object: Collections ): Promise< void >
+
+	/**
+	 * Deletes a document by id
+	 * Implement the required logic to delete a document by id from your concrete
+	 * data source
+	 * @param id the id of the document to be deleted
+	 * @param collectionName the name of the collection where the document is stored
+	 * @returns a promise
+	 */
+	abstract delete( id: string, collectionName: string ): Promise<void>
+
+	/**
+	 * Retrieves the next bunch of documents matching the query stored in the query object
+	 * Implement the required logic to retrieve the next bunch of documents that match the
+	 * requirements in the query object from your concrete the data source
+	 * @param limit the maximum number of items to be retrieved
+	 * @returns a promise resolving to an array representing the next bunch of document objects
+	 */
+	abstract next( limit?: number ): Promise< DocumentObject[] >
+
+	/**
+	 * Retrieves the number of documents matching the query stored in the query object
+	 * Implement the required logic to retrieve the number of documents that match the
+	 * requirements in the query object from your concrete the data source
+	 * @param queryObject the query object containing the query operations
+	 * @param collectionName the name of the collection where the documents are stored
+	 * @returns a promise resolving to the number of documents matching the query
+	 * @see QueryObject
+	 */
+	abstract count( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise<number>
+
+	/**
+	 * Utility method to convert a query object to a property path query object
+	 * 
+	 * @param queryObject the query object to be converted
+	 * @returns a property path query object
+	 * @example
+	 * const queryObject = {
+	 * 	operations: [{ property: 'name', operator: '==', value: { ancestorName: { father: 'Felipe' }}]
+	 * }
+	 * const propPathQueryObject = DataSource.toPropertyPathQueryObject( queryObject )
+	 * // returned value: [{ property: 'name.ancestorName.father', operator: '==', value: 'Felipe' }]
+	 */
+	static toPropertyPathOperations<T extends Persistent>( operations: QueryOperation<T>[] ): QueryOperation<T>[] {
+		if ( !operations ) return []
+
+		return operations.map( operation => {
+
+			if ( DataSource.isArrayOperator( operation.operator ) && operation.value[0] instanceof Persistent ) {
+				return {
+					property: Persistent.searchableArrayNameFor( operation.property as string ),
+					operator: operation.operator,
+					value: ( operation.value as unknown as Persistent[] ).map( v => v.id ) as any,
+					aggregate: operation.aggregate
+				} as QueryOperation<T>
+			}
+
+			const [ path, value ] = this.toPropertyPathValue( operation.value )
+			const propPath = `${ String( operation.property ) }${ path? '.'+path : '' }` 
+
+			return { 
+				property: propPath, 
+				operator:	operation.operator,
+				value,
+				aggregate: operation.aggregate
+			} as QueryOperation<T>
+		})
+	}
+
+	static isArrayOperator( operator: QueryOperator ): boolean {
+		return operator === 'containsAny' || operator === 'contains' //|| operator === 'in' || operator === '!in'  
+	}
+
+	private static toPropertyPathValue( obj: {} ): [ string | undefined, unknown ] {
+		if ( typeof obj === 'object' && !Array.isArray( obj ) ) {
+			const propName = Object.keys( obj )[0]!
+			const [ propPath, value ] = this.toPropertyPathValue( obj[ propName ] )
+			return [ `${ propName }${ propPath? '.'+propPath : '' }`, value ]
+		}
+		else {
+			return [ undefined, obj ]
+		}
+
+	}
+}

package/src/store/json-data-source.spec.ts

@@ -0,0 +1,100 @@
+import { DocumentObject, JsonDataSource, Model, Store } from '..'
+import { TestUser } from './mocks/test-user'
+
+describe( 'Json DataSource', ()=>{
+	let datasource: JsonDataSource
+	const resolveDelay = 50
+
+	describe( 'Delayed promise resolution', ()=>{
+	
+		beforeEach(()=>{
+			datasource = new JsonDataSource({
+				collection: { a: { id: 'a' }, b: { id: 'b' }, c: { id: 'c' } } as any
+			}).simulateDelay( resolveDelay )
+			Store.useDataSource( datasource )
+		})
+	
+		it( 'should fail if no wait to resolve', async ()=>{
+			let result: DocumentObject | undefined = undefined
+			datasource.findById( 'a', 'collection' ).then( data => result = data )
+			expect( result ).not.toBeDefined()
+			await datasource.wait()
+			expect( result ).toBeDefined()
+		})
+		
+		it( 'should wait promises to resolve', async ()=>{
+			let result: DocumentObject | undefined = undefined
+			datasource.findById( 'a', 'collection' ).then( data => result = data )
+			await datasource.wait()
+			expect( result ).toBeDefined()
+		})
+
+		it( 'should accumulate promises', async ()=>{
+			datasource.findById( 'a', 'collection' )
+			datasource.findById( 'b', 'collection' )
+			datasource.findById( 'c', 'collection' )
+			const promises = await datasource.wait()
+			expect( promises ).toHaveLength( 3 )
+		})
+
+		it( 'should remove resolved promises', ( done )=>{
+			datasource.findById( 'b', 'collection' )
+			datasource.findById( 'a', 'collection' )
+			setTimeout(
+				async ()=>{
+					datasource.findById( 'c', 'collection' )
+					const promises = await datasource.wait()
+					expect( promises ).toHaveLength( 1 )
+					done()
+				},
+				resolveDelay * 3
+			)
+		})
+
+		it( 'should work with save', async ()=>{
+			datasource.save({ testCollection: [{ id: "id" } as any ]})
+			await datasource.wait()
+			expect( datasource.rawData ).toEqual( expect.objectContaining({
+				testCollection: { id: { id: "id" } }
+			}))
+		})
+		
+		it( 'should work with model', async ()=>{
+			const model = Store.getModel( 'TestUser' )
+			model.save( new TestUser('id456') )
+			await datasource.wait()
+			expect( datasource.rawData.TestUser ).toEqual( expect.objectContaining({
+				id456: expect.anything()
+			}))
+		})
+		
+	})
+
+	describe( 'Error simulation', ()=>{
+		let model: Model<TestUser>
+
+		beforeAll(()=>{
+			datasource = new JsonDataSource({
+				collection: { a: { id: 'a' }, b: { id: 'b' }, c: { id: 'c' } } as any
+			}).simulateError( 'Simulated error' )
+			Store.useDataSource( datasource )
+			model = Store.getModel<TestUser>( 'TestUser' )
+		})
+
+		it( 'should simulate error on findById', ()=>{
+			expect(	model.findById( 'a' )	).rejects.toThrow( 'Simulated error' )
+		})
+
+		it( 'should simulate error on find', ()=>{
+			expect(	model.find().get() ).rejects.toThrow( 'Simulated error' )
+		})
+
+		it( 'should simulate error on save', ()=>{
+			expect(	model.save( new TestUser('id') ) ).rejects.toThrow( 'Simulated error' )
+		})
+		
+		it( 'should simulate error on delete', ()=>{
+			expect(	model.delete( 'b' ) ).rejects.toThrow( 'Simulated error' )
+		})
+	})
+})

package/src/store/json-data-source.ts

@@ -0,0 +1,256 @@
+import { Collections, Persistent, PersistentObject } from '../persistent/persistent';
+import { DataSource, DocumentObject, QueryObject, QueryOperation } from "./data-source";
+
+export interface JsonRawData {
+	[ collection: string ]: {
+		[ documentId: string ]: PersistentObject<Persistent>
+	}
+}
+
+export interface ErrorOnOperation {
+	store: string
+	find: string
+	findById: string
+	delete: string
+}
+
+type QueryProcessors = {
+	[ P in keyof Required<QueryObject<unknown>> ]: Function
+}
+
+/**
+ * A concrete implementation of the DataSource interface uses an in-memory data store
+ * initialized by a JSON object.
+ * It is useful for testing purposes.
+ * The data in the JSON object is not persisted.
+ */
+export class JsonDataSource implements DataSource {
+
+	/**
+	 * @param jsonRawData the JSON object to be used as data store
+	 */
+	constructor( jsonRawData?: JsonRawData ) {
+		if ( jsonRawData ) this._jsonRawData = jsonRawData;
+	}
+
+	/**
+	 * Set the JSON object to initialize the data store. Use to set the it after 
+	 * the constructor has been called.
+	 * @param jsonRawData the JSON object to be used as data store
+	 */
+	setDataStore( rawDataStore: JsonRawData ) {
+		this._jsonRawData = rawDataStore;
+		return this
+	}
+
+	/**
+	 * 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
+	}
+
+	findById( id: string, collectionName: string ): Promise< DocumentObject > {
+		if ( this._simulateError?.findById ) throw new Error( this._simulateError.findById )
+
+		return this.resolveWithDelay( this._jsonRawData[ collectionName ]?.[ id ] )
+	}
+
+	save( collections: Collections ): Promise< void > {
+		if ( this._simulateError?.store ) throw new Error( this._simulateError.store )
+
+		Object.entries( collections ).forEach(([ collectionName, collection ]) => {
+			if ( !this._jsonRawData[ collectionName ] ) this._jsonRawData[ collectionName ] = {}
+			collection?.forEach( document => {
+				this._jsonRawData[ collectionName ]![ document.id ] = document
+			})
+		})
+
+		return this.resolveWithDelay()
+	}
+
+	find( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise< DocumentObject[] > {
+		if ( this._simulateError?.find ) throw new Error( this._simulateError.find )
+
+		const rawDataArray = Object.values( this._jsonRawData[ collectionName ] || {} )
+		if ( !queryObject ) return this.resolveWithDelay( rawDataArray )
+		
+		this._lastLimit = queryObject.limit || 0
+		this._cursor = 0
+
+		this._lastMatchingDocs = Object.entries( queryObject ).reduce(
+			( prevDocs, [ processMethod, value ]) => {
+
+				return this.queryProcessor( prevDocs, processMethod as any, value )
+
+			}, Object.values( rawDataArray )
+		)
+
+		return this.resolveWithDelay( this._lastMatchingDocs.slice( 0, queryObject.limit ) )
+	}
+
+	delete( id: string, collectionName: string ): Promise<void> {
+		if ( this._simulateError?.delete ) throw new Error( this._simulateError.delete )
+
+		delete this._jsonRawData[ collectionName ]![ id ]
+		return this.resolveWithDelay()
+	}
+
+	next( limit?: number ): Promise< DocumentObject[] > {
+		if ( limit ) this._lastLimit = limit
+		this.incCursor( this._lastLimit )
+
+		return this.resolveWithDelay( this._lastMatchingDocs.slice( this._cursor, this._cursor + this._lastLimit ) )
+	}
+
+	count( queryObject: QueryObject<DocumentObject>, collectionName: string ): Promise<number> {
+		return this.resolveWithDelay(
+			Object.keys( this._jsonRawData[ collectionName ] ?? {} ).length
+		)
+	}
+
+	/**
+	 * @returns the raw data store data as a JSON object
+	 */
+	get rawData() {
+		return this._jsonRawData
+	}
+
+	/**
+	 * Wait for all pending promises to be resolved
+	 * @returns a promise that resolves when all pending promises are resolved
+	 */
+	wait() {
+		return Promise.all([ ...this._pendingPromises ])
+	}
+
+	private incCursor( amount: number ) {
+		this._cursor += amount 
+		if ( this._cursor > this._lastMatchingDocs.length ) {
+			this._cursor = this._lastMatchingDocs.length
+		}
+	}
+
+	simulateError( error: string | ErrorOnOperation | undefined ): this {
+		if ( error === undefined ) {
+			this._simulateError = undefined
+			return this
+		}
+
+		if ( typeof error === 'string' ) {
+			this._simulateError = {
+				store: error,
+				find: error,
+				findById: error,
+				delete: error
+			}
+		}
+		else this._simulateError = error
+
+		return this
+	}
+
+	private decCursor( amount: number ) {
+		this._cursor -= amount 
+		if ( this._cursor < 0 ) {
+			this._cursor = 0
+			return true
+		}
+		return false
+	}
+
+	private queryProcessor<T, P extends keyof QueryProcessors>( docs: DocumentObject[], processMethod: P, value: QueryObject<T>[P] ) {
+
+		const processors: QueryProcessors = {
+
+			limit: ( limit: number ) => docs, //.slice( 0, limit ),
+
+			operations: ( operations: QueryOperation<T>[] ) => this.retrieveQueryDocs( docs, operations ),
+
+			sort: ({ order, propertyName }) => docs.sort( ( a, b ) => {
+				if ( order === 'asc' ) {
+					return this.deepValue( a, propertyName ) > this.deepValue( b, propertyName )? 1 : -1 
+				}
+				else {
+					return this.deepValue( a, propertyName ) < this.deepValue( b, propertyName )? 1 : -1
+				}
+			})
+		}
+
+		return processors[ processMethod ]( value )
+	}
+
+	private retrieveQueryDocs<T>( docs: DocumentObject[], queryOperations: QueryOperation<T>[] ): DocumentObject[] {
+		return queryOperations.reduce(( prevDocs, queryOperation, i ) => {
+			if ( queryOperation.aggregate ) {
+				const aggregate = docs.filter( doc => this.isQueryMatched( doc, queryOperation ) )
+				if ( i === 0 ) return aggregate
+				else return prevDocs.concat( aggregate )
+			}
+			else {
+				return prevDocs.filter( doc => this.isQueryMatched( doc, queryOperation ) )
+			}
+		}, docs )
+	}
+
+	private deepValue( obj: {}, propertyPath: string /*like person.name.firstName*/) {
+		const propChain = propertyPath.split( '.' )
+		return propChain.reduce(( value, prop ) => value[ prop ], obj )
+	}
+
+	private isQueryMatched<T>( doc: DocumentObject, queryOperation: QueryOperation<T> ) {
+		const queryOperator = {
+			'==': <U>(a: U, b: U) => a === b,
+			'!=': <U>(a: U, b: U) => a !== b,
+			'<': <U>(a: U, b: U) => a < b,
+			'<=': <U>(a: U, b: U) => a <= b,
+			'>': <U>(a: U, b: U) => a > b,
+			'>=': <U>(a: U, b: U) => a >= b,
+			'containsAny': <U>(a: U[], b: U[]) => a?.some( v => b?.includes( v ) ),
+			'contains': <U>(a: U[], b: U) => a?.includes( b ),
+		}
+
+		const { property, value, operator } = queryOperation
+		const [ propValue, v ] = this.retrieveValuesToCompare( doc, property as string, value )
+
+		return queryOperator[ operator ]( propValue, v )
+	}
+
+	private retrieveValuesToCompare( doc: DocumentObject, propertyName: string, value: unknown ): [ any, any ] {
+		const propertyValue = doc[ propertyName ]
+
+		if ( propertyValue && typeof value === 'object' && !Array.isArray( value )) {
+			const propName = Object.keys( value! )[0]!
+			var [ propVal, val ] = this.retrieveValuesToCompare( propertyValue, propName, value?.[ propName ] )
+		}
+
+		return [ propVal || propertyValue, val || value ]
+	}
+
+	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
+	}
+
+	private _jsonRawData: JsonRawData = {}
+	private _lastMatchingDocs: DocumentObject[] = []
+	private _lastLimit: number = 0
+	private _cursor: number = 0
+	private _simulateDelay: number = 0
+	private _pendingPromises: Promise<any>[] = []
+	private _simulateError: ErrorOnOperation | undefined
+}