entropic-bond 1.50.0 → 1.50.2

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

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

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

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

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

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