@tramvai/module-common 2.7.0 → 2.11.0

package/lib/index.js

@@ -32,6 +32,7 @@ var toArray = require('@tinkoff/utils/array/toArray');
 var LRU = require('@tinkoff/lru-cache-nano');
 var tokensServer = require('@tramvai/tokens-server');
 var papi = require('@tramvai/papi');
+var nodeAbortController = require('node-abort-controller');
 var jsxRuntime = require('react/jsx-runtime');
 var tokensRender = require('@tramvai/tokens-render');
 var tokensChildApp = require('@tramvai/tokens-child-app');
@@ -393,14 +394,17 @@ const resolveDi = (type, status, diContainer, providers) => {
     return di;
 };
 class CommandLineRunner {
-    constructor({ lines, rootDi, logger, metrics, }) {
+    constructor({ lines, rootDi, logger, metrics, executionContextManager, }) {
+        this.executionContextByDi = new WeakMap();
         this.lines = lines;
         this.rootDi = rootDi;
         this.log = logger('command:command-line-runner');
         this.metrics = metrics;
+        this.executionContextManager = executionContextManager;
     }
     run(type, status, providers, customDi) {
         const di = customDi !== null && customDi !== void 0 ? customDi : resolveDi(type, status, this.rootDi, providers);
+        const rootExecutionContext = di.get({ token: tokensCommon.ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
         this.log.debug({
             event: 'command-run',
             type,
@@ -412,13 +416,25 @@ class CommandLineRunner {
                 const doneMetric = this.createDurationMetric();
                 // eslint-disable-next-line promise/no-nesting
                 return Promise.resolve()
-                    .then(() => this.createLineChain(di, line))
+                    .then(() => {
+                    return this.executionContextManager.withContext(rootExecutionContext, `command-line:${line.toString()}`, async (executionContext) => {
+                        this.executionContextByDi.set(di, executionContext);
+                        await this.createLineChain(di, line);
+                    });
+                })
                     .finally(() => doneMetric({ line: line.toString() }));
             });
         }, Promise.resolve())
             // После завершения цепочки отдаем context выполнения
+            .finally(() => {
+            this.executionContextByDi.delete(di);
+        })
             .then(() => di));
     }
+    resolveExecutionContextFromDi(di) {
+        var _a;
+        return (_a = this.executionContextByDi.get(di)) !== null && _a !== void 0 ? _a : null;
+    }
     createLineChain(di, line) {
         let lineInstance;
         try {
@@ -529,7 +545,7 @@ exports.CommandModule = class CommandModule {
 exports.CommandModule = tslib.__decorate([
     core.Module({
         providers: [
-            {
+            dippy.provide({
                 // Раннер процессов
                 provide: core.COMMAND_LINE_RUNNER_TOKEN,
                 scope: dippy.Scope.SINGLETON,
@@ -542,14 +558,27 @@ exports.CommandModule = tslib.__decorate([
                         token: tokensMetrics.METRICS_MODULE_TOKEN,
                         optional: true,
                     },
+                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
                 },
-            },
-            {
+            }),
+            dippy.provide({
+                provide: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                useFactory: ({ di, commandLineRunner, }) => {
+                    return () => {
+                        return commandLineRunner.resolveExecutionContextFromDi(di);
+                    };
+                },
+                deps: {
+                    di: core.DI_TOKEN,
+                    commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
+                },
+            }),
+            dippy.provide({
                 // Дефолтный список команл
                 provide: core.COMMAND_LINES_TOKEN,
                 scope: dippy.Scope.SINGLETON,
                 useValue: lines$1,
-            },
+            }),
         ],
     })
 ], exports.CommandModule);
@@ -601,14 +630,19 @@ const actionTramvaiReducer = state.createReducer('actionTramvai', initalState).o
     serverState: payload,
 }));
 
+/**
+ * @deprecated only for compatibility with legacy createAction
+ */
 const actionType = {
     global: 'global',
     local: 'local',
 };
 
+const DEFAULT_CONDITIONS = {};
 class ActionChecker {
     // eslint-disable-next-line max-params
     constructor(globalConditionals, payload, parameters, executionState, type) {
+        var _a;
         this.globalConditionals = globalConditionals;
         this.payload = payload;
         this.parameters = parameters;
@@ -622,7 +656,7 @@ class ActionChecker {
             // если экшен был уже выполнен, то считаем, что его не нужно больше выполнять
             this.status = executionState.status !== 'success';
         }
-        this.conditions = parameters.conditions;
+        this.conditions = (_a = parameters.conditions) !== null && _a !== void 0 ? _a : DEFAULT_CONDITIONS;
     }
     check() {
         this.globalConditionals.forEach((filter) => {
@@ -652,12 +686,16 @@ class ActionChecker {
     }
 }
 
+const EMPTY_DEPS = {};
+const DEFAULT_PAYLOAD = {};
 const getParameters = (action) => action[core.ACTION_PARAMETERS];
 class ActionExecution {
-    constructor({ actionConditionals, store, context, di, transformAction, }) {
+    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
         this.actionConditionals = flatten__default["default"](actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
         this.context = context;
+        this.store = store;
         this.di = di;
+        this.executionContextManager = executionContextManager;
         this.execution = new Map();
         this.transformAction = transformAction || identity__default["default"];
         const initialState = store.getState(actionTramvaiReducer);
@@ -667,32 +705,63 @@ class ActionExecution {
             }, initialState.serverState);
         }
     }
-    run(action, payload, type = actionType.local) {
-        // TODO выпилить после перевода всех экшенов к виду Action
-        this.transformAction(action);
-        const parameters = getParameters(action);
-        const executionState = this.getExecutionState(parameters);
+    async runInContext(executionContext, action, ...params) {
+        var _a;
+        let parameters;
+        const payload = (_a = params[0]) !== null && _a !== void 0 ? _a : DEFAULT_PAYLOAD;
+        // TODO: replace type with pure context usage
+        const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? actionType.global : actionType.local;
+        // TODO: remove else branch after migration to new declareAction
+        if (core.isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        const executionState = this.getExecutionState(parameters.name);
         if (!this.canExecuteAction(payload, parameters, executionState, type)) {
-            return Promise.resolve();
+            switch (parameters.conditionsFailResult) {
+                case 'reject':
+                    // TODO: pass condition that has failed
+                    return Promise.reject(new errors.ConditionFailError());
+                default:
+                    return Promise.resolve();
+            }
         }
-        const deps = parameters.deps ? this.di.getOfDeps(parameters.deps) : {};
         executionState.status = 'pending';
-        return Promise.resolve()
-            .then(() => action(this.context, payload, deps))
-            .then((data) => {
-            executionState.status = 'success';
-            return data;
-        })
-            .catch((err) => {
-            executionState.status = 'failed';
-            throw err;
+        return this.executionContextManager.withContext(executionContext, {
+            name: parameters.name,
+            values: (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? { pageActions: false } : undefined,
+        }, (executionActionContext) => {
+            const context = this.createActionContext(executionContext, executionActionContext, parameters);
+            return Promise.resolve()
+                .then(() => {
+                // TODO: do not execute action if context.abortSignal is aborted
+                if (core.isTramvaiAction(action)) {
+                    return action.fn.apply(context, params);
+                }
+                return action(this.context, payload, context.deps);
+            })
+                .then((data) => {
+                executionState.status = 'success';
+                return data;
+            })
+                .catch((err) => {
+                executionState.status = 'failed';
+                throw err;
+            });
         });
     }
-    getExecutionState(parameters) {
-        let executionState = this.execution.get(parameters.name);
+    async run(action, ...params) {
+        return this.runInContext(null, action, ...params);
+    }
+    getExecutionState(name) {
+        let executionState = this.execution.get(name);
+        // TODO: probably do not need to create executionState on client as it is not used
         if (!executionState) {
             executionState = { status: 'pending', state: {} };
-            this.execution.set(parameters.name, executionState);
+            this.execution.set(name, executionState);
         }
         return executionState;
     }
@@ -700,6 +769,16 @@ class ActionExecution {
         const actionChecker = new ActionChecker(this.actionConditionals, payload, parameters, executionState, type);
         return actionChecker.check();
     }
+    createActionContext(parentExecutionContext, actionExecutionContext, parameters) {
+        return {
+            abortSignal: actionExecutionContext === null || actionExecutionContext === void 0 ? void 0 : actionExecutionContext.abortSignal,
+            executeAction: this.runInContext.bind(this, actionExecutionContext),
+            deps: parameters.deps ? this.di.getOfDeps(parameters.deps) : EMPTY_DEPS,
+            actionType: (parentExecutionContext === null || parentExecutionContext === void 0 ? void 0 : parentExecutionContext.values.pageActions) ? 'page' : 'standalone',
+            dispatch: this.store.dispatch,
+            getState: this.store.getState,
+        };
+    }
 }
 
 const GLOBAL_PARAMETER = '@@global';
@@ -729,56 +808,59 @@ class ActionRegistry {
     }
 }
 
-const payload = {};
 class ActionPageRunner {
-    constructor({ store, actionExecution, limitTime, logger }) {
-        this.store = store;
-        this.actionExecution = actionExecution;
-        this.limitTime = limitTime;
-        this.log = logger('action:action-page-runner');
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.logger('action:action-page-runner');
     }
     // TODO stopRunAtError нужен только для редиректов на стороне сервера в экшенах. И нужно пересмотреть реализацию редиректов
     runActions(actions, stopRunAtError = () => false) {
-        return new Promise((resolve, reject) => {
-            const timeoutMarker = setTimeout(() => {
-                this.log.warn(`page actions has exceeded timeout of ${this.limitTime}ms, ignore some results of execution`);
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                endChecker();
-            }, this.limitTime);
-            const endChecker = () => {
-                clearTimeout(timeoutMarker);
-                const result = {};
-                this.actionExecution.execution.forEach((value, key) => {
-                    // достаем значения экшенов, которые успешно выполнились, остальные выполнятся на клиенте
-                    if (value.status === 'success') {
-                        result[key] = value;
-                    }
-                });
-                this.syncStateActions(result);
-                resolve();
-            };
-            const actionMapper = (action) => {
-                return Promise.resolve()
-                    .then(() => this.actionExecution.run(action, payload, actionType.global))
-                    .catch((error) => {
-                    const parameters = action[core.ACTION_PARAMETERS];
-                    this.log.error({
-                        error,
-                        event: `action-execution-error`,
-                        message: `${parameters.name} execution error`,
+        return this.deps.executionContextManager.withContext(this.deps.commandLineExecutionContext(), { name: 'pageActions', values: { pageActions: true } }, (executionContext, abortController) => {
+            return new Promise((resolve, reject) => {
+                const timeoutMarker = setTimeout(() => {
+                    this.log.warn(`page actions has exceeded timeout of ${this.deps.limitTime}ms, ignore some results of execution`);
+                    abortController.abort();
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    endChecker();
+                }, this.deps.limitTime);
+                const endChecker = () => {
+                    clearTimeout(timeoutMarker);
+                    const result = {};
+                    // TODO: dehydrate only actions on first level as inner actions are running on client despite their execution on server
+                    this.deps.actionExecution.execution.forEach((value, key) => {
+                        // достаем значения экшенов, которые успешно выполнились, остальные выполнятся на клиенте
+                        if (value.status === 'success') {
+                            result[key] = value;
+                        }
                     });
-                    if (stopRunAtError(error)) {
-                        clearTimeout(timeoutMarker);
-                        reject(error);
-                    }
-                });
-            };
-            // eslint-disable-next-line promise/catch-or-return
-            Promise.all(actions.map(actionMapper)).then(endChecker);
+                    this.syncStateActions(result);
+                    resolve();
+                };
+                const actionMapper = (action) => {
+                    return Promise.resolve()
+                        .then(() => this.deps.actionExecution.runInContext(executionContext, action))
+                        .catch((error) => {
+                        if (!errors.isSilentError(error)) {
+                            const parameters = core.isTramvaiAction(action) ? action : action[core.ACTION_PARAMETERS];
+                            this.log.error({
+                                error,
+                                event: `action-execution-error`,
+                                message: `${parameters.name} execution error`,
+                            });
+                        }
+                        if (stopRunAtError(error)) {
+                            clearTimeout(timeoutMarker);
+                            reject(error);
+                        }
+                    });
+                };
+                // eslint-disable-next-line promise/catch-or-return
+                Promise.all(actions.map(actionMapper)).then(endChecker);
+            });
         });
     }
     syncStateActions(success) {
-        return this.store.dispatch(actionServerStateEvent(success));
+        return this.deps.store.dispatch(actionServerStateEvent(success));
     }
 }
 
@@ -856,23 +938,26 @@ ActionModule = tslib.__decorate([
                     context: tokensCommon.CONTEXT_TOKEN,
                     store: tokensCommon.STORE_TOKEN,
                     di: core.DI_TOKEN,
+                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
                     transformAction: {
                         token: 'actionTransformAction',
                         optional: true,
                     },
                 },
             }),
-            {
+            core.provide({
                 provide: tokensCommon.ACTION_PAGE_RUNNER_TOKEN,
                 scope: core.Scope.REQUEST,
                 useClass: ActionPageRunner,
                 deps: {
                     actionExecution: tokensCommon.ACTION_EXECUTION_TOKEN,
+                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
+                    commandLineExecutionContext: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
                     store: tokensCommon.STORE_TOKEN,
                     limitTime: 'limitActionGlobalTimeRun',
                     logger: tokensCommon.LOGGER_TOKEN,
                 },
-            },
+            }),
             {
                 provide: 'limitActionGlobalTimeRun',
                 useValue: 500,
@@ -1014,6 +1099,58 @@ CacheModule = tslib.__decorate([
     })
 ], CacheModule);
 
+const EMPTY_VALUES = {};
+const normalizeOptions = (nameOrOptions) => {
+    return typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
+};
+class ExecutionContextManager {
+    async withContext(parentContext, nameOrOptions, cb) {
+        const options = normalizeOptions(nameOrOptions);
+        const { name, values: selfValues = EMPTY_VALUES } = options;
+        const contextName = parentContext ? `${parentContext.name}.${name}` : name;
+        if (parentContext === null || parentContext === void 0 ? void 0 : parentContext.abortSignal.aborted) {
+            throw new errors.ExecutionAbortError({
+                message: `Execution aborted in context "${contextName}"`,
+                contextName,
+            });
+        }
+        const abortController = new nodeAbortController.AbortController();
+        let abortListener;
+        let values = selfValues;
+        if (parentContext) {
+            values = {
+                ...parentContext.values,
+                ...selfValues,
+            };
+            abortListener = () => {
+                abortController.abort();
+            };
+            // abort child context AbortController if parent AbortController was aborted
+            parentContext.abortSignal.addEventListener('abort', abortListener);
+        }
+        const context = {
+            name: contextName,
+            abortSignal: abortController.signal,
+            values,
+        };
+        try {
+            const result = await cb(context, abortController);
+            return result;
+        }
+        catch (error) {
+            if (!error.executionContextName) {
+                error.executionContextName = context.name;
+            }
+            throw error;
+        }
+        finally {
+            if (abortListener) {
+                parentContext.abortSignal.removeEventListener('abort', abortListener);
+            }
+        }
+    }
+}
+
 exports.CommonModule = class CommonModule {
 };
 exports.CommonModule = tslib.__decorate([
@@ -1084,6 +1221,10 @@ exports.CommonModule = tslib.__decorate([
                     store: tokensCommon.STORE_TOKEN,
                 },
             }),
+            core.provide({
+                provide: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
+                useClass: ExecutionContextManager,
+            }),
             ...providers$2,
         ],
     })
@@ -1174,6 +1315,7 @@ Object.defineProperty(exports, 'COOKIE_MANAGER_TOKEN', {
     get: function () { return moduleCookie.COOKIE_MANAGER_TOKEN; }
 });
 exports.ActionExecution = ActionExecution;
+exports.ExecutionContextManager = ExecutionContextManager;
 exports.alwaysCondition = alwaysCondition;
 exports.createConsumerContext = createConsumerContext;
 exports.onlyBrowser = onlyBrowser;

package/lib/providers/clientProviders.d.ts

@@ -5,7 +5,7 @@ declare global {
     }
 }
 export declare const providers: ({
-    provide: import("@tinkoff/dippy/lib/createToken/createToken").BaseTokenInterface<{
+    provide: import("@tinkoff/dippy").BaseTokenInterface<{
         stores: Record<string, any>;
     }>;
     useFactory: () => any;
@@ -13,12 +13,12 @@ export declare const providers: ({
     deps?: undefined;
     multi?: undefined;
 } | {
-    provide: import("@tinkoff/dippy/lib/createToken/createToken").MultiTokenInterface<import("@tramvai/core").Command>;
+    provide: import("@tinkoff/dippy").MultiTokenInterface<import("@tramvai/core").Command>;
     useFactory: ({ commandLineRunner, }: {
         commandLineRunner: typeof COMMAND_LINE_RUNNER_TOKEN;
     }) => () => Promise<import("@tinkoff/dippy").Container>;
     deps: {
-        commandLineRunner: import("@tinkoff/dippy/lib/createToken/createToken").BaseTokenInterface<import("@tramvai/tokens-core").CommandLine>;
+        commandLineRunner: import("@tinkoff/dippy").BaseTokenInterface<import("@tramvai/tokens-core").CommandLine>;
     };
     multi: boolean;
     scope?: undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-common",
-  "version": "2.7.0",
+  "version": "2.11.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -28,30 +28,31 @@
     "build-for-publish": "true"
   },
   "dependencies": {
-    "@tinkoff/errors": "0.2.22",
+    "@tinkoff/errors": "0.2.23",
     "@tinkoff/hook-runner": "0.3.23",
     "@tinkoff/lru-cache-nano": "^7.8.1",
     "@tinkoff/pubsub": "0.4.25",
     "@tinkoff/url": "0.7.39",
-    "@tramvai/experiments": "2.7.0",
-    "@tramvai/module-cookie": "2.7.0",
-    "@tramvai/module-environment": "2.7.0",
-    "@tramvai/module-log": "2.7.0",
-    "@tramvai/tokens-child-app": "2.7.0",
-    "@tramvai/tokens-common": "2.7.0",
-    "@tramvai/tokens-render": "2.7.0",
-    "hoist-non-react-statics": "^3.3.1"
+    "@tramvai/experiments": "2.11.0",
+    "@tramvai/module-cookie": "2.11.0",
+    "@tramvai/module-environment": "2.11.0",
+    "@tramvai/module-log": "2.11.0",
+    "@tramvai/tokens-child-app": "2.11.0",
+    "@tramvai/tokens-common": "2.11.0",
+    "@tramvai/tokens-render": "2.11.0",
+    "hoist-non-react-statics": "^3.3.1",
+    "node-abort-controller": "^3.0.1"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.7.44",
+    "@tinkoff/dippy": "0.7.45",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "2.7.0",
-    "@tramvai/core": "2.7.0",
-    "@tramvai/papi": "2.7.0",
-    "@tramvai/react": "2.7.0",
-    "@tramvai/state": "2.7.0",
-    "@tramvai/tokens-metrics": "2.7.0",
-    "@tramvai/tokens-server": "2.7.0",
+    "@tramvai/cli": "2.11.0",
+    "@tramvai/core": "2.11.0",
+    "@tramvai/papi": "2.11.0",
+    "@tramvai/react": "2.11.0",
+    "@tramvai/state": "2.11.0",
+    "@tramvai/tokens-metrics": "2.11.0",
+    "@tramvai/tokens-server": "2.11.0",
     "react": ">=16.14.0",
     "tslib": "^2.0.3"
   },