@chevre/domain 22.11.0-alpha.3 → 22.11.0-alpha.30

package/lib/chevre/service/task.d.ts

@@ -1,7 +1,6 @@
 import { SendGridCredentials } from '../credentials/sendGrid';
 import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction, IReadyTask, IRunningTask } from '../eventEmitter/task';
 import * as factory from '../factory';
-import type { IExecutableTask, IExecutableTaskKeys, TaskRepo } from '../repo/task';
 import { Settings } from '../settings';
 import { AggregationSettings } from '../settings/aggregation';
 interface ICredentialSettings {
@@ -12,14 +11,7 @@ interface IExecuteSettings extends IMinimumExecuteSettings {
     settings: Settings;
     aggregationSettings?: AggregationSettings;
 }
-interface IExecuteOptions {
-    executeById: boolean;
-    executeByName: boolean;
-}
 type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
-type IOperationExecute<T> = (settings: IExecuteSettings, options: IExecuteOptions) => Promise<T>;
-type ICallResult = void | Pick<factory.task.IExecutionResult, 'error'>;
-export type ICallableTaskOperation = (task: IExecutableTask<factory.taskName>) => IOperationExecute<ICallResult>;
 /**
  * タスク変更イベントを受けて実行する
  */
@@ -31,13 +23,9 @@ declare function executeById(params: (IReadyTask | IRunningTask) & {
         name: string;
     };
 }, next?: INextFunction): IOperation<void>;
