A Thread-local storage (TLS) like Map implementation, base on node async hooks, support nodejs & typescript
-
thread local support for nodejs & typescript
-
named scope & chain support , easily to get closest forefather scope
-
browser or lower version of node support if provided an async-hooks implementation with constructor
install
npm install async-hooks-map
import
import { AsyncHookMap } from 'async-hooks-map';
const { AsyncHookMap } = require('async-hooks-map')
Usage
typescript:
import { AsyncHookMap } from 'async-hooks-map'
const scope = new AsyncHookMap()
Promise.resolve().then(() => {
scope.set('aa', 'first')
scope.alias('ccc')
assert.equal(scope.get('aa'), 'first')
return Promise.resolve().then(() => {
assert(scope.has('aa'), 'should has the key')
assert(!scope.has('not'), 'should not has the key')
assert(!scope.has('aa', false), 'should not has the key in this scope')
assert.equal(scope.get('aa'), 'first')
scope.set('aa', 'second')
assert.equal(scope.get('aa'), 'second')
}).then(() => {
assert.equal(scope.get('aa'), 'second')
assert.equal(scope.closest('ccc').get('aa'), 'first')
assert.equal(scope.closest('root').get('aa'), 'first')
scope.closest().delete('aa')
assert.equal(scope.get('aa'), 'first')
scope.closest('ccc').set('bb', 'bb')
assert.equal(scope.get('bb'), 'bb')
scope.delete('bb')
assert.equal(scope.get('bb'), 'bb')
})
})
})
Api:
export class AsyncHookMap<K=any, V=any>{
executionAsyncId (): number {
return this._asyncHooks.executionAsyncId()
}
current (): AsyncMapNode<K, V>
alias (name: string): this
hasName (name: string): boolean
parent (name?: string): AsyncMapNode<K, V> | undefined
closest (name: string): AsyncMapNode<K, V>
get (key: K): V | undefined
has (key: K, recursion = true): boolean
set (key: K, value: V): this
delete (key: K): boolean
clear (): void
printPath (): void
distance (key: K): number
}
export interface AsyncMapNode<K, V> {
hasName (name: string): boolean
alias (name: string): this
parent (name?: string): AsyncMapNode<K, V> | undefined
closest (name: string): AsyncMapNode<K, V>
has (key: K, recurse?: boolean): boolean
get (key: K): V | undefined
set (key: K, value: V): this
clear (): void
delete (key: K): boolean
}
tips
- closest(name:string) contains this and parent(name?:string) not
closest will throw when cant find the scope and parent() will return undefined
- A async scope can have multiple names
- Top async scope is named 'root' by default