@rsdk/actx 5.8.2 → 5.9.0-next.1

package/dist/async-context.exception.d.ts

@@ -0,0 +1,9 @@
+export declare enum AsyncContextExceptionCode {
+    ASYNC_CONTEXT_IS_NOT_PROVIDED = "ASYNC_CONTEXT_IS_NOT_PROVIDED",
+    UNEXPECTED_REWRITE = "UNEXPECTED_REWRITE",
+    VALUE_NOT_PROVIDED = "VALUE_NOT_PROVIDED"
+}
+export declare class AsyncContextException extends Error {
+    readonly code: AsyncContextExceptionCode;
+    constructor(message: string, code: AsyncContextExceptionCode);
+}

package/dist/async-context.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncContextException = exports.AsyncContextExceptionCode = void 0;
+var AsyncContextExceptionCode;
+(function (AsyncContextExceptionCode) {
+    AsyncContextExceptionCode["ASYNC_CONTEXT_IS_NOT_PROVIDED"] = "ASYNC_CONTEXT_IS_NOT_PROVIDED";
+    AsyncContextExceptionCode["UNEXPECTED_REWRITE"] = "UNEXPECTED_REWRITE";
+    AsyncContextExceptionCode["VALUE_NOT_PROVIDED"] = "VALUE_NOT_PROVIDED";
+})(AsyncContextExceptionCode || (exports.AsyncContextExceptionCode = AsyncContextExceptionCode = {}));
+// TODO: после того как вынесем ошибки в @rsdk/exception, надо сделать InternalException
+class AsyncContextException extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.AsyncContextException = AsyncContextException;
+//# sourceMappingURL=async-context.exception.js.map

package/dist/async-context.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context.exception.js","sourceRoot":"","sources":["../src/async-context.exception.ts"],"names":[],"mappings":";;;AAAA,IAAY,yBAIX;AAJD,WAAY,yBAAyB;IACnC,4FAA+D,CAAA;IAC/D,sEAAyC,CAAA;IACzC,sEAAyC,CAAA;AAC3C,CAAC,EAJW,yBAAyB,yCAAzB,yBAAyB,QAIpC;AAED,wFAAwF;AACxF,MAAa,qBAAsB,SAAQ,KAAK;IACrC,IAAI,CAA4B;IAEzC,YAAY,OAAe,EAAE,IAA+B;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAPD,sDAOC"}

