@chevre/domain 25.2.0-alpha.45 → 25.2.0-alpha.46

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

@@ -0,0 +1,12 @@
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction, IReadyTask } from '../eventEmitter/task';
+type IExecuteSettings = IMinimumExecuteSettings;
+type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
+declare function executeAsyncActionById(params: IReadyTask & {
+    executor: {
+        /**
+         * タスク実行者名称
+         */
+        name: string;
+    };
+}, next?: INextFunction): IOperation<void>;
+export { executeAsyncActionById };

package/lib/chevre/service/asyncAction.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAsyncActionById = executeAsyncActionById;
+/**
+ * 非同期アクションサービス
+ */
+const debug_1 = __importDefault(require("debug"));
+const asyncActionHandler_1 = require("./asyncActionHandler");
+const debug = (0, debug_1.default)('chevre-domain:service:task');
+function executeAsyncActionById(params, next) {
+    return async (settings) => {
+        const taskRepo = new (await import('../repo/task.js')).TaskRepo(settings.connection);
+        const { id, status, executor, expires } = params;
+        let task = null;
+        try {
+            task = await taskRepo.executeOneById({
+                id,
+                status,
+                executor: { name: executor.name },
+                ...(expires instanceof Date) ? { expires } : undefined
+            });
+        }
+        catch (error) {
+            /* istanbul ignore next */
+            debug('service.asyncAction.executeAsyncActionById error:', error);
+        }
+        // タスクがなければ終了
+        if (task !== null) {
+            await (0, asyncActionHandler_1.executeAsyncAction)(task, (typeof next === 'function') ? next : undefined)(settings, {
+                executeById: true,
+                executeByName: false
+            });
+        }
+    };
+}

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

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

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperationFailed = onOperationFailed;
+const factory_1 = require("../../factory");
+/**
+ * タスク実行失敗時処理
+ */
+function onOperationFailed(params) {
+    return async (repos) => {
+        let error = params.error;
+        const { task, now, next } = params;
+        if (typeof error !== 'object') {
+            error = { message: String(error) };
+        }
+        const endDate = new Date();
+        let executedTask;
+        // remainingNumberOfTries<=0ならAborted(2025-08-04~)
+        const isRetryable = task.remainingNumberOfTries > 0;
+        if (isRetryable) {
+            // 実験的に実行中タスク連携をしてみたが、ひとまず廃止(2026-07-01~)
+            // if (USE_INFORM_TASK_RUNNING) {
+            //     await informTaskIfNeeded({ task, executionEndDate: endDate })(repos);
+            // }
+            const result = {
+                executedAt: now,
+                endDate,
+                error: {
+                    ...error,
+                    code: error.code,
+                    message: error.message,
+                    name: error.name,
+                    stack: error.stack
+                }
+            };
+            // 失敗してもここではステータスを戻さない(Runningのまま待機)
+            await repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: task.status,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+            executedTask = {
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name,
+                status: task.status,
+                executionResult: result
+            };
+        }
+        else {
+            // one time taskは分析連携しない
+            // await informTaskIfNeeded({ task, executionEndDate: endDate })(repos);
+            const result = {
+                executedAt: now,
+                endDate,
+                error: {
+                    ...error,
+                    code: error.code,
+                    message: error.message,
+                    name: error.name,
+                    stack: error.stack
+                }
+            };
+            await repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory_1.factory.taskStatus.Aborted,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+            executedTask = {
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name,
+                status: task.status,
+                executionResult: result
+            };
+        }
+        return { executedTask };
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { INextFunction } from '../eventEmitter/task';
+import { factory } from '../factory';
+import type { ICallResult, ICallableTaskOperation, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+export declare const taskLoader: {
+    load: (taskName: string) => Promise<{
+        call: ICallableTaskOperation;
+    }>;
+};
+/**
+ * 非同期アクションを実行する
+ */
+declare function executeAsyncAction(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
+export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeAsyncAction };

package/lib/chevre/service/asyncActionHandler.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskLoader = void 0;
+exports.executeAsyncAction = executeAsyncAction;
+const debug_1 = __importDefault(require("debug"));
+const moment_1 = __importDefault(require("moment"));
+const factory_1 = require("../factory");
+const onOperationFailed_1 = require("./asyncActionHandler/onOperationFailed");
+const debug = (0, debug_1.default)('chevre-domain:service:asyncActionHandler');
+exports.taskLoader = {
+    load: (taskName) => {
+        return import(`./task/${taskName}.js`);
+    }
+};
+/**
+ * 非同期アクションを実行する
+ */
+function executeAsyncAction(task, next) {
+    const now = new Date();
+    debug('executing an executableTask...', task, now);
+    return async (settings, options) => {
+        const settingRepo = new (await import('../repo/setting.js')).SettingRepo(settings.connection);
+        const taskRepo = new (await import('../repo/task.js')).TaskRepo(settings.connection);
+        let executedTask;
+        try {
+            // 期限検証(2024-04-23~)
+            if (task.expires instanceof Date) {
+                const taskExpired = (0, moment_1.default)(now)
+                    .isAfter(task.expires);
+                if (taskExpired) {
+                    throw new factory_1.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_1.factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
+            }
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
+            const callResult = await call(task)(settings, options);
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
+                error: (callResult?.error instanceof Error)
+                    ? {
+                        ...callResult.error,
+                        message: callResult.error.message
+                    }
+                    : ''
+            };
+            await taskRepo.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            });
+            executedTask = {
+                id: task.id,
+                remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                name: task.name,
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            };
+        }
+        catch (error) {
+            const onOperationFailedResult = await (0, onOperationFailed_1.onOperationFailed)({
+                task, now, error,
+                // ...(typeof next === 'function') ? { next } : undefined // タスクステータス変更イベントを発生させない
+            })({ setting: settingRepo, task: taskRepo });
+            executedTask = onOperationFailedResult.executedTask;
+        }
+        finally {
+            if (typeof next === 'function') {
+                if (executedTask === undefined) {
+                    executedTask = {
+                        id: task.id,
+                        remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                        name: task.name,
+                        status: factory_1.factory.taskStatus.Aborted,
+                        executionResult: {} // eslint-disable-line @typescript-eslint/no-explicit-any
+                    };
+                }
+                await next(executedTask)(settings);
+            }
+        }
+    };
+}

package/lib/chevre/service.d.ts

@@ -17,6 +17,7 @@ import type * as AnyPaymentService from './service/payment/any';
 import type * as ProjectService from './service/project';
 import type * as ReserveService from './service/reserve';
 import type * as TaskService from './service/task';
+import type * as AsyncActionService from './service/asyncAction';
 import type * as TransactionService from './service/transaction';
 export declare namespace aggregation {
     function createService(): Promise<typeof AggregationService>;
@@ -53,6 +54,9 @@ export declare namespace reserve {
 export declare namespace task {
     function createService(): Promise<typeof TaskService>;
 }
+export declare namespace asyncAction {
+    function createService(): Promise<typeof AsyncActionService>;
+}
 export declare namespace transaction {
     function createService(): Promise<typeof TransactionService>;
 }

package/lib/chevre/service.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = exports.transaction = exports.task = exports.reserve = exports.project = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.assetTransaction = exports.aggregation = void 0;
+exports.factory = exports.transaction = exports.asyncAction = exports.task = exports.reserve = exports.project = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.assetTransaction = exports.aggregation = void 0;
 /* eslint-disable @typescript-eslint/no-namespace */
 /**
  * service module
@@ -167,6 +167,17 @@ var task;
     }
     task.createService = createService;
 })(task || (exports.task = task = {}));
+var asyncAction;
+(function (asyncAction) {
+    let service;
+    async function createService() {
+        if (service === undefined) {
+            service = await import('./service/asyncAction.js');
+        }
+        return service;
+    }
+    asyncAction.createService = createService;
+})(asyncAction || (exports.asyncAction = asyncAction = {}));
 var transaction;
 (function (transaction) {
     let service;

package/package.json

@@ -88,5 +88,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "25.2.0-alpha.45"
+  "version": "25.2.0-alpha.46"
 }