@chevre/domain 26.0.0-alpha.9 → 26.0.0

package/lib/chevre/service/task/voidReserveTransaction.js

@@ -4,7 +4,7 @@ exports.call = call;
 const coa_service_1 = require("@motionpicture/coa-service");
 const factory_1 = require("../../factory");
 const voidTransaction_1 = require("../offer/event/voidTransaction");
-const action_1 = require("../../repo/action");
+const cancel_1 = require("../../repo/action/cancel");
 const acceptCOAOffer_1 = require("../../repo/action/acceptCOAOffer");
 const authorizeOffer_1 = require("../../repo/action/authorizeOffer");
 const assetTransaction_1 = require("../../repo/assetTransaction");
@@ -16,28 +16,26 @@ const setting_1 = require("../../repo/setting");
 const integration_1 = require("../../repo/setting/integration");
 const stockHolder_1 = require("../../repo/stockHolder");
 const task_1 = require("../../repo/task");
-// import { TransactionRepo } from '../../repo/transaction';
 const placeOrder_1 = require("../../repo/transaction/placeOrder");
 let coaAuthClientCreated = false;
 let coaAuthClient = new coa_service_1.COA.auth.RefreshToken({
     endpoint: '', // 使用されないので空文字でok
     refreshToken: '', // 使用されないので空文字でok
-    // useFetch: true
 });
 /**
  * タスク実行関数
  */
 function call(params) {
-    return async ({ connection, redisClient }, options) => {
+    return async ({ connection, redisClient }) => {
         if (redisClient === undefined) {
             throw new factory_1.factory.errors.Argument('settings', 'redisClient required');
         }
         const voidByActionId = typeof params.data.id === 'string';
         if (voidByActionId) {
-            // 遅延実行(executeByName)には対応しない
-            if (!options.executeById) {
-                return;
-            }
+            // // 遅延実行(executeByName)には対応しない
+            // if (!options.executeById) {
+            //     return;
+            // }
         }
         if (!coaAuthClientCreated) {
             const reserveInterfaceRepo = new reserveInterface_1.ReserveInterfaceRepo(connection);
@@ -53,16 +51,17 @@ function call(params) {
             endpoint: coaAuthClient.options.endpoint, // same as authClient(2024-07-17~)
             auth: coaAuthClient
         }, { timeout: (await settings.getByKey('coa')).timeoutReserve });
-        // const transactionProcessRepo = new TransactionProcessRepo(redisClient, { lockExpiresInSeconds: 120 });
         try {
             await (0, voidTransaction_1.voidTransaction)({
                 ...params.data,
                 project: { id: params.project.id },
                 sameAs: { id: params.id }
             })({
-                action: new action_1.ActionRepo(connection),
-                acceptCOAOfferAction: new acceptCOAOffer_1.AcceptCOAOfferActionRepo(connection),
-                authorizeOfferAction: new authorizeOffer_1.AuthorizeOfferActionRepo(connection),
+                actions: {
+                    cancel: new cancel_1.CancelActionRepo(connection),
+                    acceptCOAOffer: new acceptCOAOffer_1.AcceptCOAOfferActionRepo(connection),
+                    authorizeOffer: new authorizeOffer_1.AuthorizeOfferActionRepo(connection),
+                },
                 assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
                 stockHolder: new stockHolder_1.StockHolderRepo({ connection }),
                 offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),
@@ -71,7 +70,6 @@ function call(params) {
                 setting: new setting_1.SettingRepo(connection),
                 task: new task_1.TaskRepo(connection),
                 placeOrder: new placeOrder_1.PlaceOrderRepo(connection),
-                // transaction: new TransactionRepo(connection),
                 reserveService
             }, settings);
         }

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

@@ -1,4 +1,4 @@
-import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction, IReadyTask, IRunningTask } from '../eventEmitter/task';
+import type { IExecuteSettings as IMinimumExecuteSettings, IReadyTask, IRunningTask } from '../eventEmitter/task';
 import type { AggregationSettings } from '../taskSettings';
 interface IExecuteSettings extends IMinimumExecuteSettings {
     aggregationSettings?: AggregationSettings;
@@ -7,12 +7,12 @@ type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
 /**
  * タスク変更イベントを受けて実行する
  */
-declare function executeById(params: (IReadyTask | IRunningTask) & {
+declare function executeTaskById(params: (Pick<IReadyTask, 'id' | 'status'> | Pick<IRunningTask, 'id' | 'status'>) & {
     executor: {
         /**
          * タスク実行者名称
          */
         name: string;
     };
-}, next?: INextFunction): IOperation<void>;
-export { executeById, };
+}): IOperation<void>;
+export { executeTaskById };

package/lib/chevre/service/task.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeById = executeById;
+exports.executeTaskById = executeTaskById;
 /**
  * タスクサービス
  */
@@ -13,30 +13,26 @@ const debug = (0, debug_1.default)('chevre-domain:service:task');
 /**
  * タスク変更イベントを受けて実行する
  */
-function executeById(params, next) {
+function executeTaskById(params) {
     return async (settings) => {
-        const taskRepo = new (await import('../repo/task.js')).TaskRepo(settings.connection);
-        const { id, status, executor, expires } = params;
+        const taskRunningRepo = new (await import('../repo/taskRunning.js')).TaskRunningRepo(settings.connection);
+        const { id, status, executor } = params;
         let task = null;
         try {
             // support status: Running(2025-03-05~)
-            task = await taskRepo.executeOneById({
+            task = await taskRunningRepo.executeOneById({
                 id,
                 status,
-                executor: { name: executor.name },
-                ...(expires instanceof Date) ? { expires } : undefined
+                executor: { name: executor.name }
             });
         }
         catch (error) {
             /* istanbul ignore next */
-            debug('service.task.executeById error:', error);
+            debug('service.task.executeTaskById error:', error);
         }
         // タスクがなければ終了
         if (task !== null) {
-            await (0, taskHandler_1.executeTask)(task, (typeof next === 'function') ? next : undefined)(settings, {
-                executeById: true,
-                executeByName: false
-            });
+            await (0, taskHandler_1.executeTask)(task)(settings, {});
         }
     };
 }

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

@@ -46,7 +46,6 @@ function createInformTasks(params) {
                             const informActionAttributes = {
                                 object: task4inform,
                                 recipient: {
-                                    id: '',
                                     name: String(informTaskParams.recipient?.name),
                                     typeOf: factory_1.factory.creativeWorkType.WebApplication
                                 },

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

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

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

@@ -9,7 +9,7 @@ const informTaskIfNeeded_1 = require("./onOperationFailed/informTaskIfNeeded");
 function onOperationFailed(params) {
     return async (repos) => {
         let error = params.error;
-        const { task, now, next } = params;
+        const { task, now } = params;
         if (error === null || typeof error !== 'object') {
             error = { message: String(error) };
         }
@@ -18,9 +18,6 @@ function onOperationFailed(params) {
         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,
@@ -33,14 +30,10 @@ function onOperationFailed(params) {
                 }
             };
             // 失敗してもここではステータスを戻さない(Runningのまま待機)
-            await repos.task.setExecutionResultAndStatus({
-                id: task.id,
-                remainingNumberOfTries: task.remainingNumberOfTries,
-                name: task.name
-            }, {
+            await repos.taskRunning.setExecutionResultAndStatus({ id: task.id }, {
                 status: task.status,
                 executionResult: result
-            }, (typeof next === 'function') ? next : undefined);
+            });
         }
         else {
             // 分析連携(2025-08-05~)
@@ -59,14 +52,10 @@ function onOperationFailed(params) {
                     stack: error.stack
                 }
             };
-            await repos.task.setExecutionResultAndStatus({
-                id: task.id,
-                remainingNumberOfTries: task.remainingNumberOfTries,
-                name: task.name
-            }, {
+            await repos.taskRunning.setExecutionResultAndStatus({ id: task.id }, {
                 status: factory_1.factory.taskStatus.Aborted,
                 executionResult: result
-            }, (typeof next === 'function') ? next : undefined);
+            });
         }
     };
 }

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

@@ -1,4 +1,3 @@
-import type { INextFunction } from '../eventEmitter/task';
 import { factory } from '../factory';
 import type { ICallResult, ICallableTaskOperation, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
 export declare const taskLoader: {
@@ -9,5 +8,5 @@ export declare const taskLoader: {
 /**
  * タスクを実行する
  */
-declare function executeTask(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
+declare function executeTask(task: IExecutableTask<factory.taskName>): IOperationExecute<void>;
 export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeTask };

package/lib/chevre/service/taskHandler.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskLoader = void 0;
 exports.executeTask = executeTask;
 const debug_1 = __importDefault(require("debug"));
-const moment_1 = __importDefault(require("moment"));
 const factory_1 = require("../factory");
 const onOperationFailed_1 = require("./taskHandler/onOperationFailed");
 const debug = (0, debug_1.default)('chevre-domain:service:taskHandler');
@@ -18,21 +17,15 @@ exports.taskLoader = {
 /**
  * タスクを実行する
  */
-function executeTask(task, next) {
+function executeTask(task) {
     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);
+        const taskRunningRepo = new (await import('../repo/taskRunning.js')).TaskRunningRepo(settings.connection);
         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}]`);
-                }
-            }
+            // タスクのexpiresは廃止済なので期限検証はなし(2026-08-07~)
             // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
             // リトライを繰り返した後、不明の原因でRunningのまま残ってしまったタスクがリトライされたケース
             const { remainingNumberOfTries } = task;
@@ -55,20 +48,15 @@ function executeTask(task, next) {
                     }
                     : ''
             };
-            await taskRepo.setExecutionResultAndStatus({
-                id: task.id,
-                remainingNumberOfTries,
-                name: task.name
-            }, {
+            await taskRunningRepo.setExecutionResultAndStatus({ id: task.id }, {
                 status: factory_1.factory.taskStatus.Executed,
                 executionResult: result
-            }, (typeof next === 'function') ? next : undefined);
+            });
         }
         catch (error) {
             await (0, onOperationFailed_1.onOperationFailed)({
-                task, now, error,
-                ...(typeof next === 'function') ? { next } : undefined
-            })({ setting: settingRepo, task: taskRepo });
+                task, now, error
+            })({ setting: settingRepo, task: taskRepo, taskRunning: taskRunningRepo });
         }
     };
 }

package/lib/chevre/service/transaction/deleteTransaction/deletePayTransactionsByPlaceOrder.js

@@ -29,10 +29,10 @@ function deletePayTransactionsByPlaceOrder(params) {
                 deletedCount: deleteAssetTransactionsResult?.deletedCount
             };
             // 返金取引も削除(2023-05-19~)
-            const refundTransactions = await repos.assetTransaction.search({
+            const refundTransactions = await repos.assetTransaction.findAssetTransactionsByTypeOf({
                 typeOf: factory_1.factory.assetTransactionType.Refund,
                 object: { paymentMethodId: { $in: payTransactionNumbers } }
-            }, ['transactionNumber'], []);
+            }, ['transactionNumber']);
             if (refundTransactions.length > 0) {
                 const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
                     project: { id: params.transaction.project.id },

package/lib/chevre/service/transaction/deleteTransaction/deleteReservationsByPlaceOrder.js

@@ -40,11 +40,11 @@ function deleteReservationsByPlaceOrder(params) {
                 deletedCount: deleteAssetTransactionsResult?.deletedCount
             };
             // 予約番号で予約取消取引を検索
-            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
+            const deletingCancelReservationTransactions = await repos.assetTransaction.findAssetTransactionsByTypeOf({
                 project: { id: { $eq: params.transaction.project.id } },
                 object: { reservationNumber: { $in: reserveTransactionNumbers } },
                 typeOf: factory_1.factory.assetTransactionType.CancelReservation
-            }, ['transactionNumber'], []);
+            }, ['transactionNumber']);
             if (deletingCancelReservationTransactions.length > 0) {
                 // 予約取消取引も削除(2024-04-18~)
                 const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({

package/lib/chevre/service/transaction/deleteTransaction.d.ts

@@ -1,23 +1,27 @@
 import { factory } from '../../factory';
 import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
 import type { AccountingReportRepo } from '../../repo/accountingReport';
-import type { ActionRepo } from '../../repo/action';
+import type { UpdateActionRepo } from '../../repo/action/update';
+import type { AdminActionRepo } from '../../repo/adminAction';
+import type { AdminTransactionRepo } from '../../repo/adminTransaction';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { NoteRepo } from '../../repo/note';
 import type { OrderRepo } from '../../repo/order';
 import type { ReservationRepo } from '../../repo/reservation';
-import type { TransactionRepo } from '../../repo/transaction';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import type { ReturnOrderRepo } from '../../repo/transaction/returnOrder';
 interface IDeleteTransactionRepos {
     acceptedOffer: AcceptedOfferRepo;
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    actions: {
+        update: UpdateActionRepo;
+    };
+    adminAction: AdminActionRepo;
+    adminTransaction: AdminTransactionRepo;
     assetTransaction: AssetTransactionRepo;
     note: NoteRepo;
     order: OrderRepo;
     reservation: ReservationRepo;
-    transaction: TransactionRepo;
     placeOrder: PlaceOrderRepo;
     returnOrder: ReturnOrderRepo;
 }

package/lib/chevre/service/transaction/deleteTransaction.js

@@ -71,13 +71,13 @@ function deleteTransactionById(params) {
         let deletedReservationNumbers = [];
         let deleteActionResult;
         let deleteOrderResult;
-        const action = await repos.action.start(actionAttributes);
+        const action = await repos.actions.update.startUpdateAction(actionAttributes);
         try {
             const transactionTypeOf = transaction.typeOf;
             switch (transactionTypeOf) {
                 case factory_1.factory.transactionType.PlaceOrder: {
                     // 取引に対する全ての承認アクションを検索
-                    const authorizeActions = await repos.action.searchByPurpose({
+                    const authorizeActions = await repos.adminAction.searchByPurpose({
                         typeOf: factory_1.factory.actionType.AuthorizeAction,
                         purpose: {
                             typeOf: transactionTypeOf,
@@ -111,7 +111,7 @@ function deleteTransactionById(params) {
                         deleteReservationsByPlaceOrderResult.deleteCancelReservationTransactionResult;
                     deletedReservationNumbers = deleteReservationsByPlaceOrderResult.reserveTransactionNumbers;
                     // アクション削除(2023-05-19~)
-                    deleteActionResult = await repos.action.deleteActionsByTransactionId({
+                    deleteActionResult = await repos.adminAction.deleteActionsByTransactionId({
                         project: { id: transaction.project.id },
                         transaction: { id: transaction.id, typeOf: transactionTypeOf },
                         typeOf: {
@@ -132,13 +132,13 @@ function deleteTransactionById(params) {
                     // })(repos);
                     // deleteMessagessResult = deleteMessagesByPlaceOrderResult.deleteResult;
                     // 取引削除
-                    await repos.transaction.findByIdAndDelete({ id: transaction.id });
+                    await repos.adminTransaction.findByIdAndDelete({ id: transaction.id });
                     break;
                 }
                 // implemented(2022-06-09~)
                 case factory_1.factory.transactionType.ReturnOrder:
                     // 取引削除
-                    await repos.transaction.findByIdAndDelete({ id: transaction.id });
+                    await repos.adminTransaction.findByIdAndDelete({ id: transaction.id });
                     break;
                 default:
                     throw new factory_1.factory.errors.NotImplemented(`${transactionTypeOf} not implemented`);
@@ -146,7 +146,7 @@ function deleteTransactionById(params) {
         }
         catch (error) {
             try {
-                await repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error });
+                await repos.actions.update.giveUpUpdateAction({ typeOf: action.typeOf, id: action.id, error });
             }
             catch (__) {
                 // 失敗したら仕方ない
@@ -166,6 +166,6 @@ function deleteTransactionById(params) {
             deleteOrderResult // 2026-07-10~
             // ...(deleteMessagessResult !== undefined) ? { deleteMessagessResult } : undefined
         };
-        await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: actionResult });
+        await repos.actions.update.completeUpdateAction({ typeOf: action.typeOf, id: action.id, result: actionResult });
     };
 }

package/lib/chevre/service/transaction/placeOrder/confirm.js

@@ -128,7 +128,7 @@ function confirm(params, options) {
         const payTransactionNumbers = authorizePaymentActions.map((authorizeAction) => authorizeAction.object.paymentMethodId);
         // const payTransactionNumbers = authorizePaymentActions.map(({ instrument }) => instrument.transactionNumber);
         if (payTransactionNumbers.length > 0) {
-            payTransactions = await repos.assetTransaction.search({
+            payTransactions = await repos.assetTransaction.findAssetTransactionsByTypeOf({
                 typeOf: factory_1.factory.assetTransactionType.Pay,
                 transactionNumber: { $in: payTransactionNumbers }
             }, ['object']);

package/lib/chevre/service/transaction/placeOrder/exportTasks/factory.d.ts

@@ -1,6 +1,6 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
-type IPlaceOrderPotentialTask = factory.task.IAttributes<factory.taskName.PlaceOrder> | factory.task.IAttributes<factory.taskName.VoidPayTransaction> | factory.task.voidReserveTransaction.IAttributes;
+type IPlaceOrderPotentialTask = factory.task.IAttributes<factory.taskName.PlaceOrder> | factory.task.IAttributes<factory.taskName.VoidPayTransaction> | Omit<factory.task.voidReserveTransaction.IAttributes, 'expires'>;
 /**
  * 取引のタスクを作成する
  * 取引削除タスクを分離(2026-08-02~)

package/lib/chevre/service/transaction/placeOrder/exportTasksById.js

@@ -25,24 +25,18 @@ function exportTasksById(params) {
         }
         // search settings
         const setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['storage']);
-        const useScheduledDeleteTransactionTask = setting?.storage?.useScheduledDeleteTransactionTask === true;
         const deleteTransactionTaskExpiresInDays = setting?.storage?.deleteTransactionTaskExpiresInDays;
-        const deleteTask = (0, factory_2.createScheduledTasks)({ transaction }, setting);
-        if (useScheduledDeleteTransactionTask && typeof deleteTransactionTaskExpiresInDays === 'number' && deleteTransactionTaskExpiresInDays > 0) {
-            // support scheduledTask(2026-08-02~)
-            await repos.task.saveMany((0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }));
-            await repos.scheduledTask.addScheduledTasks([{
-                    ...deleteTask,
-                    expires: (0, moment_1.default)(deleteTask.runsAt)
-                        .add(deleteTransactionTaskExpiresInDays, 'days')
-                        .toDate()
-                }]);
-        }
-        else {
-            await repos.task.saveMany([
-                ...(0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }),
-                deleteTask
-            ]);
+        if (typeof deleteTransactionTaskExpiresInDays !== 'number') {
+            throw new factory_1.factory.errors.Internal('settings.storage.deleteTransactionTaskExpiresInDays required');
         }
+        const deleteTask = (0, factory_2.createScheduledTasks)({ transaction }, setting);
+        // support scheduledTask(2026-08-02~)
+        await repos.task.saveMany((0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }));
+        await repos.scheduledTask.addScheduledTasks([{
+                ...deleteTask,
+                expires: (0, moment_1.default)(deleteTask.runsAt)
+                    .add(deleteTransactionTaskExpiresInDays, 'days')
+                    .toDate()
+            }]);
     };
 }

package/lib/chevre/service/transaction/returnOrder.js

@@ -167,24 +167,18 @@ function exportTasksById(params) {
         }
         // search settings
         const setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['storage']);
-        const useScheduledDeleteTransactionTask = setting?.storage?.useScheduledDeleteTransactionTask === true;
         const deleteTransactionTaskExpiresInDays = setting?.storage?.deleteTransactionTaskExpiresInDays;
-        const deleteTask = (0, factory_2.createScheduledTasks)({ transaction }, setting);
-        if (useScheduledDeleteTransactionTask && typeof deleteTransactionTaskExpiresInDays === 'number' && deleteTransactionTaskExpiresInDays > 0) {
-            // support scheduledTask(2026-08-02~)
-            await repos.task.saveMany((0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }));
-            await repos.scheduledTask.addScheduledTasks([{
-                    ...deleteTask,
-                    expires: (0, moment_timezone_1.default)(deleteTask.runsAt)
-                        .add(deleteTransactionTaskExpiresInDays, 'days')
-                        .toDate()
-                }]);
-        }
-        else {
-            await repos.task.saveMany([
-                ...(0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }),
-                deleteTask
-            ]);
+        if (typeof deleteTransactionTaskExpiresInDays !== 'number') {
+            throw new factory_1.factory.errors.Internal('settings.storage.deleteTransactionTaskExpiresInDays required');
         }
+        const deleteTask = (0, factory_2.createScheduledTasks)({ transaction }, setting);
+        // support scheduledTask(2026-08-02~)
+        await repos.task.saveMany((0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }));
+        await repos.scheduledTask.addScheduledTasks([{
+                ...deleteTask,
+                expires: (0, moment_timezone_1.default)(deleteTask.runsAt)
+                    .add(deleteTransactionTaskExpiresInDays, 'days')
+                    .toDate()
+            }]);
     };
 }

package/lib/chevre/service/validation/validateOrder.d.ts

@@ -1,8 +1,6 @@
 import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { OrderRepo } from '../../repo/order';
-import type { SettingRepo } from '../../repo/setting';
-import type { TaskRepo } from '../../repo/task';
 export declare function validateOrder(params: {
     orderNumber: string;
     project: {
@@ -12,6 +10,4 @@ export declare function validateOrder(params: {
     acceptedOffer: AcceptedOfferRepo;
     assetTransaction: AssetTransactionRepo;
     order: OrderRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
 }) => Promise<void>;

package/lib/chevre/service/validation/validateOrder.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOrder = validateOrder;
 // import createDebug from 'debug';
 const moment_1 = __importDefault(require("moment"));
+// import type { SettingRepo } from '../../repo/setting';
 const factory_1 = require("../../factory");
 const factory_2 = require("../offer/event/authorize/factory");
-// import { acceptedOffers2amount as acceptedOffers2amount4product } from '../offer/product/factory';
 const validateMovieTicket_1 = require("../transaction/placeOrder/confirm/validation/validateMovieTicket");
 function validateOrder(params) {
     return async (repos) => {
@@ -25,11 +25,11 @@ function validateOrder(params) {
         });
         let payTransactions = [];
         if (order.paymentMethods.length > 0) {
-            payTransactions = await repos.assetTransaction.search({
+            payTransactions = await repos.assetTransaction.findAssetTransactionsByTypeOf({
                 project: { id: { $eq: order.project.id } },
                 typeOf: factory_1.factory.assetTransactionType.Pay,
                 transactionNumber: { $in: order.paymentMethods.map(({ paymentMethodId }) => paymentMethodId) }
-            }, [], []);
+            }, []);
         }
         // 型検証
         if (typeof order.confirmationNumber !== 'string' || order.confirmationNumber.length === 0) {

package/lib/chevre/taskSettings.d.ts

@@ -20,10 +20,10 @@ declare class AggregationSettings {
 interface IExecuteSettings extends IMinimumExecuteSettings {
     aggregationSettings?: AggregationSettings;
 }
-interface IExecuteOptions {
-    executeById: boolean;
-    executeByName: boolean;
-}
+/**
+ * かつてはexecuteById,executeByNameといったオプションが存在したが、現時点で特に何もなし(2026-08-07)
+ */
+type IExecuteOptions = Record<string, never>;
 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>;

package/package.json

@@ -11,7 +11,7 @@
   "dependencies": {
     "@aws-sdk/client-cognito-identity-provider": "3.1090.0",
     "@aws-sdk/credential-providers": "3.1090.0",
-    "@chevre/factory": "10.1.0-alpha.5",
+    "@chevre/factory": "10.3.0",
     "@motionpicture/coa-service": "10.0.0",
     "@motionpicture/gmo-service": "6.1.0-alpha.0",
     "@sendgrid/client": "8.1.4",
@@ -88,5 +88,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "26.0.0-alpha.9"
+  "version": "26.0.0"
 }