@tramvai/module-common 5.16.2 → 5.17.0

package/lib/CommonModule.browser.js

@@ -4,8 +4,7 @@ import { Module, provide, Scope, BUNDLE_LIST_TOKEN, DI_TOKEN } from '@tramvai/co
 import { EnvironmentModule } from '@tramvai/module-environment';
 import { CookieModule } from '@tramvai/module-cookie';
 import { LogModule } from '@tramvai/module-log';
-import { Hooks } from '@tinkoff/hook-runner';
-import { HOOK_TOKEN, COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN, LOGGER_TOKEN, CONTEXT_TOKEN, PUBSUB_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN, LOGGER_TOKEN, CONTEXT_TOKEN, PUBSUB_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { BundleManager } from './bundleManager/bundleManager.browser.js';
 import { ComponentRegistry } from './componentRegistry/componentRegistry.browser.js';
 import { RequestManagerModule } from './requestManager/RequestManagerModule.browser.browser.js';
@@ -19,12 +18,14 @@ import { ActionModule } from './actions/ActionModule.browser.js';
 import { StateModule } from './state/StateModule.browser.js';
 import { CacheModule } from './cache/CacheModule.browser.js';
 import { ExecutionContextManager } from './executionContext/executionContextManager.browser.js';
+import { TramvaiHookModule } from './hook/HookModule.browser.js';
 
 let CommonModule = class CommonModule {
 };
 CommonModule = __decorate([
     Module({
         imports: [
+            TramvaiHookModule,
             CommandModule,
             EnvironmentModule,
             PubSubModule,
@@ -39,13 +40,6 @@ CommonModule = __decorate([
         ],
         providers: [
             provide({
-                // Инстанс хук системы
-                provide: HOOK_TOKEN,
-                scope: Scope.SINGLETON,
-                useClass: Hooks,
-            }),
-            provide({
-                // Регистр ui компонентов
                 provide: COMPONENT_REGISTRY_TOKEN,
                 scope: Scope.SINGLETON,
                 useClass: ComponentRegistry,
@@ -54,7 +48,6 @@ CommonModule = __decorate([
                 },
             }),
             provide({
-                // Управление бандлами, хранение и получение
                 provide: BUNDLE_MANAGER_TOKEN,
                 scope: Scope.SINGLETON,
                 useFactory: ({ additionalBundleList, ...bundleManagerDeps }) => {
@@ -77,7 +70,6 @@ CommonModule = __decorate([
                 },
             }),
             provide({
-                //  Клиентский контекст исполнения
                 provide: CONTEXT_TOKEN,
                 scope: Scope.REQUEST,
                 useFactory: createConsumerContext,

package/lib/CommonModule.es.js

@@ -4,8 +4,7 @@ import { Module, provide, Scope, BUNDLE_LIST_TOKEN, DI_TOKEN } from '@tramvai/co
 import { EnvironmentModule } from '@tramvai/module-environment';
 import { CookieModule } from '@tramvai/module-cookie';
 import { LogModule } from '@tramvai/module-log';
-import { Hooks } from '@tinkoff/hook-runner';
-import { HOOK_TOKEN, COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN, LOGGER_TOKEN, CONTEXT_TOKEN, PUBSUB_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN, LOGGER_TOKEN, CONTEXT_TOKEN, PUBSUB_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { BundleManager } from './bundleManager/bundleManager.es.js';
 import { ComponentRegistry } from './componentRegistry/componentRegistry.es.js';
 import { RequestManagerModule } from './requestManager/RequestManagerModule.es.js';
@@ -19,12 +18,14 @@ import { ActionModule } from './actions/ActionModule.es.js';
 import { StateModule } from './state/StateModule.es.js';
 import { CacheModule } from './cache/CacheModule.es.js';
 import { ExecutionContextManager } from './executionContext/executionContextManager.es.js';
+import { TramvaiHookModule } from './hook/HookModule.es.js';
 
 let CommonModule = class CommonModule {
 };
 CommonModule = __decorate([
     Module({
         imports: [
+            TramvaiHookModule,
             CommandModule,
             EnvironmentModule,
             PubSubModule,
@@ -39,13 +40,6 @@ CommonModule = __decorate([
         ],
         providers: [
             provide({
-                // Инстанс хук системы
-                provide: HOOK_TOKEN,
-                scope: Scope.SINGLETON,
-                useClass: Hooks,
-            }),
-            provide({
-                // Регистр ui компонентов
                 provide: COMPONENT_REGISTRY_TOKEN,
                 scope: Scope.SINGLETON,
                 useClass: ComponentRegistry,
@@ -54,7 +48,6 @@ CommonModule = __decorate([
                 },
             }),
             provide({
-                // Управление бандлами, хранение и получение
                 provide: BUNDLE_MANAGER_TOKEN,
                 scope: Scope.SINGLETON,
                 useFactory: ({ additionalBundleList, ...bundleManagerDeps }) => {
@@ -77,7 +70,6 @@ CommonModule = __decorate([
                 },
             }),
             provide({
-                //  Клиентский контекст исполнения
                 provide: CONTEXT_TOKEN,
                 scope: Scope.REQUEST,
                 useFactory: createConsumerContext,

package/lib/CommonModule.js

@@ -8,7 +8,6 @@ var core = require('@tramvai/core');
 var moduleEnvironment = require('@tramvai/module-environment');
 var moduleCookie = require('@tramvai/module-cookie');
 var moduleLog = require('@tramvai/module-log');
-var hookRunner = require('@tinkoff/hook-runner');
 var tokensCommon = require('@tramvai/tokens-common');
 var bundleManager = require('./bundleManager/bundleManager.js');
 var componentRegistry = require('./componentRegistry/componentRegistry.js');
@@ -23,6 +22,7 @@ var ActionModule = require('./actions/ActionModule.js');
 var StateModule = require('./state/StateModule.js');
 var CacheModule = require('./cache/CacheModule.js');
 var executionContextManager = require('./executionContext/executionContextManager.js');
+var HookModule = require('./hook/HookModule.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -33,6 +33,7 @@ exports.CommonModule = class CommonModule {
 exports.CommonModule = tslib.__decorate([
     core.Module({
         imports: [
+            HookModule.TramvaiHookModule,
             CommandModule.CommandModule,
             moduleEnvironment.EnvironmentModule,
             PubSubModule.PubSubModule,
@@ -47,13 +48,6 @@ exports.CommonModule = tslib.__decorate([
         ],
         providers: [
             core.provide({
-                // Инстанс хук системы
-                provide: tokensCommon.HOOK_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useClass: hookRunner.Hooks,
-            }),
-            core.provide({
-                // Регистр ui компонентов
                 provide: tokensCommon.COMPONENT_REGISTRY_TOKEN,
                 scope: core.Scope.SINGLETON,
                 useClass: componentRegistry.ComponentRegistry,
@@ -62,7 +56,6 @@ exports.CommonModule = tslib.__decorate([
                 },
             }),
             core.provide({
-                // Управление бандлами, хранение и получение
                 provide: tokensCommon.BUNDLE_MANAGER_TOKEN,
                 scope: core.Scope.SINGLETON,
                 useFactory: ({ additionalBundleList, ...bundleManagerDeps }) => {
@@ -85,7 +78,6 @@ exports.CommonModule = tslib.__decorate([
                 },
             }),
             core.provide({
-                //  Клиентский контекст исполнения
                 provide: tokensCommon.CONTEXT_TOKEN,
                 scope: core.Scope.REQUEST,
                 useFactory: createConsumerContext.createConsumerContext,

package/lib/command/CommandModule.browser.js

@@ -1,25 +1,28 @@
 import { __decorate } from 'tslib';
-import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN } from '@tramvai/core';
-import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, TAPABLE_HOOK_FACTORY_TOKEN, COMMAND_LINE_RUNNER_PLUGIN, DI_TOKEN } from '@tramvai/core';
 import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import { provide, Scope } from '@tinkoff/dippy';
-import { CommandLineRunner } from './commandLineRunner.browser.js';
+import { provide, Scope, optional } from '@tinkoff/dippy';
+import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { TramvaiHookModule } from '../hook/HookModule.browser.js';
 import { lines } from './defaultLines.browser.js';
+import { CommandLineRunner } from './commandLineRunner.new.browser.js';
 
 let CommandModule = class CommandModule {
 };
 CommandModule = __decorate([
     Module({
+        imports: [TramvaiHookModule],
         providers: [
             provide({
-                // Раннер процессов
                 provide: COMMAND_LINE_RUNNER_TOKEN,
                 scope: Scope.SINGLETON,
                 useClass: CommandLineRunner,
                 deps: {
+                    logger: LOGGER_TOKEN,
                     lines: COMMAND_LINES_TOKEN,
+                    hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
+                    plugins: optional(COMMAND_LINE_RUNNER_PLUGIN),
                     rootDi: DI_TOKEN,
-                    logger: LOGGER_TOKEN,
                     executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
                     executionEndHandlers: {
                         token: COMMAND_LINE_EXECUTION_END_TOKEN,
@@ -40,7 +43,6 @@ CommandModule = __decorate([
                 },
             }),
             provide({
-                // Дефолтный список команл
                 provide: COMMAND_LINES_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: lines,

package/lib/command/CommandModule.es.js

@@ -1,25 +1,28 @@
 import { __decorate } from 'tslib';
-import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN } from '@tramvai/core';
-import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, TAPABLE_HOOK_FACTORY_TOKEN, COMMAND_LINE_RUNNER_PLUGIN, DI_TOKEN } from '@tramvai/core';
 import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import { provide, Scope } from '@tinkoff/dippy';
-import { CommandLineRunner } from './commandLineRunner.es.js';
+import { provide, Scope, optional } from '@tinkoff/dippy';
+import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { TramvaiHookModule } from '../hook/HookModule.es.js';
 import { lines } from './defaultLines.es.js';
+import { CommandLineRunner } from './commandLineRunner.new.es.js';
 
 let CommandModule = class CommandModule {
 };
 CommandModule = __decorate([
     Module({
+        imports: [TramvaiHookModule],
         providers: [
             provide({
-                // Раннер процессов
                 provide: COMMAND_LINE_RUNNER_TOKEN,
                 scope: Scope.SINGLETON,
                 useClass: CommandLineRunner,
                 deps: {
+                    logger: LOGGER_TOKEN,
                     lines: COMMAND_LINES_TOKEN,
+                    hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
+                    plugins: optional(COMMAND_LINE_RUNNER_PLUGIN),
                     rootDi: DI_TOKEN,
-                    logger: LOGGER_TOKEN,
                     executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
                     executionEndHandlers: {
                         token: COMMAND_LINE_EXECUTION_END_TOKEN,
@@ -40,7 +43,6 @@ CommandModule = __decorate([
                 },
             }),
             provide({
-                // Дефолтный список команл
                 provide: COMMAND_LINES_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: lines,

package/lib/command/CommandModule.js

@@ -4,26 +4,29 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var core = require('@tramvai/core');
-var tokensCorePrivate = require('@tramvai/tokens-core-private');
 var tokensCommon = require('@tramvai/tokens-common');
 var dippy = require('@tinkoff/dippy');
-var commandLineRunner = require('./commandLineRunner.js');
+var tokensCorePrivate = require('@tramvai/tokens-core-private');
+var HookModule = require('../hook/HookModule.js');
 var defaultLines = require('./defaultLines.js');
+var commandLineRunner_new = require('./commandLineRunner.new.js');
 
 exports.CommandModule = class CommandModule {
 };
 exports.CommandModule = tslib.__decorate([
     core.Module({
+        imports: [HookModule.TramvaiHookModule],
         providers: [
             dippy.provide({
-                // Раннер процессов
                 provide: core.COMMAND_LINE_RUNNER_TOKEN,
                 scope: dippy.Scope.SINGLETON,
-                useClass: commandLineRunner.CommandLineRunner,
+                useClass: commandLineRunner_new.CommandLineRunner,
                 deps: {
+                    logger: tokensCommon.LOGGER_TOKEN,
                     lines: core.COMMAND_LINES_TOKEN,
+                    hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
+                    plugins: dippy.optional(core.COMMAND_LINE_RUNNER_PLUGIN),
                     rootDi: core.DI_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
                     executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
                     executionEndHandlers: {
                         token: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
@@ -44,7 +47,6 @@ exports.CommandModule = tslib.__decorate([
                 },
             }),
             dippy.provide({
-                // Дефолтный список команл
                 provide: core.COMMAND_LINES_TOKEN,
                 scope: dippy.Scope.SINGLETON,
                 useValue: defaultLines.lines,

package/lib/command/commandLineRunner.new.browser.js

@@ -0,0 +1,159 @@
+import { createChildContainer } from '@tinkoff/dippy';
+import { isSilentError } from '@tinkoff/errors';
+import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { COMMAND_LINE_TIMING_INFO_TOKEN } from '@tramvai/tokens-core-private';
+
+class CommandLineRunner {
+    constructor({ rootDi, lines, logger, plugins, hookFactory, executionContextManager, executionEndHandlers, }) {
+        this.executionContextByDi = new WeakMap();
+        this.abortControllerByDi = new WeakMap();
+        this.rootDi = rootDi;
+        this.lines = lines;
+        this.hookFactory = hookFactory;
+        this.plugins = plugins;
+        this.executionContextManager = executionContextManager;
+        this.executionEndHandlers = executionEndHandlers;
+        this.log = logger('command:command-line-runner');
+        this.runLineHook = this.hookFactory.createAsync('runLine');
+        this.runCommandHook = this.hookFactory.createAsync('runCommand');
+        this.runCommandFnHook = this.hookFactory.createAsync('runCommandFn');
+        this.runLineHook.tapPromise('commandLineRunner', async (_, { env, line, di, key }) => {
+            const commands = this.lines[env][line];
+            const timingInfo = {};
+            di.register({ provide: COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
+            this.log.debug({
+                event: 'command-run',
+                type: env,
+                status: line,
+            });
+            try {
+                for (const command of commands) {
+                    // emulate old `CommandLineRunner` behavior, important for race conditions at client-side,
+                    // when new line executes in the middle of current line, and we need cleanup current line before
+                    await Promise.resolve();
+                    await this.runCommandHook.callPromise({
+                        env,
+                        line,
+                        di,
+                        command,
+                    });
+                }
+            }
+            finally {
+                this.executionContextByDi.delete(di);
+                this.abortControllerByDi.delete(di);
+                for (const executionEndHandler of this.executionEndHandlers) {
+                    executionEndHandler(di, env, line, timingInfo, key);
+                }
+            }
+        });
+        this.runCommandHook.tapPromise('commandLineRunner', async (_, { env, line, di, command }) => {
+            const commands = di.get({ token: command, optional: true });
+            if (!commands) {
+                return;
+            }
+            const rootExecutionContext = di.get({ token: ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
+            const timingInfo = di.get(COMMAND_LINE_TIMING_INFO_TOKEN);
+            const commandName = command.toString();
+            timingInfo[commandName] = { start: performance.now() };
+            return this.executionContextManager
+                .withContext(rootExecutionContext, `command-line:${commandName}`, async (executionContext, abortController) => {
+                this.executionContextByDi.set(di, executionContext);
+                this.abortControllerByDi.set(di, abortController);
+                if (!Array.isArray(commands)) {
+                    await this.runCommandFnHook.callPromise({ fn: commands, line, command, di });
+                }
+                else {
+                    await Promise.all(commands.map((fn) => {
+                        return this.runCommandFnHook.callPromise({ fn, line, command, di });
+                    }));
+                }
+            })
+                .finally(() => {
+                timingInfo[commandName].end = performance.now();
+            });
+        });
+        this.runCommandFnHook.tapPromise('commandLineRunner', async (_, { fn, command, di }) => {
+            try {
+                await this.executeCommand(fn, command, di);
+            }
+            catch (error) {
+                // in case if any error happens during line execution results from other line handlers will not be used anyway
+                this.abortControllerByDi
+                    .get(di)
+                    ?.abort('Execution context were aborted because of one of the commands failed');
+                throw error;
+            }
+        });
+        this.plugins?.forEach((plugin) => {
+            plugin.apply(this);
+        });
+    }
+    async run(env, line, providers, customDi, key) {
+        const di = customDi ?? this.resolveDi(env, line, this.rootDi, providers);
+        await this.runLineHook.callPromise({ env, line, di, key });
+        return di;
+    }
+    resolveDi(env, line, rootDi, providers) {
+        let di = rootDi;
+        if (env === 'server' && line === 'customer') {
+            di = createChildContainer(di);
+        }
+        if (providers) {
+            providers.forEach((item) => {
+                return di.register(item);
+            });
+        }
+        return di;
+    }
+    resolveExecutionContextFromDi(di) {
+        return this.executionContextByDi.get(di) ?? null;
+    }
+    async executeCommand(command, commandToken, di) {
+        const commandName = commandToken.toString();
+        if (!(command instanceof Function)) {
+            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${commandName}", received "${command}".
+      Check that all commandLineListTokens providers return functions`);
+            if (process.env.NODE_ENV !== 'production') {
+                const commands = di.get(commandToken);
+                const record = di.getRecord(commandToken.name);
+                // need to find stack trace from this specific token provider
+                for (let i = 0; i < commands.length; i++) {
+                    if (commands[i] === command) {
+                        // @ts-expect-error
+                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
+                    }
+                }
+            }
+            this.log.error({
+                event: 'line-error',
+                error,
+                line: commandName,
+            });
+            return;
+        }
+        const { name = '' } = command;
+        this.log.debug({
+            event: 'line-run',
+            line: commandName,
+            command: name,
+        });
+        try {
+            await command();
+        }
+        catch (error) {
+            this.log[isSilentError(error) ? 'debug' : 'error']({
+                event: 'line-error',
+                error,
+                line: commandName,
+                command: name,
+            });
+            if (typeof error === 'object') {
+                error.di = di;
+            }
+            throw error;
+        }
+    }
+}
+
+export { CommandLineRunner };

package/lib/command/commandLineRunner.new.d.ts

@@ -0,0 +1,57 @@
+import type { MultiTokenInterface, Provider } from '@tinkoff/dippy';
+import type { AsyncTapableHookInstance, CommandLineDescription, CommandLineRunnerPlugin, CommandLines } from '@tramvai/core';
+import type { COMMAND_LINES_TOKEN, Command, DI_TOKEN, ExtractDependencyType, CommandLineRunner as Interface, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
+import { type EXECUTION_CONTEXT_MANAGER_TOKEN, type ExecutionContext, type LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { type COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+type Container = ExtractDependencyType<typeof DI_TOKEN>;
+type Lines = ExtractDependencyType<typeof COMMAND_LINES_TOKEN>;
+export type CommandEnvironment = 'server' | 'client';
+export type CommandLine = 'init' | 'customer' | 'spa' | 'afterSpa' | 'close';
+type LoggerFactory = ExtractDependencyType<typeof LOGGER_TOKEN>;
+type HookFactory = ExtractDependencyType<typeof TAPABLE_HOOK_FACTORY_TOKEN>;
+type ExecutionContextManager = ExtractDependencyType<typeof EXECUTION_CONTEXT_MANAGER_TOKEN>;
+type ExecutionEndHandlers = ExtractDependencyType<typeof COMMAND_LINE_EXECUTION_END_TOKEN> | null;
+export declare class CommandLineRunner implements Interface {
+    private rootDi;
+    private log;
+    private hookFactory;
+    private plugins;
+    private executionContextManager;
+    private executionEndHandlers;
+    private executionContextByDi;
+    private abortControllerByDi;
+    lines: Lines;
+    runLineHook: AsyncTapableHookInstance<{
+        env: keyof CommandLines;
+        line: keyof CommandLineDescription;
+        di: Container;
+        key?: string | number;
+    }>;
+    runCommandHook: AsyncTapableHookInstance<{
+        env: keyof CommandLines;
+        line: keyof CommandLineDescription;
+        di: Container;
+        command: MultiTokenInterface<Command>;
+    }>;
+    runCommandFnHook: AsyncTapableHookInstance<{
+        fn: Command;
+        line: keyof CommandLineDescription;
+        command: MultiTokenInterface<Command>;
+        di: Container;
+    }>;
+    constructor({ rootDi, lines, logger, plugins, hookFactory, executionContextManager, executionEndHandlers, }: {
+        rootDi: Container;
+        lines: Lines;
+        logger: LoggerFactory;
+        plugins: CommandLineRunnerPlugin[] | null;
+        hookFactory: HookFactory;
+        executionContextManager: ExecutionContextManager;
+        executionEndHandlers: ExecutionEndHandlers;
+    });
+    run(env: CommandEnvironment, line: 'init' | 'customer' | 'spa' | 'afterSpa' | 'close', providers?: Provider[], customDi?: Container, key?: string | number): Promise<import("@tinkoff/dippy").Container>;
+    resolveDi(env: CommandEnvironment, line: CommandLine, rootDi: Container, providers?: Provider[]): Container;
+    resolveExecutionContextFromDi(di: Container): ExecutionContext | null;
+    private executeCommand;
+}
+export {};
+//# sourceMappingURL=commandLineRunner.new.d.ts.map

package/lib/command/commandLineRunner.new.es.js

@@ -0,0 +1,159 @@
+import { createChildContainer } from '@tinkoff/dippy';
+import { isSilentError } from '@tinkoff/errors';
+import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { COMMAND_LINE_TIMING_INFO_TOKEN } from '@tramvai/tokens-core-private';
+
+class CommandLineRunner {
+    constructor({ rootDi, lines, logger, plugins, hookFactory, executionContextManager, executionEndHandlers, }) {
+        this.executionContextByDi = new WeakMap();
+        this.abortControllerByDi = new WeakMap();
+        this.rootDi = rootDi;
+        this.lines = lines;
+        this.hookFactory = hookFactory;
+        this.plugins = plugins;
+        this.executionContextManager = executionContextManager;
+        this.executionEndHandlers = executionEndHandlers;
+        this.log = logger('command:command-line-runner');
+        this.runLineHook = this.hookFactory.createAsync('runLine');
+        this.runCommandHook = this.hookFactory.createAsync('runCommand');
+        this.runCommandFnHook = this.hookFactory.createAsync('runCommandFn');
+        this.runLineHook.tapPromise('commandLineRunner', async (_, { env, line, di, key }) => {
+            const commands = this.lines[env][line];
+            const timingInfo = {};
+            di.register({ provide: COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
+            this.log.debug({
+                event: 'command-run',
+                type: env,
+                status: line,
+            });
+            try {
+                for (const command of commands) {
+                    // emulate old `CommandLineRunner` behavior, important for race conditions at client-side,
+                    // when new line executes in the middle of current line, and we need cleanup current line before
+                    await Promise.resolve();
+                    await this.runCommandHook.callPromise({
+                        env,
+                        line,
+                        di,
+                        command,
+                    });
+                }
+            }
+            finally {
+                this.executionContextByDi.delete(di);
+                this.abortControllerByDi.delete(di);
+                for (const executionEndHandler of this.executionEndHandlers) {
+                    executionEndHandler(di, env, line, timingInfo, key);
+                }
+            }
+        });
+        this.runCommandHook.tapPromise('commandLineRunner', async (_, { env, line, di, command }) => {
+            const commands = di.get({ token: command, optional: true });
+            if (!commands) {
+                return;
+            }
+            const rootExecutionContext = di.get({ token: ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
+            const timingInfo = di.get(COMMAND_LINE_TIMING_INFO_TOKEN);
+            const commandName = command.toString();
+            timingInfo[commandName] = { start: performance.now() };
+            return this.executionContextManager
+                .withContext(rootExecutionContext, `command-line:${commandName}`, async (executionContext, abortController) => {
+                this.executionContextByDi.set(di, executionContext);
+                this.abortControllerByDi.set(di, abortController);
+                if (!Array.isArray(commands)) {
+                    await this.runCommandFnHook.callPromise({ fn: commands, line, command, di });
+                }
+                else {
+                    await Promise.all(commands.map((fn) => {
+                        return this.runCommandFnHook.callPromise({ fn, line, command, di });
+                    }));
+                }
+            })
+                .finally(() => {
+                timingInfo[commandName].end = performance.now();
+            });
+        });
+        this.runCommandFnHook.tapPromise('commandLineRunner', async (_, { fn, command, di }) => {
+            try {
+                await this.executeCommand(fn, command, di);
+            }
+            catch (error) {
+                // in case if any error happens during line execution results from other line handlers will not be used anyway
+                this.abortControllerByDi
+                    .get(di)
+                    ?.abort('Execution context were aborted because of one of the commands failed');
+                throw error;
+            }
+        });
+        this.plugins?.forEach((plugin) => {
+            plugin.apply(this);
+        });
+    }
+    async run(env, line, providers, customDi, key) {
+        const di = customDi ?? this.resolveDi(env, line, this.rootDi, providers);
+        await this.runLineHook.callPromise({ env, line, di, key });
+        return di;
+    }
+    resolveDi(env, line, rootDi, providers) {
+        let di = rootDi;
+        if (env === 'server' && line === 'customer') {
+            di = createChildContainer(di);
+        }
+        if (providers) {
+            providers.forEach((item) => {
+                return di.register(item);
+            });
+        }
+        return di;
+    }
+    resolveExecutionContextFromDi(di) {
+        return this.executionContextByDi.get(di) ?? null;
+    }
+    async executeCommand(command, commandToken, di) {
+        const commandName = commandToken.toString();
+        if (!(command instanceof Function)) {
+            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${commandName}", received "${command}".
+      Check that all commandLineListTokens providers return functions`);
+            if (process.env.NODE_ENV !== 'production') {
+                const commands = di.get(commandToken);
+                const record = di.getRecord(commandToken.name);
+                // need to find stack trace from this specific token provider
+                for (let i = 0; i < commands.length; i++) {
+                    if (commands[i] === command) {
+                        // @ts-expect-error
+                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
+                    }
+                }
+            }
+            this.log.error({
+                event: 'line-error',
+                error,
+                line: commandName,
+            });
+            return;
+        }
+        const { name = '' } = command;
+        this.log.debug({
+            event: 'line-run',
+            line: commandName,
+            command: name,
+        });
+        try {
+            await command();
+        }
+        catch (error) {
+            this.log[isSilentError(error) ? 'debug' : 'error']({
+                event: 'line-error',
+                error,
+                line: commandName,
+                command: name,
+            });
+            if (typeof error === 'object') {
+                error.di = di;
+            }
+            throw error;
+        }
+    }
+}
+
+export { CommandLineRunner };