@itee/client 10.0.0

package/sources/managers/TDataBaseManager.js

@@ -0,0 +1,1649 @@
+/**
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ *
+ * @class TDataBaseManager
+ * @classdesc The base class of database managers. Give the basic interface about database call.
+ *
+ * @requires {@link HttpVerb}
+ * @requires {@link ResponseType}
+ * @requires {@link HttpStatusCode}
+ * @requires {@link TOrchestrator}
+ * @requires {@link TStore}
+ *
+ * @example Todo
+ *
+ */
+
+/* eslint-env browser */
+
+import {
+    DefaultLogger,
+    TLogger
+}                 from '@itee/core'
+import { toEnum } from '@itee/utils'
+import {
+    isArray,
+    isArrayOfSingleElement,
+    isBlankString,
+    isDefined,
+    isEmptyObject,
+    isEmptyString,
+    isNotBlankString,
+    isNotDefined,
+    isNotEmptyArray,
+    isNotEmptyObject,
+    isNotEmptyString,
+    isNotNumber,
+    isNotObject,
+    isNotString,
+    isNull,
+    isNumberNegative,
+    isNumberPositive,
+    isObject,
+    isString,
+    isUndefined,
+    isZero
+}                 from '@itee/validators'
+import {
+    HttpStatusCode,
+    HttpVerb,
+    ResponseType
+}                 from '../cores/TConstants.js'
+import { TStore } from '../cores/TStore.js'
+
+
+/**
+ * @deprecated
+ */
+class IdGenerator {
+
+    constructor() {
+        this._id = 0
+    }
+
+    get id() {
+        this._id += 1
+        return this._id
+    }
+
+}
+
+const Generate = new IdGenerator()
+
+/**
+ *
+ * @type {ReadonlyArray<unknown>}
+ */
+const RequestType = /*#__PURE__*/toEnum( {
+    CreateOne:   0,
+    CreateMany:  1,
+    ReadOne:     2,
+    ReadMany:    3,
+    ReadWhere:   4,
+    ReadAll:     5,
+    UpdateOne:   6,
+    UpdateMany:  7,
+    UpdateWhere: 8,
+    UpdateAll:   9,
+    DeleteOne:   10,
+    DeleteMany:  11,
+    DeleteWhere: 12,
+    DeleteAll:   13
+} )
+
+/**
+ * @class
+ */
+class TDataBaseManager {
+
+    /**
+     *
+     * @param parameters
+     */
+    constructor( parameters = {} ) {
+
+        const _parameters = {
+            ...{
+                basePath:               '/',
+                responseType:           ResponseType.Json,
+                bunchSize:              500,
+                requestAggregationTime: 200,
+                requestsConcurrency:    6,
+                logger:                 DefaultLogger
+            }, ...parameters
+        }
+
+        this.basePath               = _parameters.basePath
+        this.responseType           = _parameters.responseType
+        this.bunchSize              = _parameters.bunchSize
+        this.requestAggregationTime = _parameters.requestAggregationTime
+        this.requestsConcurrency    = _parameters.requestsConcurrency
+        this.logger                 = _parameters.logger
+
+        this._cache                = new TStore()
+        this._waitingQueue         = []
+        this._aggregateQueue       = []
+        this._requestQueue         = []
+        this._processQueue         = []
+        this._aggregationTimeoutId = null
+
+        this._idToRequest = []
+
+    }
+    /**
+     *
+     * @returns {number}
+     */
+    static get requestId() {
+        TDataBaseManager._requestId++
+        return TDataBaseManager._requestId
+    }
+    /**
+     *
+     * @returns {*}
+     */
+    get basePath() {
+        return this._basePath
+    }
+
+    set basePath( value ) {
+
+        if ( isNull( value ) ) { throw new TypeError( 'Base path cannot be null ! Expect a non empty string.' ) }
+        if ( isUndefined( value ) ) { throw new TypeError( 'Base path cannot be undefined ! Expect a non empty string.' ) }
+        if ( isNotString( value ) ) { throw new TypeError( `Base path cannot be an instance of ${ value.constructor.name } ! Expect a non empty string.` ) }
+        if ( isEmptyString( value ) ) { throw new TypeError( 'Base path cannot be empty ! Expect a non empty string.' ) }
+        if ( isBlankString( value ) ) { throw new TypeError( 'Base path cannot contain only whitespace ! Expect a non empty string.' ) }
+
+        this._basePath = value
+
+    }
+
+    /**
+     *
+     * @returns {*}
+     */
+    get responseType() {
+        return this._responseType
+    }
+
+    set responseType( value ) {
+
+        if ( isNull( value ) ) { throw new Error( 'TDataBaseManager: responseType cannot be null !' ) }
+        if ( isNull( value ) ) { throw new TypeError( 'Response type cannot be null ! Expect a non empty string.' ) }
+        if ( isUndefined( value ) ) { throw new TypeError( 'Response type cannot be undefined ! Expect a non empty string.' ) }
+        //        if ( !( value instanceof ResponseType ) ) { throw new TypeError( `Response type cannot be an instance of ${value.constructor.name} ! Expect a value from ResponseType enum.` ) }
+
+        this._responseType = value
+
+    }
+
+    /**
+     *
+     * @returns {*}
+     */
+    get bunchSize() {
+        return this._bunchSize
+    }
+
+    set bunchSize( value ) {
+
+        if ( isNull( value ) ) { throw new TypeError( 'Bunch size cannot be null ! Expect a positive number.' ) }
+        if ( isUndefined( value ) ) { throw new TypeError( 'Bunch size cannot be undefined ! Expect a positive number.' ) }
+        if ( isNotNumber( value ) ) { throw new TypeError( `Bunch size cannot be an instance of ${ value.constructor.name } ! Expect a positive number.` ) }
+        if ( !isNumberPositive( value ) ) { throw new TypeError( `Bunch size cannot be lower or equal to zero ! Expect a positive number.` ) }
+
+        this._bunchSize = value
+
+    }
+
+    /**
+     *
+     * @returns {*}
+     */
+    get requestAggregationTime() {
+        return this._requestAggregationTime
+    }
+
+    set requestAggregationTime( value ) {
+
+        if ( isNull( value ) ) {
+            throw new TypeError( 'Requests aggregation time cannot be null ! Expect a positive number.' )
+        }
+
+        if ( isUndefined( value ) ) {
+            throw new TypeError( 'Requests aggregation time cannot be undefined ! Expect a positive number.' )
+        }
+
+        if ( isNotNumber( value ) ) {
+            throw new TypeError( `Requests aggregation time cannot be an instance of ${ value.constructor.name } ! Expect a positive number.` )
+        }
+
+        if ( isNumberNegative( value ) ) {
+            throw new TypeError( 'Requests aggregation time cannot be lower or equal to zero ! Expect a positive number.' )
+        }
+
+        this._requestAggregationTime = value
+
+    }
+
+    /**
+     *
+     * @returns {*}
+     */
+    get requestsConcurrency() {
+        return this._requestsConcurrency
+    }
+
+    set requestsConcurrency( value ) {
+
+        if ( isNull( value ) ) {
+            throw new TypeError( 'Minimum of simultaneous request cannot be null ! Expect a positive number.' )
+        }
+
+        if ( isUndefined( value ) ) {
+            throw new TypeError( 'Minimum of simultaneous request cannot be undefined ! Expect a positive number.' )
+        }
+
+        if ( isNotNumber( value ) ) {
+            throw new TypeError( `Minimum of simultaneous request cannot be an instance of ${ value.constructor.name } ! Expect a positive number.` )
+        }
+
+        if ( isZero( value ) || isNumberNegative( value ) ) {
+            throw new TypeError( 'Minimum of simultaneous request cannot be lower or equal to zero ! Expect a positive number.' )
+        }
+
+        this._requestsConcurrency = value
+
+    }
+
+    /**
+     *
+     * @returns {TLogger}
+     */
+    get logger() {
+        return this._logger
+    }
+
+    set logger( value ) {
+
+        if ( isNull( value ) ) { throw new TypeError( 'Progress manager cannot be null ! Expect an instance of TProgressManager.' ) }
+        if ( isUndefined( value ) ) { throw new TypeError( 'Progress manager cannot be undefined ! Expect an instance of TProgressManager.' ) }
+        if ( !( value instanceof TLogger ) ) { throw new TypeError( `Progress manager cannot be an instance of ${ value.constructor.name } ! Expect an instance of TProgressManager.` ) }
+
+        this._logger = value
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setBasePath( value ) {
+
+        this.basePath = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setResponseType( value ) {
+
+        this.responseType = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setBunchSize( value ) {
+
+        this.bunchSize = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setRequestAggregationTime( value ) {
+
+        this.requestAggregationTime = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setRequestsConcurrency( value ) {
+
+        this.requestsConcurrency = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TDataBaseManager}
+     */
+    setLogger( value ) {
+
+        this.logger = value
+        return this
+
+    }
+
+    /**
+     *
+     */
+    aggregateQueue() {
+
+        clearTimeout( this._aggregationTimeoutId )
+
+        this._aggregationTimeoutId = setTimeout( () => {
+
+            const datasToRequest = this._idToRequest
+            let idBunch          = []
+            for ( let idIndex = datasToRequest.length - 1 ; idIndex >= 0 ; idIndex-- ) {
+
+                idBunch.push( datasToRequest.pop() )
+
+                if ( idBunch.length === this._bunchSize || idIndex === 0 ) {
+
+                    this._requestQueue.push( {
+                        _id:        `readMany_${ Generate.id }`,
+                        _timeStart: new Date(),
+                        _type:      RequestType.ReadMany,
+                        method:     HttpVerb.Read.value,
+                        url:        this._basePath,
+                        data:       {
+                            ids: idBunch
+                        },
+                        responseType: this._responseType
+                    } )
+
+                    idBunch = []
+                }
+
+            }
+
+            this.processQueue.call( this )
+
+        }, this._requestAggregationTime )
+
+    }
+
+    /**
+     *
+     */
+    processQueue() {
+
+        while ( this._requestQueue.length > 0 && this._processQueue.length < this._requestsConcurrency ) {
+
+            const requestSkull = this._requestQueue.pop()
+            this._processQueue.push( requestSkull )
+
+            const request              = new XMLHttpRequest()
+            request.onloadstart        = _onLoadStart.bind( this )
+            request.onload             = this._onLoad.bind(
+                this,
+                requestSkull,
+                this._onEnd.bind( this, requestSkull, requestSkull.onLoad ),
+                this._onProgress.bind( this, requestSkull.onProgress ),
+                this._onError.bind( this, requestSkull, requestSkull.onError )
+            )
+            request.onloadend          = _onLoadEnd.bind( this )
+            request.onprogress         = this._onProgress.bind( this, requestSkull.onProgress )
+            request.onreadystatechange = _onReadyStateChange.bind( this )
+            request.onabort            = _onAbort.bind( this )
+            request.onerror            = this._onError.bind( this, requestSkull, requestSkull.onError )
+            request.ontimeout          = _onTimeout.bind( this )
+            request.open( requestSkull.method, requestSkull.url, true )
+            request.setRequestHeader( 'Content-Type', 'application/json' )
+            request.setRequestHeader( 'Accept', 'application/json' )
+            request.responseType = requestSkull.responseType.value
+
+            const dataToSend = ( requestSkull.data && requestSkull.responseType === ResponseType.Json ) ? JSON.stringify( requestSkull.data ) : requestSkull.data
+            request.send( dataToSend )
+
+        }
+
+        function _onLoadStart( loadStartEvent ) { this.logger.progress( loadStartEvent ) }
+
+        function _onLoadEnd( loadEndEvent ) { this.logger.progress( loadEndEvent ) }
+
+        function _onReadyStateChange( readyStateEvent ) { this.logger.debug( readyStateEvent ) }
+
+        function _onAbort( abortEvent ) { this.logger.error( abortEvent ) }
+
+        function _onTimeout( timeoutEvent ) { this.logger.error( timeoutEvent ) }
+
+    }
+
+    // Publics
+    /**
+     * The create method allow to create a new ressource on the server. Providing a single object that match a database schema, or an array of them.
+     *
+     * @param {object|array.<object>} data - The data to send for create new objects.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    create( data, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        if ( isArray( data ) && isNotEmptyArray( data ) ) {
+
+            if ( isArrayOfSingleElement( data ) ) {
+
+                this._createOne( data[ 0 ], onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._createMany( data, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else if ( isObject( data ) && isNotEmptyObject( data ) ) {
+
+            this._createOne( data, onLoadCallback, onProgressCallback, onErrorCallback )
+
+        } else {
+
+            onErrorCallback( 'TDataBaseManager.create: Invalid data type, expect object or array of objects.' )
+
+        }
+
+    }
+
+    /**
+     * The read method allow to retrieve data from the server, using a single id or an array of them.
+     *
+     * @param {string|array.<string>} condition - The ids of objects to retrieve.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    read( condition, projection, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        if ( isString( condition ) && isNotEmptyString( condition ) && isNotBlankString( condition ) ) {
+
+            this._readOne( condition, projection, onLoadCallback, onProgressCallback, onErrorCallback )
+
+        } else if ( isArray( condition ) && isNotEmptyArray( condition ) ) {
+
+            if ( isArrayOfSingleElement( condition ) ) {
+
+                this._readOne( condition[ 0 ], projection, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._readMany( condition, projection, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else if ( isObject( condition ) ) {
+
+            if ( isEmptyObject( condition ) ) {
+
+                this._readAll( projection, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._readWhere( condition, projection, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else {
+
+            onErrorCallback( 'TDataBaseManager.read: Invalid data type, expect string, object or array of objects.' )
+
+        }
+
+    }
+
+    /**
+     * The update method allow to update data on the server, using a single id or an array of them, and a corresponding object about the data to update.
+     *
+     * @param {string|array.<string>} condition - The ids of objects to update.
+     * @param {object} update - The update data ( need to match the related database schema ! ). In case of multiple ids they will be updated with the same given data.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    update( condition, update, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        if ( isNotDefined( update ) ) {
+            onErrorCallback( 'TDataBaseManager.update: Update data cannot be null or undefined !' )
+            return
+        }
+
+        if ( isNotObject( update ) ) {
+            onErrorCallback( 'TDataBaseManager.update: Invalid update data type. Expect an object.' )
+            return
+        }
+
+        if ( isString( condition ) && isNotEmptyString( condition ) && isNotBlankString( condition ) ) {
+
+            this._updateOne( condition, update, onLoadCallback, onProgressCallback, onErrorCallback )
+
+        } else if ( isArray( condition ) && isNotEmptyArray( condition ) ) {
+
+            if ( isArrayOfSingleElement( condition ) ) {
+
+                this._updateOne( condition[ 0 ], update, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._updateMany( condition, update, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else if ( isObject( condition ) ) {
+
+            if ( isEmptyObject( condition ) ) {
+
+                this._updateAll( update, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._updateWhere( condition, update, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else {
+
+            onErrorCallback( 'TDataBaseManager.update: Invalid data type, expect string, object or array of objects.' )
+
+        }
+
+    }
+
+    /**
+     * The delete method allow to remove data from the server, using a single id or an array of them.
+     *
+     * @param {string|array.<string>|object|null} condition - The ids of objects to delete.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    delete( condition, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        if ( isString( condition ) && isNotEmptyString( condition ) && isNotBlankString( condition ) ) {
+
+            this._deleteOne( condition, onLoadCallback, onProgressCallback, onErrorCallback )
+
+        } else if ( isArray( condition ) && isNotEmptyArray( condition ) ) {
+
+            if ( isArrayOfSingleElement( condition ) ) {
+
+                this._deleteOne( condition[ 0 ], onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._deleteMany( condition, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else if ( isObject( condition ) ) {
+
+            if ( isEmptyObject( condition ) ) {
+
+                this._deleteAll( onLoadCallback, onProgressCallback, onErrorCallback )
+
+            } else {
+
+                this._deleteWhere( condition, onLoadCallback, onProgressCallback, onErrorCallback )
+
+            }
+
+        } else {
+
+            onErrorCallback( 'TDataBaseManager.delete: Invalid data type, expect null, string, object or array of objects.' )
+
+        }
+
+    }
+
+    // Privates
+
+    //// Events
+
+    /**
+     * The private _onLoad method allow to process the server response in an abstract way to check against error and wrong status code.
+     * It will bind user callback on each type of returns, and dispatch in sub methods in function of the response type.
+     *
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @param {object} loadEvent - The server response object to parse.
+     * @private
+     */
+    _onLoad( request, onLoadCallback, onProgressCallback, onErrorCallback, loadEvent ) {
+
+        const target       = loadEvent.target
+        const status       = target.status
+        const response     = target.response
+        const responseType = target.responseType
+
+        switch ( status ) {
+
+            // 100
+            //            case HttpStatusCode.Continue.value:
+            //            case HttpStatusCode.SwitchingProtocols.value:
+            //            case HttpStatusCode.Processing.value:
+
+            // 200
+            case HttpStatusCode.Ok.value:
+                this._dispatchResponse( response, responseType, onLoadCallback, onProgressCallback, onErrorCallback )
+                break
+            //            case HttpStatusCode.Created.value:
+            //            case HttpStatusCode.Accepted.value:
+
+            case HttpStatusCode.NonAuthoritativeInformation.value:
+            case HttpStatusCode.NoContent.value:
+            case HttpStatusCode.ResetContent.value:
+            case HttpStatusCode.PartialContent.value:
+            case HttpStatusCode.MultiStatus.value:
+            case HttpStatusCode.AlreadyReported.value:
+            case HttpStatusCode.ContentDifferent.value:
+            case HttpStatusCode.IMUsed.value:
+            case HttpStatusCode.MultipleChoices.value:
+            case HttpStatusCode.MovedPermanently.value:
+            case HttpStatusCode.Found.value:
+            case HttpStatusCode.SeeOther.value:
+            case HttpStatusCode.NotModified.value:
+            case HttpStatusCode.UseProxy.value:
+            case HttpStatusCode.Unused.value:
+            case HttpStatusCode.TemporaryRedirect.value:
+            case HttpStatusCode.PermanentRedirect.value:
+            case HttpStatusCode.TooManyRedirects.value:
+            case HttpStatusCode.BadRequest.value:
+            case HttpStatusCode.Unauthorized.value:
+            case HttpStatusCode.PaymentRequired.value:
+            case HttpStatusCode.Forbidden.value:
+            case HttpStatusCode.NotFound.value:
+            case HttpStatusCode.MethodNotAllowed.value:
+            case HttpStatusCode.NotAcceptable.value:
+            case HttpStatusCode.ProxyAuthenticationRequired.value:
+            case HttpStatusCode.RequestTimeOut.value:
+            case HttpStatusCode.Conflict.value:
+            case HttpStatusCode.Gone.value:
+            case HttpStatusCode.LengthRequired.value:
+            case HttpStatusCode.PreconditionFailed.value:
+            case HttpStatusCode.RequestEntityTooLarge.value:
+            case HttpStatusCode.RequestRangeUnsatisfiable.value:
+            case HttpStatusCode.ExpectationFailed.value:
+            case HttpStatusCode.ImATeapot.value:
+            case HttpStatusCode.BadMapping.value:
+            case HttpStatusCode.UnprocessableEntity.value:
+            case HttpStatusCode.Locked.value:
+            case HttpStatusCode.MethodFailure.value:
+            case HttpStatusCode.UnorderedCollection.value:
+            case HttpStatusCode.UpgradeRequired.value:
+            case HttpStatusCode.PreconditionRequired.value:
+            case HttpStatusCode.TooManyRequests.value:
+            case HttpStatusCode.RequestHeaderFieldsTooLarge.value:
+            case HttpStatusCode.NoResponse.value:
+            case HttpStatusCode.RetryWith.value:
+            case HttpStatusCode.BlockedByWindowsParentalControls.value:
+            case HttpStatusCode.UnavailableForLegalReasons.value:
+            case HttpStatusCode.UnrecoverableError.value:
+            case HttpStatusCode.SSLCertificateError.value:
+            case HttpStatusCode.SSLCertificateRequired.value:
+            case HttpStatusCode.HTTPRequestSentToHTTPSPort.value:
+            case HttpStatusCode.ClientClosedRequest.value:
+            case HttpStatusCode.InternalServerError.value:
+            case HttpStatusCode.NotImplemented.value:
+            case HttpStatusCode.BadGateway.value:
+            case HttpStatusCode.ServiceUnavailable.value:
+            case HttpStatusCode.GatewayTimeOut.value:
+            case HttpStatusCode.HTTPVersionNotSupported.value:
+            case HttpStatusCode.VariantAlsoNegotiates.value:
+            case HttpStatusCode.InsufficientStorage.value:
+            case HttpStatusCode.LoopDetected.value:
+            case HttpStatusCode.BandwidthLimitExceeded.value:
+            case HttpStatusCode.NotExtended.value:
+            case HttpStatusCode.NetworkAuthenticationRequired.value:
+            case HttpStatusCode.UnknownError.value:
+            case HttpStatusCode.WebServerIsDown.value:
+            case HttpStatusCode.ConnectionTimedOut.value:
+            case HttpStatusCode.OriginIsUnreachable.value:
+            case HttpStatusCode.ATimeoutOccured.value:
+            case HttpStatusCode.SSLHandshakeFailed.value:
+            case HttpStatusCode.InvalidSSLCertificate.value:
+            case HttpStatusCode.RailgunError.value:
+                onErrorCallback( response )
+                break
+
+            default:
+                throw new RangeError( `Unmanaged HttpStatusCode: ${ status }` )
+
+        }
+
+    }
+
+    /**
+     * The private _onProgress method will handle all progress event from server and submit them to the logger if exist else to the user onProgressCallback
+     *
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {object} progressEvent - The server progress event.
+     * @private
+     */
+    _onProgress( onProgressCallback, progressEvent ) {
+
+        if ( isDefined( this.logger ) ) {
+
+            this.logger.progress( progressEvent, onProgressCallback )
+
+        } else if ( isDefined( onProgressCallback ) ) {
+
+            onProgressCallback( progressEvent )
+
+        }
+
+    }
+
+    /**
+     * The private _onError method will handle all error event from server and submit them to the logger if exist else to the user onErrorCallback
+     *
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @param {object} errorEvent - A server error event
+     * @private
+     */
+    _onError( request, onErrorCallback, errorEvent ) {
+
+        this._closeRequest( request )
+
+        if ( isDefined( this.logger ) ) {
+
+            this.logger.error( errorEvent, onErrorCallback )
+
+        } else if ( isDefined( onErrorCallback ) ) {
+
+            onErrorCallback( errorEvent )
+
+        }
+
+    }
+
+    /**
+     * The private _onEnd method is call after all other callback and perform request type checking in view to upadte cache, waitingqueue and callback if needed,
+     * to finally close the request
+     *
+     * @param request
+     * @param onLoadCallback
+     * @param response
+     * @private
+     */
+    _onEnd( request, onLoadCallback, response ) {
+
+        const type = request._type
+
+        switch ( type ) {
+
+            case RequestType.ReadOne:
+            case RequestType.ReadMany:
+                this._updateCache( response )
+                this._updateWaitingQueue()
+                break
+
+            case RequestType.ReadWhere:
+            case RequestType.ReadAll:
+                this._updateCache( response )
+                this._updateWaitingQueue()
+                onLoadCallback( response )
+                break
+
+            case RequestType.CreateOne:
+            case RequestType.CreateMany:
+            case RequestType.UpdateOne:
+            case RequestType.UpdateMany:
+            case RequestType.UpdateWhere:
+            case RequestType.UpdateAll:
+            case RequestType.DeleteOne:
+            case RequestType.DeleteMany:
+            case RequestType.DeleteWhere:
+            case RequestType.DeleteAll:
+                onLoadCallback( response )
+                break
+
+            default:
+                throw new RangeError( `Invalid request type: ${ type }` )
+
+        }
+
+        this._closeRequest( request )
+
+    }
+
+    //// Data parsing
+    // Expect that methods were reimplemented when TDataBaseManager is inherited
+
+    /**
+     * Dispatch response to the correct handler in function of response type
+     *
+     * @param response
+     * @param responseType
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _dispatchResponse( response, responseType, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        switch ( responseType ) {
+
+            case ResponseType.ArrayBuffer.value:
+                this._onArrayBuffer(
+                    response,
+                    onLoadCallback,
+                    onProgressCallback,
+                    onErrorCallback
+                )
+                break
+
+            case ResponseType.Blob.value:
+                this._onBlob(
+                    response,
+                    onLoadCallback,
+                    onProgressCallback,
+                    onErrorCallback
+                )
+                break
+
+            case ResponseType.Json.value:
+                this._onJson(
+                    response,
+                    onLoadCallback,
+                    onProgressCallback,
+                    onErrorCallback
+                )
+                break
+
+            case ResponseType.DOMString.value:
+            case ResponseType.Default.value:
+                this._onText(
+                    response,
+                    onLoadCallback,
+                    onProgressCallback,
+                    onErrorCallback
+                )
+                break
+
+            default:
+                throw new Error( `Unknown response type: ${ responseType }` )
+
+        }
+
+    }
+
+    /**
+     * Will remove the request from the process queue
+     *
+     * @param request
+     * @private
+     */
+    _closeRequest( request ) {
+
+        this._processQueue.splice( this._processQueue.indexOf( request ), 1 )
+
+        if ( Window.Itee && Window.Itee.Debug ) {
+
+            const diff    = new Date().valueOf() - request._timeStart.valueOf()
+            const message = `${ this.constructor.name } close request [${ request._id }] on ${ diff }ms.` +
+                `Waiting queue: ${ this._waitingQueue.length }` +
+                `Request queue: ${ this._requestQueue.length }` +
+                `Process queue: ${ this._processQueue.length }` +
+                `==========================`
+            this.logger.debug( message )
+
+        }
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param ids
+     * @returns {Object}
+     * @private
+     */
+    _retrieveCachedValues( ids ) {
+
+        let results      = {}
+        let underRequest = []
+        let toRequest    = []
+
+        for ( let idIndex = 0, numberOfIds = ids.length ; idIndex < numberOfIds ; idIndex++ ) {
+
+            const id          = ids[ idIndex ]
+            const cachedValue = this._cache.get( id )
+
+            if ( isDefined( cachedValue ) ) {
+                results[ id ] = cachedValue
+            } else if ( isNull( cachedValue ) ) { // In request
+                underRequest.push( id )
+            } else {
+                toRequest.push( id )
+            }
+
+        }
+
+        return {
+            results,
+            underRequest,
+            toRequest
+        }
+
+    }
+
+    /**
+     *
+     * @param datas
+     * @private
+     */
+    _updateCache( datas ) {
+
+        if ( isNull( datas ) ) { throw new TypeError( 'Data cannot be null ! Expect an array of object.' ) }
+        if ( isUndefined( datas ) ) { throw new TypeError( 'Data cannot be undefined ! Expect an array of object.' ) }
+
+        let _datas = {}
+        if ( isArray( datas ) ) {
+
+            for ( let key in datas ) {
+                _datas[ datas[ key ]._id ] = datas[ key ]
+            }
+
+        } else {
+
+            _datas = datas
+
+        }
+
+        for ( let [ id, data ] of Object.entries( _datas ) ) {
+
+            const cachedResult = this._cache.get( id )
+
+            if ( isNull( cachedResult ) ) {
+                this._cache.add( id, data, true )
+            } else if ( isUndefined( cachedResult ) ) {
+                this.logger.warn( 'Cache was not pre-allocated with null value.' )
+                this._cache.add( id, data )
+            } else {
+                this.logger.error( 'Cached value already exist !' )
+            }
+
+        }
+
+    }
+
+    /**
+     *
+     * @private
+     */
+    _updateWaitingQueue() {
+
+        const haveNoRequestToProcess = ( this._requestQueue.length === 0 && this._processQueue.length === 0 )
+
+        for ( let requestIndex = this._waitingQueue.length - 1 ; requestIndex >= 0 ; requestIndex-- ) {
+
+            const demand = this._waitingQueue[ requestIndex ]
+
+            // Update requested datas
+            for ( let dataIndex = demand.underRequest.length - 1 ; dataIndex >= 0 ; dataIndex-- ) {
+
+                const id           = demand.underRequest[ dataIndex ]
+                const cachedResult = this._cache.get( id )
+
+                if ( isNotDefined( cachedResult ) ) { continue }
+
+                // Assign the cached value
+                demand.results[ id ] = cachedResult
+
+                // Remove the requested object that is now added
+                demand.underRequest.splice( demand.underRequest.indexOf( id ), 1 )
+
+            }
+
+            // Check if request is now fullfilled
+            const demandIsComplet = ( demand.underRequest.length === 0 )
+            if ( demandIsComplet ) {
+
+                this._waitingQueue.splice( requestIndex, 1 )
+                demand.onLoadCallback( demand.results )
+
+            } else if ( !demandIsComplet && haveNoRequestToProcess /* && haveTryAgainManyTimesButFail */ ) {
+
+                this.logger.warn( 'Incomplet demand but empty request/process queue' )
+                this._waitingQueue.splice( requestIndex, 1 )
+                demand.onLoadCallback( demand.results )
+
+            } else {
+
+                // Wait next response
+
+            }
+
+        }
+
+    }
+
+    /**
+     * The abstract private _onArrayBuffer method must be overridden in case the parser expect an array buffer as input data.
+     *
+     * @private
+     * @abstract
+     * @param {ArrayBuffer} data - The retrieved data to parse.
+     * @param {function} onSuccess - The onLoad callback, which is call when parser parse with success the data.
+     * @param {function} onProgress - The onProgress callback, which is call during the parsing.
+     * @param {function} onError - The onError callback, which is call when parser throw an error during parsing.
+     */
+    // eslint-disable-next-line no-unused-vars
+    _onArrayBuffer( data, onSuccess, onProgress, onError ) {}
+
+    /**
+     * The abstract private _onBlob method must be overridden in case the parser expect a blob as input data.
+     *
+     * @private
+     * @abstract
+     * @param {Blob} data - The retrieved data to parse.
+     * @param {function} onSuccess - The onLoad callback, which is call when parser parse with success the data.
+     * @param {function} onProgress - The onProgress callback, which is call during the parsing.
+     * @param {function} onError - The onError callback, which is call when parser throw an error during parsing.
+     */
+    // eslint-disable-next-line no-unused-vars
+    _onBlob( data, onSuccess, onProgress, onError ) {}
+
+    /**
+     * The abstract private _onJson method must be overridden in case the parser expect json as input data.
+     *
+     * @private
+     * @abstract
+     * @param {json} data - The retrieved data to parse.
+     * @param {function} onSuccess - The onLoad callback, which is call when parser parse with success the data.
+     * @param {function} onProgress - The onProgress callback, which is call during the parsing.
+     * @param {function} onError - The onError callback, which is call when parser throw an error during parsing.
+     */
+    // eslint-disable-next-line no-unused-vars
+    _onJson( data, onSuccess, onProgress, onError ) {}
+
+    /**
+     * The abstract private _onText method must be overridden in case the parser expect a string/text as input data.
+     *
+     * @private
+     * @abstract
+     * @param {string} data - The retrieved data to parse.
+     * @param {function} onSuccess - The onLoad callback, which is call when parser parse with success the data.
+     * @param {function} onProgress - The onProgress callback, which is call during the parsing.
+     * @param {function} onError - The onError callback, which is call when parser throw an error during parsing.
+     */
+    // eslint-disable-next-line no-unused-vars
+    _onText( data, onSuccess, onProgress, onError ) {}
+
+    // REST Api calls
+    /**
+     * The private _create method allow to format a server request to create objects with the given data and get creation result with given callbacks.
+     *
+     * @private
+     * @param {object} data - The data to send.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    _createOne( data, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:          `createOne_${ Generate.id }`,
+            _timeStart:   new Date(),
+            _type:        RequestType.CreateOne,
+            method:       HttpVerb.Create.value,
+            url:          this._basePath,
+            data:         data,
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param datas
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _createMany( datas, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:          `createMany_${ Generate.id }`,
+            _timeStart:   new Date(),
+            _type:        RequestType.CreateMany,
+            method:       HttpVerb.Create.value,
+            url:          this._basePath,
+            data:         datas,
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     * The private _updateOne method will format a server request to get a single object with the given id.
+     *
+     * @private
+     * @param {string} id - The object's id of the object to retrieve.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    _readOne( id, projection, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        // Filter requested values by cached values
+        const datas = this._retrieveCachedValues( [ id ] )
+
+        // retrieveLocalStorageValues...
+
+        // getDatabaseValues()
+
+        if ( datas.toRequest.length === 0 ) {
+
+            if ( datas.underRequest.length === 0 ) {
+
+                onLoadCallback( datas.results )
+
+            } else {
+
+                datas[ 'onLoadCallback' ]     = onLoadCallback
+                datas[ 'onProgressCallback' ] = onProgressCallback
+                datas[ 'onErrorCallback' ]    = onErrorCallback
+                this._waitingQueue.push( datas )
+
+            }
+
+        } else {
+
+            datas[ 'onLoadCallback' ]     = onLoadCallback
+            datas[ 'onProgressCallback' ] = onProgressCallback
+            datas[ 'onErrorCallback' ]    = onErrorCallback
+            this._waitingQueue.push( datas )
+
+            try {
+                this._cache.add( id, null )
+                datas.underRequest.push( id )
+                datas.toRequest.splice( datas.toRequest.indexOf( id ), 1 )
+            } catch ( error ) {
+                this.logger.error( error )
+            }
+
+            this._idToRequest.push( id )
+            this.aggregateQueue()
+
+        }
+
+    }
+
+    /**
+     * The private _readMany method will format a server request to get objects with id in the ids array.
+     *
+     * @private
+     * @param {array.<string>} ids - The ids of objects to retrieve.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     */
+    _readMany( ids, projection, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        // Filter requested values by cached values
+        const datas = this._retrieveCachedValues( ids )
+
+        // retrieveLocalStorageValues...
+
+        // getDatabaseValues()
+
+        if ( datas.toRequest.length === 0 ) {
+
+            if ( datas.underRequest.length === 0 ) {
+
+                onLoadCallback( datas.results )
+
+            } else {
+
+                datas[ 'onLoadCallback' ]     = onLoadCallback
+                datas[ 'onProgressCallback' ] = onProgressCallback
+                datas[ 'onErrorCallback' ]    = onErrorCallback
+                this._waitingQueue.push( datas )
+
+            }
+
+        } else {
+
+            datas[ 'onLoadCallback' ]     = onLoadCallback
+            datas[ 'onProgressCallback' ] = onProgressCallback
+            datas[ 'onErrorCallback' ]    = onErrorCallback
+            this._waitingQueue.push( datas )
+
+            const datasToRequest = datas.toRequest
+            let id               = undefined
+            for ( let idIndex = datasToRequest.length - 1 ; idIndex >= 0 ; idIndex-- ) {
+
+                id = datasToRequest[ idIndex ]
+
+                // Prepare entry for id to request
+                try {
+                    this._cache.add( id, null )
+                    datas.underRequest.push( id )
+                    datas.toRequest.splice( datas.toRequest.indexOf( id ), 1 )
+                } catch ( error ) {
+                    this.logger.error( error )
+                }
+
+                this._idToRequest.push( id )
+
+            }
+
+            this.aggregateQueue()
+
+        }
+
+    }
+
+    /**
+     *
+     * @param query
+     * @param projection
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _readWhere( query, projection, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        //        // Filter requested values by cached values
+        //                const datas = {
+        //                    results: {},
+        //                    underRequest: [],
+        //                    toRequest: []
+        //                }
+        //
+        //        datas[ 'onLoadCallback' ] = onLoadCallback
+        //        this._waitingQueue.push( datas )
+
+        this._requestQueue.push( {
+            _id:        `readWhere_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.ReadWhere,
+            method:     HttpVerb.Read.value,
+            url:        this._basePath,
+            data:       {
+                query,
+                projection
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param projection
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _readAll( projection, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        //        const datas = {
+        //            results: {},
+        //            underRequest: [],
+        //            toRequest: []
+        //        }
+        //
+        //        datas[ 'onLoadCallback' ] = onLoadCallback
+        //        this._waitingQueue.push( datas )
+
+        const query = {}
+
+        this._requestQueue.push( {
+            _id:        `readAll_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.ReadAll,
+            method:     HttpVerb.Read.value,
+            url:        this._basePath,
+            data:       {
+                query,
+                projection
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     * The private _updateOne method will format a server request to update a single object with the given id.
+     *
+     * @param {string} id - The object's id of the object to update.
+     * @param update
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @private
+     */
+    _updateOne( id, update, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:        `updateOne_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.UpdateOne,
+            method:     HttpVerb.Update.value,
+            url:        `${ this._basePath }/${ id }`,
+            data:       {
+                update
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     * The private _updateMany method will format a server request to update objects with id in the ids array.
+     *
+     * @param {array.<string>} ids - The ids of objects to update.
+     * @param update
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @private
+     */
+    _updateMany( ids, update, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:        `updateMany_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.UpdateMany,
+            method:     HttpVerb.Update.value,
+            url:        this._basePath,
+            data:       {
+                ids,
+                update
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param query
+     * @param update
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _updateWhere( query, update, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:        `updateWhere_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.UpdateWhere,
+            method:     HttpVerb.Update.value,
+            url:        this._basePath,
+            data:       {
+                query,
+                update
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param update
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _updateAll( update, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        const query = {}
+
+        this._requestQueue.push( {
+            _id:        `updateAll_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.UpdateAll,
+            method:     HttpVerb.Update.value,
+            url:        this._basePath,
+            data:       {
+                query,
+                update
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     * The private _deleteOne method will format a server request to delete a single object with the given id.
+     *
+     * @param {string} id - The object's id of the object to delete.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @private
+     */
+    _deleteOne( id, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:          `deleteOne_${ Generate.id }`,
+            _timeStart:   new Date(),
+            _type:        RequestType.DeleteOne,
+            method:       HttpVerb.Delete.value,
+            url:          `${ this._basePath }/${ id }`,
+            data:         null,
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     * The private _deleteMany method will format a server request to delete objects with id in the ids array.
+     *
+     * @param {array.<string>} ids - The ids of objects to delete.
+     * @param {function} onLoadCallback - The onLoad callback, which is call when server respond with success to the request.
+     * @param {function} onProgressCallback - The onProgress callback, which is call during the response incoming.
+     * @param {function} onErrorCallback - The onError callback, which is call when server respond with an error to the request.
+     * @private
+     */
+    _deleteMany( ids, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:        `deleteMany_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.DeleteMany,
+            method:     HttpVerb.Delete.value,
+            url:        this._basePath,
+            data:       {
+                ids
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param query
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _deleteWhere( query, onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        this._requestQueue.push( {
+            _id:        `deleteWhere_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.DeleteWhere,
+            method:     HttpVerb.Delete.value,
+            url:        this._basePath,
+            data:       {
+                query
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+    /**
+     *
+     * @param onLoadCallback
+     * @param onProgressCallback
+     * @param onErrorCallback
+     * @private
+     */
+    _deleteAll( onLoadCallback, onProgressCallback, onErrorCallback ) {
+
+        const query = {}
+
+        this._requestQueue.push( {
+            _id:        `deleteAll_${ Generate.id }`,
+            _timeStart: new Date(),
+            _type:      RequestType.DeleteAll,
+            method:     HttpVerb.Delete.value,
+            url:        this._basePath,
+            data:       {
+                query
+            },
+            onLoad:       onLoadCallback,
+            onProgress:   onProgressCallback,
+            onError:      onErrorCallback,
+            responseType: this._responseType
+        } )
+
+        this.processQueue()
+
+    }
+
+}
+
+// Static stuff
+/**
+ *
+ * @type {number}
+ * @private
+ */
+TDataBaseManager._requestId = 0
+
+/**
+ *
+ * @type {Object}
+ * @private
+ */
+TDataBaseManager._requests = {
+    /**
+     * The global waiting queue to process
+     */
+    waitingQueue: {},
+    /**
+     * The objects not requested yet
+     */
+    toProcess:    {
+        create: {},
+        read:   {},
+        update: {},
+        delete: {}
+    },
+    /**
+     * The object currently under request
+     */
+    underProcess: {
+        create: {},
+        read:   {},
+        update: {},
+        delete: {}
+    },
+    /**
+     * The objects already processed
+     */
+    processed: {
+        create: {},
+        read:   {},
+        update: {},
+        delete: {}
+    }
+}
+//TDataBaseManager._orchestrator = TOrchestrator
+
+export { TDataBaseManager }