package/dist/async-context.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncContext = void 0;
+const async_context_exception_1 = require("./async-context.exception");
 const async_context_storage_1 = require("./async-context.storage");
 class AsyncContext {
     static set(key, v, rewritable = false) {
@@ -19,7 +20,7 @@ class AsyncContext {
     static getStoreOrThrow() {
         const store = async_context_storage_1.AsyncContextStorage.getStore();
         if (!store) {
-            throw new Error('AsyncContext is not provided');
+            throw new async_context_exception_1.AsyncContextException('AsyncContext is not provided', async_context_exception_1.AsyncContextExceptionCode.ASYNC_CONTEXT_IS_NOT_PROVIDED);
         }
         return store;
     }
@@ -28,7 +29,7 @@ class AsyncContext {
             return;
         }
         if (AsyncContext.has(key)) {
-            throw new Error('Unexpected rewrite');
+            throw new async_context_exception_1.AsyncContextException('Unexpected rewrite', async_context_exception_1.AsyncContextExceptionCode.UNEXPECTED_REWRITE);
         }
     }
 }

package/dist/async-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-context.js","sourceRoot":"","sources":["../src/async-context.ts"],"names":[],"mappings":";;;AAAA,mEAA8D;AAE9D,MAAa,YAAY;IACvB,MAAM,CAAC,GAAG,CAAC,GAAW,EAAE,CAAU,EAAE,UAAU,GAAG,KAAK;QACpD,MAAM,KAAK,GAAG,YAAY,CAAC,eAAe,EAAE,CAAC;QAE7C,YAAY,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC/C,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,GAAG,CAAI,GAAW;QACvB,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAE7C,OAAO,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,GAAW;QACpB,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAE7C,OAAO,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC;IAClC,CAAC;IAEO,MAAM,CAAC,eAAe;QAC5B,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAC7C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,GAAW,EAAE,UAAmB;QAC9D,IAAI,UAAU,EAAE,CAAC;YACf,OAAO;QACT,CAAC;QACD,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;CACF;AApCD,oCAoCC"}
+{"version":3,"file":"async-context.js","sourceRoot":"","sources":["../src/async-context.ts"],"names":[],"mappings":";;;AAAA,uEAGmC;AACnC,mEAA8D;AAE9D,MAAa,YAAY;IACvB,MAAM,CAAC,GAAG,CAAC,GAAW,EAAE,CAAU,EAAE,UAAU,GAAG,KAAK;QACpD,MAAM,KAAK,GAAG,YAAY,CAAC,eAAe,EAAE,CAAC;QAE7C,YAAY,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC/C,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,GAAG,CAAI,GAAW;QACvB,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAE7C,OAAO,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,GAAW;QACpB,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAE7C,OAAO,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC;IAClC,CAAC;IAEO,MAAM,CAAC,eAAe;QAC5B,MAAM,KAAK,GAAG,2CAAmB,CAAC,QAAQ,EAAE,CAAC;QAC7C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,+CAAqB,CAC7B,8BAA8B,EAC9B,mDAAyB,CAAC,6BAA6B,CACxD,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,GAAW,EAAE,UAAmB;QAC9D,IAAI,UAAU,EAAE,CAAC;YACf,OAAO;QACT,CAAC;QACD,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,+CAAqB,CAC7B,oBAAoB,EACpB,mDAAyB,CAAC,kBAAkB,CAC7C,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA1CD,oCA0CC"}

package/dist/async-context.provider.d.ts

@@ -3,6 +3,17 @@ export interface AsyncContextProvider<V> {
     get(): V | undefined;
     getOrThrow(): V;
     set(v: V): void;
+    /**
+     * Данный метод позволяет создать дочерний контекст для провайдера с указанным новым значением.
+     * Это может быть полезно, например, для системных действий по крону или для нужд тестирования.
+     * При использовании `set` данного провайдера внутри callback'а родительский контекст не изменится,
+     * а при использовании `set` других провайдеров изменения всплывут в родительский контекст.
+     *
+     * @param value Новое значение в провайдере, которое будет доступно в callback
+     * @param callback Callback, внутри которого замкнуто новое значение провайдера
+     * @returns Результат выполнения callback
+     */
+    runWith<T>(value: V, callback: () => T): T;
 }
 export declare const createAsyncContextProvider: <V = never>(config: {
     /**

package/dist/async-context.provider.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAsyncContextProvider = void 0;
 const async_context_1 = require("./async-context");
+const async_context_exception_1 = require("./async-context.exception");
+const async_context_storage_1 = require("./async-context.storage");
 const createAsyncContextProvider = (config) => {
     const token = config.name;
     let isSettled = false;
@@ -14,7 +16,7 @@ const createAsyncContextProvider = (config) => {
         },
         getOrThrow() {
             if (!async_context_1.AsyncContext.has(token)) {
-                throw new Error('Value not provided: ' + token);
+                throw new async_context_exception_1.AsyncContextException('Value not provided: ' + token, async_context_exception_1.AsyncContextExceptionCode.VALUE_NOT_PROVIDED);
             }
             return async_context_1.AsyncContext.get(token);
         },
@@ -22,6 +24,40 @@ const createAsyncContextProvider = (config) => {
             isSettled = true;
             async_context_1.AsyncContext.set(token, v, config.rewritable);
         },
+        runWith(value, callback) {
+            const parentStore = async_context_storage_1.AsyncContextStorage.getStore() ?? new Map();
+            const localOverrides = new Map([[token, value]]);
+            const proxyStore = new Proxy(parentStore, {
+                get(target, prop, receiver) {
+                    switch (prop) {
+                        case 'get':
+                            return (key) => {
+                                if (key === token) {
+                                    return localOverrides.get(key);
+                                }
+                                return target.get(key);
+                            };
+                        case 'set':
+                            return (key, val) => {
+                                if (key === token) {
+                                    localOverrides.set(key, val);
+                                }
+                                else {
+                                    target.set(key, val);
+                                }
+                                return proxyStore;
+                            };
+                        case 'has':
+                            return (key) => {
+                                return key === token || target.has(key);
+                            };
+                        default:
+                            return Reflect.get(target, prop, receiver);
+                    }
+                },
+            });
+            return async_context_storage_1.AsyncContextStorage.run(proxyStore, callback);
+        },
     };
 };
 exports.createAsyncContextProvider = createAsyncContextProvider;

package/dist/async-context.provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-context.provider.js","sourceRoot":"","sources":["../src/async-context.provider.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAWxC,MAAM,0BAA0B,GAAG,CAAY,MAUrD,EAA2B,EAAE;IAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IAE1B,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACL,IAAI,SAAS;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,GAAG;YACD,OAAO,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,UAAU;YACR,IAAI,CAAC,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CAAC,sBAAsB,GAAG,KAAK,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,GAAG,CAAC,CAAI;YACN,SAAS,GAAG,IAAI,CAAC;YACjB,4BAAY,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAnCW,QAAA,0BAA0B,8BAmCrC"}
+{"version":3,"file":"async-context.provider.js","sourceRoot":"","sources":["../src/async-context.provider.ts"],"names":[],"mappings":";;;AAAA,mDAA+C;AAC/C,uEAGmC;AACnC,mEAA8D;AAuBvD,MAAM,0BAA0B,GAAG,CAAY,MAUrD,EAA2B,EAAE;IAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IAE1B,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACL,IAAI,SAAS;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,GAAG;YACD,OAAO,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,UAAU;YACR,IAAI,CAAC,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,+CAAqB,CAC7B,sBAAsB,GAAG,KAAK,EAC9B,mDAAyB,CAAC,kBAAkB,CAC7C,CAAC;YACJ,CAAC;YACD,OAAO,4BAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,GAAG,CAAC,CAAI;YACN,SAAS,GAAG,IAAI,CAAC;YACjB,4BAAY,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,CAAI,KAAQ,EAAE,QAAiB;YACpC,MAAM,WAAW,GAAG,2CAAmB,CAAC,QAAQ,EAAE,IAAI,IAAI,GAAG,EAAE,CAAC;YAEhE,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;YAEjD,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,WAAW,EAAE;gBACxC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ;oBACxB,QAAQ,IAAI,EAAE,CAAC;wBACb,KAAK,KAAK;4BACR,OAAO,CAAC,GAAQ,EAAO,EAAE;gCACvB,IAAI,GAAG,KAAK,KAAK,EAAE,CAAC;oCAClB,OAAO,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gCACjC,CAAC;gCAED,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;4BACzB,CAAC,CAAC;wBACJ,KAAK,KAAK;4BACR,OAAO,CAAC,GAAQ,EAAE,GAAQ,EAAiB,EAAE;gCAC3C,IAAI,GAAG,KAAK,KAAK,EAAE,CAAC;oCAClB,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;gCAC/B,CAAC;qCAAM,CAAC;oCACN,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;gCACvB,CAAC;gCAED,OAAO,UAAU,CAAC;4BACpB,CAAC,CAAC;wBACJ,KAAK,KAAK;4BACR,OAAO,CAAC,GAAQ,EAAW,EAAE;gCAC3B,OAAO,GAAG,KAAK,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;4BAC1C,CAAC,CAAC;wBACJ;4BACE,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;oBAC/C,CAAC;gBACH,CAAC;aACF,CAAC,CAAC;YAEH,OAAO,2CAAmB,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvD,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AA7EW,QAAA,0BAA0B,8BA6ErC"}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { AsyncContextModule } from './async-context.module';
 export { createAsyncContextProvider, AsyncContextProvider, } from './async-context.provider';
+export { AsyncContextException, AsyncContextExceptionCode, } from './async-context.exception';

package/dist/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAsyncContextProvider = exports.AsyncContextModule = void 0;
+exports.AsyncContextExceptionCode = exports.AsyncContextException = exports.createAsyncContextProvider = exports.AsyncContextModule = void 0;
 var async_context_module_1 = require("./async-context.module");
 Object.defineProperty(exports, "AsyncContextModule", { enumerable: true, get: function () { return async_context_module_1.AsyncContextModule; } });
 var async_context_provider_1 = require("./async-context.provider");
 Object.defineProperty(exports, "createAsyncContextProvider", { enumerable: true, get: function () { return async_context_provider_1.createAsyncContextProvider; } });
+var async_context_exception_1 = require("./async-context.exception");
+Object.defineProperty(exports, "AsyncContextException", { enumerable: true, get: function () { return async_context_exception_1.AsyncContextException; } });
+Object.defineProperty(exports, "AsyncContextExceptionCode", { enumerable: true, get: function () { return async_context_exception_1.AsyncContextExceptionCode; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAE3B,mEAGkC;AAFhC,oIAAA,0BAA0B,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAE3B,mEAGkC;AAFhC,oIAAA,0BAA0B,OAAA;AAG5B,qEAGmC;AAFjC,gIAAA,qBAAqB,OAAA;AACrB,oIAAA,yBAAyB,OAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdk/actx",
-  "version": "5.8.2",
+  "version": "5.9.0-next.1",
   "description": "Library for AsyncLocalStorage",
   "license": "Apache License 2.0",
   "publishConfig": {
@@ -15,5 +15,5 @@
     "@nestjs/core": "^10.0.0",
     "rxjs": "^7.1.0"
   },
-  "gitHead": "524bd5c5e00b467f2fa46d6d5f55b330c687abc5"
+  "gitHead": "0ac1c409f8e5f7c79d5625a72950169d46e04b00"
 }

package/src/async-context.exception.ts

@@ -0,0 +1,15 @@
+export enum AsyncContextExceptionCode {
+  ASYNC_CONTEXT_IS_NOT_PROVIDED = 'ASYNC_CONTEXT_IS_NOT_PROVIDED',
+  UNEXPECTED_REWRITE = 'UNEXPECTED_REWRITE',
+  VALUE_NOT_PROVIDED = 'VALUE_NOT_PROVIDED',
+}
+
+// TODO: после того как вынесем ошибки в @rsdk/exception, надо сделать InternalException
+export class AsyncContextException extends Error {
+  readonly code: AsyncContextExceptionCode;
+
+  constructor(message: string, code: AsyncContextExceptionCode) {
+    super(message);
+    this.code = code;
+  }
+}

package/src/async-context.provider.ts

@@ -1,4 +1,9 @@
 import { AsyncContext } from './async-context';
+import {
+  AsyncContextException,
+  AsyncContextExceptionCode,
+} from './async-context.exception';
+import { AsyncContextStorage } from './async-context.storage';
 
 export interface AsyncContextProvider<V> {
   get isSettled(): boolean;
@@ -7,6 +12,18 @@ export interface AsyncContextProvider<V> {
   getOrThrow(): V;
 
   set(v: V): void;
+
+  /**
+   * Данный метод позволяет создать дочерний контекст для провайдера с указанным новым значением.
+   * Это может быть полезно, например, для системных действий по крону или для нужд тестирования.
+   * При использовании `set` данного провайдера внутри callback'а родительский контекст не изменится,
+   * а при использовании `set` других провайдеров изменения всплывут в родительский контекст.
+   *
+   * @param value Новое значение в провайдере, которое будет доступно в callback
+   * @param callback Callback, внутри которого замкнуто новое значение провайдера
+   * @returns Результат выполнения callback
+   */
+  runWith<T>(value: V, callback: () => T): T;
 }
 
 export const createAsyncContextProvider = <V = never>(config: {
@@ -34,7 +51,10 @@ export const createAsyncContextProvider = <V = never>(config: {
 
     getOrThrow(): V {
       if (!AsyncContext.has(token)) {
-        throw new Error('Value not provided: ' + token);
+        throw new AsyncContextException(
+          'Value not provided: ' + token,
+          AsyncContextExceptionCode.VALUE_NOT_PROVIDED,
+        );
       }
       return AsyncContext.get(token);
     },
@@ -43,5 +63,44 @@ export const createAsyncContextProvider = <V = never>(config: {
       isSettled = true;
       AsyncContext.set(token, v, config.rewritable);
     },
+
+    runWith<T>(value: V, callback: () => T): T {
+      const parentStore = AsyncContextStorage.getStore() ?? new Map();
+
+      const localOverrides = new Map([[token, value]]);
+
+      const proxyStore = new Proxy(parentStore, {
+        get(target, prop, receiver): any {
+          switch (prop) {
+            case 'get':
+              return (key: any): any => {
+                if (key === token) {
+                  return localOverrides.get(key);
+                }
+
+                return target.get(key);
+              };
+            case 'set':
+              return (key: any, val: any): Map<any, any> => {
+                if (key === token) {
+                  localOverrides.set(key, val);
+                } else {
+                  target.set(key, val);
+                }
+
+                return proxyStore;
+              };
+            case 'has':
+              return (key: any): boolean => {
+                return key === token || target.has(key);
+              };
+            default:
+              return Reflect.get(target, prop, receiver);
+          }
+        },
+      });
+
+      return AsyncContextStorage.run(proxyStore, callback);
+    },
   };
 };

package/src/async-context.ts

@@ -1,3 +1,7 @@
+import {
+  AsyncContextException,
+  AsyncContextExceptionCode,
+} from './async-context.exception';
 import { AsyncContextStorage } from './async-context.storage';
 
 export class AsyncContext {
@@ -23,7 +27,10 @@ export class AsyncContext {
   private static getStoreOrThrow(): Map<any, any> {
     const store = AsyncContextStorage.getStore();
     if (!store) {
-      throw new Error('AsyncContext is not provided');
+      throw new AsyncContextException(
+        'AsyncContext is not provided',
+        AsyncContextExceptionCode.ASYNC_CONTEXT_IS_NOT_PROVIDED,
+      );
     }
     return store;
   }
@@ -33,7 +40,10 @@ export class AsyncContext {
       return;
     }
     if (AsyncContext.has(key)) {
-      throw new Error('Unexpected rewrite');
+      throw new AsyncContextException(
+        'Unexpected rewrite',
+        AsyncContextExceptionCode.UNEXPECTED_REWRITE,
+      );
     }
   }
 }

package/src/index.ts

@@ -4,3 +4,7 @@ export {
   createAsyncContextProvider,
   AsyncContextProvider,
 } from './async-context.provider';
+export {
+  AsyncContextException,
+  AsyncContextExceptionCode,
+} from './async-context.exception';

package/test/async-context.provider.spec.ts

@@ -0,0 +1,255 @@
+import type { AsyncContextProvider } from '../src';
+import {
+  AsyncContextException,
+  AsyncContextExceptionCode,
+  createAsyncContextProvider,
+} from '../src';
+import { AsyncContext } from '../src/async-context';
+import { AsyncContextStorage } from '../src/async-context.storage';
+
+describe('AsyncContextProvider', () => {
+  const token = 'some token';
+  const oldValue = { value: 'old value' };
+  const newValue = { value: 'new value' };
+  let provider: AsyncContextProvider<{ value: string }>;
+
+  describe('rewritable', () => {
+    beforeEach(() => {
+      provider = createAsyncContextProvider({
+        name: token,
+        rewritable: true,
+      });
+    });
+
+    describe('get', () => {
+      it('should return undefined if async context is not provided', () => {
+        expect(provider.get()).toBeUndefined();
+      });
+
+      it('should return undefined if value is not set', () => {
+        AsyncContextStorage.run(new Map(), () => {
+          expect(provider.get()).toBeUndefined();
+        });
+      });
+
+      it('should return value', () => {
+        AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+          expect(provider.get()).toStrictEqual(oldValue);
+        });
+      });
+    });
+
+    describe('getOrThrow', () => {
+      it('should throw if async context is not provided', () => {
+        expect(async () => provider.getOrThrow()).rejects.toMatchObject({
+          constructor: AsyncContextException,
+          code: AsyncContextExceptionCode.VALUE_NOT_PROVIDED,
+        });
+      });
+
+      it('should throw if value is not set', () => {
+        AsyncContextStorage.run(new Map(), () => {
+          expect(async () => provider.getOrThrow()).rejects.toMatchObject({
+            constructor: AsyncContextException,
+            code: AsyncContextExceptionCode.VALUE_NOT_PROVIDED,
+          });
+        });
+      });
+
+      it('should return value', () => {
+        AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+          expect(provider.getOrThrow()).toStrictEqual(oldValue);
+        });
+      });
+    });
+
+    describe('set', () => {
+      it('should change isSettled', () => {
+        expect(provider.isSettled).toStrictEqual(false);
+        AsyncContextStorage.run(new Map(), () => {
+          provider.set(newValue);
+        });
+        expect(provider.isSettled).toStrictEqual(true);
+      });
+
+      it('should call AsyncContext.set', () => {
+        const asyncContextMock = jest.spyOn(AsyncContext, 'set');
+
+        AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+          provider.set(newValue);
+        });
+
+        expect(asyncContextMock).toHaveBeenCalledWith(token, newValue, true);
+      });
+    });
+
+    describe('runWith', () => {
+      const anotherToken = 'another token';
+      let anotherProvider: AsyncContextProvider<{ value: string }>;
+
+      beforeEach(() => {
+        anotherProvider = createAsyncContextProvider({
+          name: anotherToken,
+          rewritable: true,
+        });
+      });
+
+      it('should not throw if async context is not provided', () => {
+        provider.runWith(oldValue, () => {
+          provider.set(newValue);
+        });
+      });
+
+      it('should not rewrite parent store for this token', () => {
+        const valueInRunWith = { value: 'value in run with' };
+        const overrideValueInRunWith = { value: 'override value in run with' };
+
+        AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+          expect(provider.get()).toStrictEqual(oldValue);
+
+          provider.runWith(valueInRunWith, () => {
+            expect(provider.get()).toStrictEqual(valueInRunWith);
+            provider.set(overrideValueInRunWith);
+            expect(provider.get()).toStrictEqual(overrideValueInRunWith);
+          });
+
+          expect(provider.get()).toStrictEqual(oldValue);
+        });
+      });
+
+      it('should propagate value to parent store if set for another provider', () => {
+        const oldValueForAnotherProvider = {
+          value: 'oldValueForAnotherProvider',
+        };
+        const newValueForAnotherProvider = {
+          value: 'newValueForAnotherProvider',
+        };
+
+        AsyncContextStorage.run(
+          new Map([
+            [token, oldValue],
+            [anotherToken, oldValueForAnotherProvider],
+          ]),
+          () => {
+            expect(anotherProvider.get()).toStrictEqual(
+              oldValueForAnotherProvider,
+            );
+
+            provider.runWith(newValue, () => {
+              expect(anotherProvider.get()).toStrictEqual(
+                oldValueForAnotherProvider,
+              );
+              anotherProvider.set(newValueForAnotherProvider);
+              expect(anotherProvider.get()).toStrictEqual(
+                newValueForAnotherProvider,
+              );
+            });
+
+            expect(anotherProvider.get()).toStrictEqual(
+              newValueForAnotherProvider,
+            );
+          },
+        );
+      });
+
+      it('should correctly works in complex example', () => {
+        const firstProviderValue1 = { value: '1' };
+        const firstProviderValue2 = { value: '2' };
+        const firstProviderValue3 = { value: '3' };
+        const firstProviderValue4 = { value: '4' };
+        const firstProviderValue5 = { value: '5' };
+        const firstProviderValue6 = { value: '6' };
+
+        const secondProviderValue1 = { value: '1' };
+        const secondProviderValue2 = { value: '2' };
+        const secondProviderValue3 = { value: '3' };
+        const secondProviderValue4 = { value: '4' };
+        const secondProviderValue5 = { value: '5' };
+
+        AsyncContextStorage.run(
+          new Map([
+            [token, firstProviderValue1],
+            [anotherToken, secondProviderValue1],
+          ]),
+          () => {
+            expect(provider.get()).toStrictEqual(firstProviderValue1);
+            expect(anotherProvider.get()).toStrictEqual(secondProviderValue1);
+
+            provider.runWith(firstProviderValue2, () => {
+              expect(provider.get()).toStrictEqual(firstProviderValue2);
+              expect(anotherProvider.get()).toStrictEqual(secondProviderValue1);
+
+              provider.set(firstProviderValue3);
+              anotherProvider.set(secondProviderValue2);
+
+              expect(provider.get()).toStrictEqual(firstProviderValue3);
+              expect(anotherProvider.get()).toStrictEqual(secondProviderValue2);
+
+              anotherProvider.runWith(secondProviderValue3, () => {
+                expect(provider.get()).toStrictEqual(firstProviderValue3);
+                expect(anotherProvider.get()).toStrictEqual(
+                  secondProviderValue3,
+                );
+
+                provider.set(firstProviderValue4);
+                anotherProvider.set(secondProviderValue4);
+
+                expect(provider.get()).toStrictEqual(firstProviderValue4);
+                expect(anotherProvider.get()).toStrictEqual(
+                  secondProviderValue4,
+                );
+
+                provider.runWith(firstProviderValue5, () => {
+                  expect(provider.get()).toStrictEqual(firstProviderValue5);
+                  expect(anotherProvider.get()).toStrictEqual(
+                    secondProviderValue4,
+                  );
+
+                  provider.set(firstProviderValue6);
+                  anotherProvider.set(secondProviderValue5);
+
+                  expect(provider.get()).toStrictEqual(firstProviderValue6);
+                  expect(anotherProvider.get()).toStrictEqual(
+                    secondProviderValue5,
+                  );
+                });
+
+                expect(provider.get()).toStrictEqual(firstProviderValue4);
+                expect(anotherProvider.get()).toStrictEqual(
+                  secondProviderValue5,
+                );
+              });
+
+              expect(provider.get()).toStrictEqual(firstProviderValue4);
+              expect(anotherProvider.get()).toStrictEqual(secondProviderValue2);
+            });
+
+            expect(provider.get()).toStrictEqual(firstProviderValue1);
+            expect(anotherProvider.get()).toStrictEqual(secondProviderValue2);
+          },
+        );
+      });
+    });
+  });
+
+  describe('is not rewritable', () => {
+    beforeEach(() => {
+      provider = createAsyncContextProvider({
+        name: token,
+        rewritable: false,
+      });
+    });
+
+    describe('set', () => {
+      it('should call AsyncContext.set', () => {
+        const asyncContextMock = jest.spyOn(AsyncContext, 'set');
+
+        AsyncContextStorage.run(new Map(), () => {
+          provider.set(newValue);
+        });
+
+        expect(asyncContextMock).toHaveBeenCalledWith(token, newValue, false);
+      });
+    });
+  });
+});