-/**
- * support no name(2025-03-04~)
- */
 declare function executeOneIfExists(params: {
-    name?: {
-        $eq?: factory.taskName;
-        $nin?: factory.taskName[];
+    name: {
+        $eq: factory.taskName;
     };
     executor: {
         /**
@@ -48,19 +36,9 @@ declare function executeOneIfExists(params: {
     runsAt: {
         $lt: Date;
     };
+    sort: {
+        numberOfTried?: factory.sortType;
+        runsAt?: factory.sortType;
+    };
 }): IOperation<void>;
-/**
- * タスクを実行する
- */
-declare function execute(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
-/**
- * add(2025-03-13~)
- */
-declare function notifyAbortedTasksByEmail(params: {
-    dateAbortedGte: Date;
-}): (repos: {
-    task: TaskRepo;
-}, settings: Pick<Settings, "abortedTasksWithoutReport">, credentials: {
-    sendGrid: SendGridCredentials;
-}) => Promise<void>;
-export { ICallResult, IExecutableTaskKeys, IOperationExecute, executeById, executeOneIfExists, execute, notifyAbortedTasksByEmail };
+export { executeById, executeOneIfExists };

package/lib/chevre/service/task.js

@@ -11,15 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeById = executeById;
 exports.executeOneIfExists = executeOneIfExists;
-exports.execute = execute;
-exports.notifyAbortedTasksByEmail = notifyAbortedTasksByEmail;
 /**
  * タスクサービス
  */
 const createDebug = require("debug");
-const moment = require("moment");
-const factory = require("../factory");
-const factory_1 = require("./notification/factory");
+const taskHandler_1 = require("./taskHandler");
 const debug = createDebug('chevre-domain:service:task');
 /**
  * タスク変更イベントを受けて実行する
@@ -42,16 +38,13 @@ function executeById(params, next) {
         }
         // タスクがなければ終了
         if (task !== null) {
-            yield execute(task, (typeof next === 'function') ? next : undefined)(settings, {
+            yield (0, taskHandler_1.executeTask)(task, (typeof next === 'function') ? next : undefined)(settings, {
                 executeById: true,
                 executeByName: false
             });
         }
     });
 }
-/**
- * support no name(2025-03-04~)
- */
 function executeOneIfExists(params) {
     return (settings) => __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -60,7 +53,12 @@ function executeOneIfExists(params) {
         // tslint:disable-next-line:no-null-keyword
         let task = null;
         try {
-            task = yield taskRepo.executeOneIfExists(Object.assign({ executor: { name: params.executor.name }, runsAt: { $lt: params.runsAt.$lt } }, (params.name !== undefined) ? { name: params.name } : undefined));
+            task = yield taskRepo.executeOneIfExists({
+                executor: { name: params.executor.name },
+                runsAt: { $lt: params.runsAt.$lt },
+                name: params.name,
+                sort: params.sort
+            });
             debug('executable task found.', task, params.runsAt.$lt);
         }
         catch (error) {
@@ -70,113 +68,10 @@ function executeOneIfExists(params) {
         }
         // タスクがなければ終了
         if (task !== null) {
-            yield execute(task)(settings, {
+            yield (0, taskHandler_1.executeTask)(task)(settings, {
                 executeById: false,
                 executeByName: (typeof ((_a = params.name) === null || _a === void 0 ? void 0 : _a.$eq) === 'string')
             });
         }
     });
 }
-/**
- * タスクを実行する
- */
-function execute(task, next) {
-    const now = new Date();
-    debug('executing an executableTask...', task, now);
-    return (settings, options) => __awaiter(this, void 0, void 0, function* () {
-        const taskRepo = new (yield Promise.resolve().then(() => require('../repo/task'))).TaskRepo(settings.connection);
-        try {
-            // 期限検証(2024-04-23~)
-            if (task.expires instanceof Date) {
-                const taskExpired = moment(now)
-                    .isAfter(task.expires);
-                if (taskExpired) {
-                    throw new factory.errors.Internal(`task expired [expires:${task.expires}]`);
-                }
-            }
-            // タスク名の関数が定義されていなければ、TypeErrorとなる
-            let callResult;
-            const { call } = yield Promise.resolve(`${`./task/${task.name}`}`).then(s => require(s));
-            switch (task.name) {
-                case factory.taskName.AcceptCOAOffer:
-                case factory.taskName.AggregateOnSystem:
-                case factory.taskName.AuthorizePayment:
-                case factory.taskName.CancelPendingReservation:
-                case factory.taskName.CheckMovieTicket:
-                case factory.taskName.DeletePerson:
-                case factory.taskName.HandleNotification:
-                case factory.taskName.ImportEventCapacitiesFromCOA:
-                case factory.taskName.ImportEventsFromCOA:
-                case factory.taskName.ImportOffersFromCOA:
-                case factory.taskName.InvalidatePaymentUrl:
-                case factory.taskName.OnAuthorizationCreated:
-                case factory.taskName.Pay:
-                case factory.taskName.PublishPaymentUrl:
-                case factory.taskName.Refund:
-                case factory.taskName.VoidPayTransaction:
-                case factory.taskName.VoidReserveTransaction:
-                case factory.taskName.ConfirmReserveTransaction:
-                case factory.taskName.ReturnPayTransaction:
-                case factory.taskName.ReturnReserveTransaction:
-                case factory.taskName.SendEmailMessage:
-                case factory.taskName.TriggerWebhook:
-                    callResult = yield call(task)(settings, options);
-                    break;
-                default:
-                    yield call(task.data)(settings);
-            }
-            const result = {
-                executedAt: now,
-                endDate: new Date(),
-                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
-                error: ((callResult === null || callResult === void 0 ? void 0 : callResult.error) instanceof Error)
-                    ? Object.assign(Object.assign({}, callResult.error), { message: callResult.error.message }) : ''
-            };
-            yield taskRepo.pushExecutionResultById({
-                id: task.id,
-                status: factory.taskStatus.Executed
-            }, result, (typeof next === 'function') ? next : undefined);
-        }
-        catch (error) {
-            debug('service.task.execute throwed an error. task:', task.name, task.id, 'error:', error === null || error === void 0 ? void 0 : error.name, error === null || error === void 0 ? void 0 : error.message);
-            if (typeof error !== 'object') {
-                error = { message: String(error) };
-            }
-            // 実行結果追加
-            const result = {
-                executedAt: now,
-                endDate: new Date(),
-                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
-            };
-            // 失敗してもここではステータスを戻さない(Runningのまま待機)
-            yield taskRepo.pushExecutionResultById({
-                id: task.id,
-                status: task.status
-            }, result, (typeof next === 'function') ? next : undefined);
-        }
-    });
-}
-let notification;
-/**
- * add(2025-03-13~)
- */
-function notifyAbortedTasksByEmail(params) {
-    return (repos, settings, credentials) => __awaiter(this, void 0, void 0, function* () {
-        const { abortedTasksWithoutReport } = settings;
-        const abortedTasks = yield repos.task.projectFields(Object.assign({ status: { $eq: factory.taskStatus.Aborted }, dateAborted: { $gte: params.dateAbortedGte } }, (abortedTasksWithoutReport.length > 0)
-            ? { name: { $nin: abortedTasksWithoutReport } }
-            : undefined), []);
-        if (abortedTasks.length > 0) {
-            if (notification === undefined) {
-                notification = yield Promise.resolve().then(() => require('./notification'));
-            }
-            // 開発者へ報告
-            const message = (0, factory_1.tasks2lineNotify)({ tasks: abortedTasks });
-            const notifyResult = yield notification.notifyByEmail({
-                subject: message.subject, content: message.content,
-                logLevel: 'error'
-            })({}, credentials);
-            debug('notifyResult:', notifyResult);
-        }
-    });
-}

package/lib/chevre/service/taskHandler/onOperationFailed/informTaskIfNeeded.d.ts

@@ -0,0 +1,11 @@
+import * as factory from '../../../factory';
+import type { SettingRepo } from '../../../repo/setting';
+import type { IExecutableTask, TaskRepo } from '../../../repo/task';
+declare function informTaskIfNeeded(params: {
+    task: IExecutableTask<factory.taskName>;
+    executionEndDate: Date;
+}): (repos: {
+    setting: SettingRepo;
+    task: TaskRepo;
+}) => Promise<void>;
+export { informTaskIfNeeded };

package/lib/chevre/service/taskHandler/onOperationFailed/informTaskIfNeeded.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.informTaskIfNeeded = informTaskIfNeeded;
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service:taskHandler:onOperationFailed');
+function createInformTasks(params) {
+    var _a, _b, _c;
+    const { task, setting, executionEndDate } = params;
+    const informTask = (_a = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _a === void 0 ? void 0 : _a.informTask;
+    const informTaskNames = (_b = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _b === void 0 ? void 0 : _b.informTaskNames;
+    const informTaskStatuses = (_c = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _c === void 0 ? void 0 : _c.informTaskStatuses;
+    const informTasks = [];
+    if (Array.isArray(informTaskNames) && informTaskNames.includes(task.name)) {
+        if (Array.isArray(informTaskStatuses)) {
+            const { id, name, data, project, runsAt, remainingNumberOfTries } = task;
+            let task4inform;
+            if (remainingNumberOfTries <= 0) {
+                if (informTaskStatuses.includes(factory.taskStatus.Aborted)) {
+                    const abortingTask = {
+                        id, name, data, project, runsAt,
+                        status: factory.taskStatus.Aborted,
+                        typeOf: 'Task',
+                        dateAborted: executionEndDate
+                    };
+                    task4inform = abortingTask;
+                }
+            }
+            else {
+                if (informTaskStatuses.includes(factory.taskStatus.Running)) {
+                    const runningTask = {
+                        id, name, data, project, runsAt,
+                        status: factory.taskStatus.Running,
+                        typeOf: 'Task'
+                    };
+                    task4inform = runningTask;
+                }
+            }
+            if (task4inform !== undefined) {
+                const informIdentifier = `Task:${name}:${id}:${task4inform.status}`;
+                if (Array.isArray(informTask) && informTask.length > 0) {
+                    informTask.forEach((informTaskParams) => {
+                        var _a, _b;
+                        if (typeof ((_a = informTaskParams.recipient) === null || _a === void 0 ? void 0 : _a.url) === 'string') {
+                            const informActionAttributes = {
+                                object: task4inform,
+                                recipient: {
+                                    id: '',
+                                    name: String((_b = informTaskParams.recipient) === null || _b === void 0 ? void 0 : _b.name),
+                                    typeOf: factory.creativeWorkType.WebApplication
+                                },
+                                target: {
+                                    httpMethod: 'POST',
+                                    encodingType: factory.encodingFormat.Application.json,
+                                    typeOf: 'EntryPoint',
+                                    urlTemplate: informTaskParams.recipient.url
+                                },
+                                identifier: informIdentifier
+                            };
+                            const description = `inform aborting tasks to agg service: ${name} ${id} ${task4inform.status}`;
+                            informTasks.push({
+                                project,
+                                name: factory.taskName.TriggerWebhook,
+                                status: factory.taskStatus.Ready,
+                                runsAt: executionEndDate,
+                                remainingNumberOfTries: 10,
+                                numberOfTried: 0,
+                                executionResults: [],
+                                data: informActionAttributes,
+                                description
+                            });
+                        }
+                    });
+                }
+            }
+        }
+    }
+    return informTasks;
+}
+function informTaskIfNeeded(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const { executionEndDate, task } = params;
+        const isAborting = task.status === factory.taskStatus.Running;
+        const useInform = isAborting
+            && task.name !== factory.taskName.HandleNotification // nameで絞る
+            && task.name !== factory.taskName.TriggerWebhook;
+        if (useInform) {
+            const setting = yield repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['onTaskStatusChanged']);
+            const informTasks = createInformTasks({ task, setting, executionEndDate });
+            debug('informTaskIfNeeded: creating inform tasks...', JSON.stringify(informTasks));
+            if (informTasks.length > 0) {
+                yield repos.task.saveMany(informTasks, { emitImmediately: true });
+            }
+        }
+    });
+}

package/lib/chevre/service/taskHandler/onOperationFailed.d.ts

@@ -0,0 +1,17 @@
+import type { INextFunction } from '../../eventEmitter/task';
+import * as factory from '../../factory';
+import type { SettingRepo } from '../../repo/setting';
+import type { IExecutableTask, TaskRepo } from '../../repo/task';
+/**
+ * タスク実行失敗時処理
+ */
+declare function onOperationFailed(params: {
+    task: IExecutableTask<factory.taskName>;
+    now: Date;
+    error: any;
+    next?: INextFunction;
+}): (repos: {
+    setting: SettingRepo;
+    task: TaskRepo;
+}) => Promise<void>;
+export { onOperationFailed };

package/lib/chevre/service/taskHandler/onOperationFailed.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperationFailed = onOperationFailed;
+const factory = require("../../factory");
+const informTaskIfNeeded_1 = require("./onOperationFailed/informTaskIfNeeded");
+const USE_INFORM_TASK_RUNNING = process.env.USE_INFORM_TASK_RUNNING === '1';
+/**
+ * タスク実行失敗時処理
+ */
+function onOperationFailed(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let error = params.error;
+        const { task, now, next } = params;
+        if (typeof error !== 'object') {
+            error = { message: String(error) };
+        }
+        const endDate = new Date();
+        // remainingNumberOfTries<=0ならAborted(2025-08-04~)
+        const isRetryable = task.remainingNumberOfTries > 0;
+        if (isRetryable) {
+            // 実験的に実行中タスク連携
+            if (USE_INFORM_TASK_RUNNING) {
+                yield (0, informTaskIfNeeded_1.informTaskIfNeeded)({ task, executionEndDate: endDate })(repos);
+            }
+            const result = {
+                executedAt: now,
+                endDate,
+                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
+            };
+            // 失敗してもここではステータスを戻さない(Runningのまま待機)
+            yield repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: task.status,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+        else {
+            // 分析連携(2025-08-05~)
+            // 設定されたnameの場合連携する
+            // もしここで連携タスク作成に失敗したとしても、再度Readyタスクとなりリトライされて、処理は冪等となる想定
+            // 最終的に、連携タスクが作成され、実行中タスクがAbortedとなればよい
+            yield (0, informTaskIfNeeded_1.informTaskIfNeeded)({ task, executionEndDate: endDate })(repos);
+            const result = {
+                executedAt: now,
+                endDate,
+                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
+            };
+            yield repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory.taskStatus.Aborted,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+    });
+}

package/lib/chevre/service/taskHandler.d.ts

@@ -0,0 +1,26 @@
+import type { SendGridCredentials } from '../credentials/sendGrid';
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction } from '../eventEmitter/task';
+import * as factory from '../factory';
+import type { IExecutableTask, IExecutableTaskKeys } from '../repo/task';
+import type { Settings } from '../settings';
+import type { AggregationSettings } from '../settings/aggregation';
+interface ICredentialSettings {
+    sendGrid: SendGridCredentials;
+}
+interface IExecuteSettings extends IMinimumExecuteSettings {
+    credentials: ICredentialSettings;
+    settings: Settings;
+    aggregationSettings?: AggregationSettings;
+}
+interface IExecuteOptions {
+    executeById: boolean;
+    executeByName: boolean;
+}
+type IOperationExecute<T> = (settings: IExecuteSettings, options: IExecuteOptions) => Promise<T>;
+type ICallResult = void | Pick<factory.task.IExecutionResult, 'error'>;
+type ICallableTaskOperation = (task: IExecutableTask<factory.taskName>) => IOperationExecute<ICallResult>;
+/**
+ * タスクを実行する
+ */
+declare function executeTask(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
+export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeTask };

package/lib/chevre/service/taskHandler.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTask = executeTask;
+const createDebug = require("debug");
+const moment = require("moment");
+const factory = require("../factory");
+const onOperationFailed_1 = require("./taskHandler/onOperationFailed");
+const debug = createDebug('chevre-domain:service:taskHandler');
+/**
+ * タスクを実行する
+ */
+// tslint:disable-next-line:max-func-body-length
+function executeTask(task, next) {
+    const now = new Date();
+    debug('executing an executableTask...', task, now);
+    return (settings, options) => __awaiter(this, void 0, void 0, function* () {
+        const settingRepo = new (yield Promise.resolve().then(() => require('../repo/setting'))).SettingRepo(settings.connection);
+        const taskRepo = new (yield Promise.resolve().then(() => require('../repo/task'))).TaskRepo(settings.connection);
+        try {
+            // 期限検証(2024-04-23~)
+            if (task.expires instanceof Date) {
+                const taskExpired = moment(now)
+                    .isAfter(task.expires);
+                if (taskExpired) {
+                    throw new factory.errors.Internal(`task expired [expires:${task.expires}]`);
+                }
+            }
+            // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
+            // リトライを繰り返した後、不明の原因でRunningのまま残ってしまったタスクがリトライされたケース
+            const { remainingNumberOfTries } = task;
+            const isCallable = remainingNumberOfTries >= 0;
+            if (!isCallable) {
+                throw new factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
+            }
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            let callResult;
+            const { call } = yield Promise.resolve(`${`./task/${task.name}`}`).then(s => require(s));
+            switch (task.name) {
+                case factory.taskName.AcceptCOAOffer:
+                case factory.taskName.AggregateOnSystem:
+                case factory.taskName.AuthorizePayment:
+                case factory.taskName.CancelPendingReservation:
+                case factory.taskName.CheckMovieTicket:
+                case factory.taskName.DeletePerson:
+                case factory.taskName.HandleNotification:
+                case factory.taskName.ImportEventCapacitiesFromCOA:
+                case factory.taskName.ImportEventsFromCOA:
+                case factory.taskName.ImportOffersFromCOA:
+                case factory.taskName.InvalidatePaymentUrl:
+                case factory.taskName.OnAuthorizationCreated:
+                case factory.taskName.Pay:
+                case factory.taskName.PublishPaymentUrl:
+                case factory.taskName.Refund:
+                case factory.taskName.VoidPayTransaction:
+                case factory.taskName.VoidReserveTransaction:
+                case factory.taskName.ConfirmReserveTransaction:
+                case factory.taskName.ReturnPayTransaction:
+                case factory.taskName.ReturnReserveTransaction:
+                case factory.taskName.SendEmailMessage:
+                case factory.taskName.TriggerWebhook:
+                    callResult = yield call(task)(settings, options);
+                    break;
+                default:
+                    yield call(task.data)(settings);
+            }
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
+                error: ((callResult === null || callResult === void 0 ? void 0 : callResult.error) instanceof Error)
+                    ? Object.assign(Object.assign({}, callResult.error), { message: callResult.error.message }) : ''
+            };
+            yield taskRepo.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory.taskStatus.Executed,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+        catch (error) {
+            debug('service.task.execute throwed an error. task:', task.name, task.id, 'error:', error === null || error === void 0 ? void 0 : error.name, error === null || error === void 0 ? void 0 : error.message);
+            yield (0, onOperationFailed_1.onOperationFailed)(Object.assign({ task, now, error }, (typeof next === 'function') ? { next } : undefined))({ setting: settingRepo, task: taskRepo });
+        }
+    });
+}