package/test/async-context.spec.ts

@@ -0,0 +1,77 @@
+import { AsyncContextException, AsyncContextExceptionCode } from '../src';
+import { AsyncContext } from '../src/async-context';
+import { AsyncContextStorage } from '../src/async-context.storage';
+
+describe('AsyncContext', () => {
+  const token = 'key';
+  const oldValue = { value: 'old value' };
+  const newValue = { value: 'new value' };
+
+  describe('set', () => {
+    it('should throw if async context is not provided', () => {
+      expect(async () =>
+        AsyncContext.set(token, newValue, true),
+      ).rejects.toMatchObject({
+        constructor: AsyncContextException,
+        code: AsyncContextExceptionCode.ASYNC_CONTEXT_IS_NOT_PROVIDED,
+      });
+    });
+
+    it('should throw if token is not rewritable and value was set', () => {
+      AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+        expect(async () =>
+          AsyncContext.set(token, newValue, false),
+        ).rejects.toMatchObject({
+          constructor: AsyncContextException,
+          code: AsyncContextExceptionCode.UNEXPECTED_REWRITE,
+        });
+      });
+    });
+
+    it('should set value', () => {
+      AsyncContextStorage.run(new Map([[token, oldValue]]), () => {
+        const store = AsyncContextStorage.getStore()!;
+
+        expect(store.get(token)).toStrictEqual(oldValue);
+        AsyncContext.set(token, newValue, true);
+        expect(store.get(token)).toStrictEqual(newValue);
+      });
+    });
+  });
+
+  describe('get', () => {
+    it('should return undefined if async context is not provided', () => {
+      expect(AsyncContext.get(token)).toBeUndefined();
+    });
+
+    it('should return undefined if value is not set', () => {
+      AsyncContextStorage.run(new Map(), () => {
+        expect(AsyncContext.get(token)).toBeUndefined();
+      });
+    });
+
+    it('should return value', () => {
+      AsyncContextStorage.run(new Map([[token, newValue]]), () => {
+        expect(AsyncContext.get(token)).toStrictEqual(newValue);
+      });
+    });
+  });
+
+  describe('has', () => {
+    it('should return false if async context is not provided', () => {
+      expect(AsyncContext.has(token)).toStrictEqual(false);
+    });
+
+    it('should return false if value is not set', () => {
+      AsyncContextStorage.run(new Map(), () => {
+        expect(AsyncContext.has(token)).toStrictEqual(false);
+      });
+    });
+
+    it('should return value', () => {
+      AsyncContextStorage.run(new Map([[token, newValue]]), () => {
+        expect(AsyncContext.has(token)).toStrictEqual(true);
+      });
+    });
+  });
+});