@chevre/domain 25.2.0-alpha.4 → 25.2.0-alpha.41

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

@@ -1,6 +1,6 @@
-import type { IOperationExecute } from '../taskHandler';
+import type { ICallResult, IExecutableTaskKeys, IOperationExecute } from '../taskHandler';
 import { factory } from '../../factory';
 /**
  * タスク実行関数
  */
-export declare function call(data: factory.task.voidPayment.IData): IOperationExecute<void>;
+export declare function call(params: Pick<factory.task.voidPayment.ITask, IExecutableTaskKeys>): IOperationExecute<ICallResult>;

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

@@ -19,8 +19,9 @@ const voidPaymentByTask_1 = require("./payment/voidPaymentByTask");
 /**
  * タスク実行関数
  */
-function call(data) {
+function call(params) {
     return async ({ connection, redisClient }) => {
+        const { data } = params;
         if (redisClient === undefined) {
             throw new factory_1.factory.errors.Argument('settings', 'redisClient required');
         }

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

@@ -1,9 +1,9 @@
 import type { INextFunction } from '../eventEmitter/task';
 import { factory } from '../factory';
-import type { ICallResult, ICallableTaskOperation, ICallableTaskOperationSimple, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { ICallResult, ICallableTaskOperation, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
 export declare const taskLoader: {
     load: (taskName: string) => Promise<{
-        call: ICallableTaskOperationSimple | ICallableTaskOperation;
+        call: ICallableTaskOperation;
     }>;
 };
 /**

package/lib/chevre/service/taskHandler.js

@@ -41,44 +41,43 @@ function executeTask(task, next) {
                 throw new factory_1.factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
             }
             // タスク名の関数が定義されていなければ、TypeErrorとなる
-            let callResult;
-            // const { call } = await import(`./task/${task.name}.js`) as {
-            //     call: ICallableTaskOperationSimple | ICallableTaskOperation;
-            // };
             const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
-            switch (task.name) {
-                case factory_1.factory.taskName.AcceptCOAOffer:
-                case factory_1.factory.taskName.AggregateOnSystem:
-                case factory_1.factory.taskName.AuthorizePayment:
-                case factory_1.factory.taskName.CancelPendingReservation:
-                case factory_1.factory.taskName.CheckMovieTicket:
-                case factory_1.factory.taskName.CheckResource:
-                case factory_1.factory.taskName.CreateAccountingReport:
-                case factory_1.factory.taskName.HandleNotification:
-                case factory_1.factory.taskName.ImportEventCapacitiesFromCOA:
-                case factory_1.factory.taskName.ImportEventsFromCOA:
-                case factory_1.factory.taskName.ImportOffersFromCOA:
-                case factory_1.factory.taskName.InvalidatePaymentUrl:
-                case factory_1.factory.taskName.OnAuthorizationCreated:
-                case factory_1.factory.taskName.OnResourceDeleted:
-                case factory_1.factory.taskName.Pay:
-                case factory_1.factory.taskName.PublishPaymentUrl:
-                case factory_1.factory.taskName.Refund:
-                case factory_1.factory.taskName.VoidPayTransaction:
-                case factory_1.factory.taskName.VoidReserveTransaction:
-                case factory_1.factory.taskName.ConfirmPayTransaction:
-                case factory_1.factory.taskName.ConfirmReserveTransaction:
-                case factory_1.factory.taskName.ReturnPayTransaction:
-                case factory_1.factory.taskName.ReturnReserveTransaction:
-                case factory_1.factory.taskName.SendEmailMessage:
-                case factory_1.factory.taskName.SyncResourcesFromCOA:
-                case factory_1.factory.taskName.TriggerWebhook:
-                case factory_1.factory.taskName.UseReservation:
-                    callResult = await call(task)(settings, options);
-                    break;
-                default:
-                    await call(task.data)(settings);
-            }
+            const callResult = await call(task)(settings, options);
+            // ICallableTaskOperationSimpleを廃止(2026-07-22~)
+            // let callResult: ICallResult | undefined;
+            // 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.CheckResource:
+            //     case factory.taskName.CreateAccountingReport:
+            //     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.OnResourceDeleted:
+            //     case factory.taskName.Pay:
+            //     case factory.taskName.PublishPaymentUrl:
+            //     case factory.taskName.Refund:
+            //     case factory.taskName.VoidPayTransaction:
+            //     case factory.taskName.VoidReserveTransaction:
+            //     case factory.taskName.ConfirmPayTransaction:
+            //     case factory.taskName.ConfirmReserveTransaction:
+            //     case factory.taskName.ReturnPayTransaction:
+            //     case factory.taskName.ReturnReserveTransaction:
+            //     case factory.taskName.SendEmailMessage:
+            //     case factory.taskName.SyncResourcesFromCOA:
+            //     case factory.taskName.TriggerWebhook:
+            //     case factory.taskName.UseReservation:
+            //         callResult = await (call as ICallableTaskOperation)(task)(settings, options);
+            //         break;
+            //     default:
+            //         await (call as ICallableTaskOperationSimple)(task.data)(settings); // TODO discontinue
+            // }
             const result = {
                 executedAt: now,
                 endDate: new Date(),

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

@@ -0,0 +1,15 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+export declare function deletePayTransactionsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<{
+    deletePayTransactionResult: any;
+    deleteRefundResult: any;
+    payTransactionNumbers: string[];
+}>;
+export {};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePayTransactionsByPlaceOrder = deletePayTransactionsByPlaceOrder;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const factory_1 = require("../../../factory");
+function deletePayTransactionsByPlaceOrder(params) {
+    return async (repos) => {
+        let deletePayTransactionResult;
+        let deleteRefundResult;
+        const authorizeActions = params.authorizeActions;
+        // 決済取引番号を抽出
+        const authorizePaymentActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment
+                && typeof a.object?.paymentMethodId === 'string'
+                && a.object.paymentMethodId.length > 0;
+        });
+        const payTransactionNumbers = authorizePaymentActions.map((a) => String(a.object.paymentMethodId));
+        if (payTransactionNumbers.length > 0) {
+            // 決済取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: payTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Pay
+            });
+            deletePayTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 返金取引も削除(2023-05-19~)
+            const refundTransactions = await repos.assetTransaction.search({
+                typeOf: factory_1.factory.assetTransactionType.Refund,
+                object: { paymentMethodId: { $in: payTransactionNumbers } }
+            }, ['transactionNumber'], []);
+            if (refundTransactions.length > 0) {
+                const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: refundTransactions.map(({ transactionNumber }) => transactionNumber),
+                    typeOf: factory_1.factory.assetTransactionType.Refund
+                });
+                deleteRefundResult = {
+                    n: deleteRefundAssetTransactionsResult?.n,
+                    ok: deleteRefundAssetTransactionsResult?.ok,
+                    deletedCount: deleteRefundAssetTransactionsResult?.deletedCount
+                };
+            }
+        }
+        return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
+    };
+}

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

@@ -0,0 +1,23 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { ReservationRepo } from '../../../repo/reservation';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+interface IDeleteResult {
+    n?: number;
+    ok?: number;
+    deletedCount?: number;
+}
+export declare function deleteReservationsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+    reservation: ReservationRepo;
+}) => Promise<{
+    deleteResult?: IDeleteResult;
+    deleteReserveTransactionResult?: IDeleteResult;
+    deleteCancelReservationTransactionResult?: IDeleteResult;
+    reserveTransactionNumbers: string[];
+}>;
+export {};

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteReservationsByPlaceOrder = deleteReservationsByPlaceOrder;
+const factory_1 = require("../../../factory");
+function deleteReservationsByPlaceOrder(params) {
+    return async (repos) => {
+        let deleteResult;
+        let deleteReserveTransactionResult;
+        let deleteCancelReservationTransactionResult;
+        const authorizeActions = params.authorizeActions;
+        // 予約取引番号を抽出
+        const authorizeReservationOfferActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation
+                && a.instrument?.transactionNumber === 'string'
+                && a.instrument.transactionNumber.length > 0;
+        });
+        const reserveTransactionNumbers = authorizeReservationOfferActions
+            .map((a) => String(a.instrument?.transactionNumber));
+        if (reserveTransactionNumbers.length > 0) {
+            // 該当予約番号の予約を削除する(プロジェクトでも絞ること)
+            const deleteReservationsResult = await repos.reservation.deleteByReservationNumbers({
+                project: { id: params.transaction.project.id },
+                reservationNumbers: reserveTransactionNumbers
+            });
+            deleteResult = {
+                n: deleteReservationsResult?.n,
+                ok: deleteReservationsResult?.ok,
+                deletedCount: deleteReservationsResult?.deletedCount
+            };
+            // 予約取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: reserveTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Reserve
+            });
+            deleteReserveTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 予約番号で予約取消取引を検索
+            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
+                project: { id: { $eq: params.transaction.project.id } },
+                object: { reservationNumber: { $in: reserveTransactionNumbers } },
+                typeOf: factory_1.factory.assetTransactionType.CancelReservation
+            }, ['transactionNumber'], []);
+            if (deletingCancelReservationTransactions.length > 0) {
+                // 予約取消取引も削除(2024-04-18~)
+                const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: deletingCancelReservationTransactions.map(({ transactionNumber }) => String(transactionNumber)),
+                    typeOf: factory_1.factory.assetTransactionType.CancelReservation
+                });
+                deleteCancelReservationTransactionResult = {
+                    n: deleteCancelReservationResult?.n,
+                    ok: deleteCancelReservationResult?.ok,
+                    deletedCount: deleteCancelReservationResult?.deletedCount
+                };
+            }
+        }
+        return { deleteResult, deleteReserveTransactionResult, deleteCancelReservationTransactionResult, reserveTransactionNumbers };
+    };
+}

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

@@ -4,6 +4,8 @@ exports.deleteTransaction = deleteTransaction;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const factory_1 = require("../../factory");
 const deleteOrder_1 = require("../order/deleteOrder");
+const deletePayTransactionsByPlaceOrder_1 = require("./deleteTransaction/deletePayTransactionsByPlaceOrder");
+const deleteReservationsByPlaceOrder_1 = require("./deleteTransaction/deleteReservationsByPlaceOrder");
 /**
  * 取引に関わるリソースを削除する
  * 冪等性を確保すること
@@ -30,7 +32,6 @@ function deleteTransactionById(params) {
         if (typeof deletingTransactionId !== 'string' || deletingTransactionId.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('object.id');
         }
-        // let deletingOrderNumberByTask: string | undefined;
         let transaction;
         if (params.object.typeOf === factory_1.factory.transactionType.PlaceOrder) {
             transaction = (await repos.placeOrder.findPlaceOrderTransactions({
@@ -38,7 +39,6 @@ function deleteTransactionById(params) {
                 typeOf: params.object.typeOf,
                 inclusion: ['typeOf', 'project', 'status']
             })).shift();
-            // deletingOrderNumberByTask = params.object.object.orderNumber;
         }
         else if (params.object.typeOf === factory_1.factory.transactionType.ReturnOrder) {
             transaction = (await repos.returnOrder.findReturnOrderTransactions({
@@ -70,7 +70,7 @@ function deleteTransactionById(params) {
         let deleteCancelReservationTransactionResult;
         let deletedReservationNumbers = [];
         let deleteActionResult;
-        // let deleteMessagessResult: IDeleteResult | undefined;
+        let deleteOrderResult;
         const action = await repos.action.start(actionAttributes);
         try {
             const transactionTypeOf = transaction.typeOf;
@@ -90,12 +90,7 @@ function deleteTransactionById(params) {
                             break;
                         case factory_1.factory.transactionStatusType.Confirmed: {
                             // identifierによる削除に変更(2026-06-28~)
-                            // if (typeof deletingOrderNumberByTask === 'string') {
-                            //     await deleteOrder({
-                            //         object: { orderNumber: deletingOrderNumberByTask }
-                            //     })(repos);
-                            // }
-                            await (0, deleteOrder_1.deleteOrder)({
+                            deleteOrderResult = await (0, deleteOrder_1.deleteOrder)({
                                 object: { identifier: transaction.id }
                             })(repos);
                             break;
@@ -104,27 +99,29 @@ function deleteTransactionById(params) {
                             throw new factory_1.factory.errors.NotImplemented(`${transaction.status} not implemented`);
                     }
                     // 決済取引を削除
-                    const deletePayTransactionsByPlaceOrderResult = await deletePayTransactionsByPlaceOrder({ authorizeActions, transaction })(repos);
+                    const deletePayTransactionsByPlaceOrderResult = await (0, deletePayTransactionsByPlaceOrder_1.deletePayTransactionsByPlaceOrder)({ authorizeActions, transaction })(repos);
                     deletePayTransactionResult = deletePayTransactionsByPlaceOrderResult.deletePayTransactionResult;
                     deleteRefundResult = deletePayTransactionsByPlaceOrderResult.deleteRefundResult;
                     payTransactionNumbers = deletePayTransactionsByPlaceOrderResult.payTransactionNumbers;
                     // 取引上での予約を削除
-                    const deleteReservationsByPlaceOrderResult = await deleteReservationsByPlaceOrder({ authorizeActions, transaction })(repos);
+                    const deleteReservationsByPlaceOrderResult = await (0, deleteReservationsByPlaceOrder_1.deleteReservationsByPlaceOrder)({ authorizeActions, transaction })(repos);
                     deleteReservationsResult = deleteReservationsByPlaceOrderResult.deleteResult;
                     deleteReserveTransactionResult = deleteReservationsByPlaceOrderResult.deleteReserveTransactionResult;
                     deleteCancelReservationTransactionResult =
                         deleteReservationsByPlaceOrderResult.deleteCancelReservationTransactionResult;
                     deletedReservationNumbers = deleteReservationsByPlaceOrderResult.reserveTransactionNumbers;
                     // アクション削除(2023-05-19~)
-                    deleteActionResult = await repos.action.deleteByPurpose({
+                    deleteActionResult = await repos.action.deleteActionsByTransactionId({
                         project: { id: transaction.project.id },
-                        purpose: { id: transaction.id, typeOf: transactionTypeOf },
+                        transaction: { id: transaction.id, typeOf: transactionTypeOf },
                         typeOf: {
                             $in: [
-                                factory_1.factory.actionType.AuthorizeAction,
-                                factory_1.factory.actionType.CheckAction,
-                                factory_1.factory.actionType.InformAction,
-                                factory_1.factory.actionType.OrderAction
+                                factory_1.factory.actionType.AcceptAction, // オファー採用、決済採用
+                                factory_1.factory.actionType.AuthorizeAction, // オファー承認、決済承認
+                                factory_1.factory.actionType.CheckAction, // 決済カード認証
+                                // factory.actionType.InformAction, // 通知は特になし
+                                factory_1.factory.actionType.OrderAction, // 注文
+                                factory_1.factory.actionType.RefundAction // 決済採用返金
                             ]
                         }
                     });
@@ -166,143 +163,9 @@ function deleteTransactionById(params) {
             deleteCancelReservationTransactionResult,
             deletedReservationNumbers,
             deleteActionResult,
+            deleteOrderResult // 2026-07-10~
             // ...(deleteMessagessResult !== undefined) ? { deleteMessagessResult } : undefined
         };
         await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: actionResult });
     };
 }
-function deleteReservationsByPlaceOrder(params) {
-    return async (repos) => {
-        let deleteResult;
-        let deleteReserveTransactionResult;
-        let deleteCancelReservationTransactionResult;
-        const authorizeActions = params.authorizeActions;
-        // 予約取引番号を抽出
-        const authorizeReservationOfferActions = authorizeActions
-            .filter((a) => {
-            const pendingTransactionNumber = a.instrument?.transactionNumber;
-            return a.object.typeOf === factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation
-                && typeof pendingTransactionNumber === 'string'
-                && pendingTransactionNumber.length > 0;
-        });
-        const reserveTransactionNumbers = authorizeReservationOfferActions
-            .map((a) => String(a.instrument?.transactionNumber));
-        if (reserveTransactionNumbers.length > 0) {
-            // 該当予約番号の予約を削除する(プロジェクトでも絞ること)
-            const deleteReservationsResult = await repos.reservation.deleteByReservationNumbers({
-                project: { id: params.transaction.project.id },
-                reservationNumbers: reserveTransactionNumbers
-            });
-            deleteResult = {
-                n: deleteReservationsResult?.n,
-                ok: deleteReservationsResult?.ok,
-                deletedCount: deleteReservationsResult?.deletedCount
-            };
-            // 予約取引を削除(プロジェクトでも絞ること)(2022-06-07~)
-            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                project: { id: params.transaction.project.id },
-                transactionNumbers: reserveTransactionNumbers,
-                typeOf: factory_1.factory.assetTransactionType.Reserve
-            });
-            deleteReserveTransactionResult = {
-                n: deleteAssetTransactionsResult?.n,
-                ok: deleteAssetTransactionsResult?.ok,
-                deletedCount: deleteAssetTransactionsResult?.deletedCount
-            };
-            // 予約番号で予約取消取引を検索
-            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
-                project: { id: { $eq: params.transaction.project.id } },
-                object: { reservationNumber: { $in: reserveTransactionNumbers } },
-                typeOf: factory_1.factory.assetTransactionType.CancelReservation
-            }, ['transactionNumber'], []);
-            if (deletingCancelReservationTransactions.length > 0) {
-                // 予約取消取引も削除(2024-04-18~)
-                const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({
-                    project: { id: params.transaction.project.id },
-                    transactionNumbers: deletingCancelReservationTransactions.map(({ transactionNumber }) => String(transactionNumber)),
-                    typeOf: factory_1.factory.assetTransactionType.CancelReservation
-                });
-                deleteCancelReservationTransactionResult = {
-                    n: deleteCancelReservationResult?.n,
-                    ok: deleteCancelReservationResult?.ok,
-                    deletedCount: deleteCancelReservationResult?.deletedCount
-                };
-            }
-        }
-        return { deleteResult, deleteReserveTransactionResult, deleteCancelReservationTransactionResult, reserveTransactionNumbers };
-    };
-}
-function deletePayTransactionsByPlaceOrder(params) {
-    return async (repos) => {
-        let deletePayTransactionResult;
-        let deleteRefundResult;
-        const authorizeActions = params.authorizeActions;
-        // 決済取引番号を抽出
-        const authorizePaymentActions = authorizeActions
-            .filter((a) => {
-            const pendingTransactionNumber = a.object?.paymentMethodId;
-            return a.object.typeOf === factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment
-                && typeof pendingTransactionNumber === 'string'
-                && pendingTransactionNumber.length > 0;
-        });
-        const payTransactionNumbers = authorizePaymentActions.map((a) => String(a.object.paymentMethodId));
-        if (payTransactionNumbers.length > 0) {
-            // 決済取引を削除(プロジェクトでも絞ること)(2022-06-07~)
-            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                project: { id: params.transaction.project.id },
-                transactionNumbers: payTransactionNumbers,
-                typeOf: factory_1.factory.assetTransactionType.Pay
-            });
-            deletePayTransactionResult = {
-                n: deleteAssetTransactionsResult?.n,
-                ok: deleteAssetTransactionsResult?.ok,
-                deletedCount: deleteAssetTransactionsResult?.deletedCount
-            };
-            // 返金取引も削除(2023-05-19~)
-            const refundTransactions = await repos.assetTransaction.search({
-                typeOf: factory_1.factory.assetTransactionType.Refund,
-                object: { paymentMethodId: { $in: payTransactionNumbers } }
-            }, ['transactionNumber'], []);
-            if (refundTransactions.length > 0) {
-                const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                    project: { id: params.transaction.project.id },
-                    transactionNumbers: refundTransactions.map(({ transactionNumber }) => transactionNumber),
-                    typeOf: factory_1.factory.assetTransactionType.Refund
-                });
-                deleteRefundResult = {
-                    n: deleteRefundAssetTransactionsResult?.n,
-                    ok: deleteRefundAssetTransactionsResult?.ok,
-                    deletedCount: deleteRefundAssetTransactionsResult?.deletedCount
-                };
-            }
-        }
-        return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
-    };
-}
-// function deleteMessagesByPlaceOrder(params: {
-//     transaction: factory.task.deleteTransaction.IObject;
-// }) {
-//     return async (repos: {
-//         message: MessageRepo;
-//     }): Promise<{
-//         deleteResult?: IDeleteResult;
-//     }> => {
-//         let deleteResult: IDeleteResult | undefined;
-//         if (params.transaction.typeOf === factory.transactionType.PlaceOrder
-//             && params.transaction.specifyingMethod === factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id) {
-//             const orderNumber = params.transaction.object.orderNumber;
-//             if (typeof orderNumber === 'string' && orderNumber.length > 0) {
-//                 const deleteReservationsResult = await repos.message.deleteByMainEntityOrderNumber({
-//                     project: { id: params.transaction.project.id },
-//                     mainEntity: { orderNumber }
-//                 });
-//                 deleteResult = {
-//                     n: deleteReservationsResult?.n,
-//                     ok: deleteReservationsResult?.ok,
-//                     deletedCount: deleteReservationsResult?.deletedCount
-//                 };
-//             }
-//         }
-//         return { deleteResult };
-//     };
-// }

package/lib/chevre/service/transaction/placeOrder/confirm/potentialActions/sendEmailMessage.d.ts

@@ -1,6 +1,32 @@
 import { factory } from '../../../../../factory';
 import type { ISetting } from '../../../../../repo/setting';
 import type { IOrderAsResult } from '../factory/result';
+/**
+ * Eメール送信パラメータ
+ */
+interface ISendEmailMessageParams {
+    /**
+     * Eメールカスタマイズ
+     * メール本文をカスタマイズしたい場合、PUGテンプレートを指定
+     * 挿入変数として`order`を使用できます
+     * {@link https://pugjs.org/api/getting-started.html}
+     */
+    object?: factory.creativeWork.message.email.ICustomization;
+}
+/**
+ * 取引確定後アクションパラメータ
+ */
+export interface IPotentialActionsParams {
+    order?: {
+        potentialActions?: {
+            sendOrder?: {
+                potentialActions?: {
+                    sendEmailMessage?: ISendEmailMessageParams[];
+                };
+            };
+        };
+    };
+}
 export declare function createSendEmailMessageActions(params: {
     order: IOrderAsResult & {
         confirmationNumber: string;
@@ -12,8 +38,8 @@ export declare function createSendEmailMessageActions(params: {
     customer: factory.order.ICustomer;
     seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
-    potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
+    potentialActions?: IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
     emailMessages: factory.action.transfer.send.message.email.IObjectAsEmailMessage[];
-    sendEmailMessageActions: factory.transaction.placeOrder.IPotentialSendEmailMessageAction[];
 }>;
+export {};

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

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSendEmailMessageActions = createSendEmailMessageActions;
 const emailMessageBuilder_1 = require("../../../../../emailMessageBuilder");
-const factory_1 = require("../../../../../factory");
 async function createSendEmailMessageActions(params, setting) {
     // 注文配送メール送信設定
     const emailMessages = [];
-    const sendEmailMessageActions = [];
+    // const sendEmailMessageActions: factory.transaction.placeOrder.IPotentialSendEmailMessageAction[] = [];
     const sendEmailMessageOnOrderSentParams = params.potentialActions?.order?.potentialActions?.sendOrder?.potentialActions?.sendEmailMessage;
     if (Array.isArray(sendEmailMessageOnOrderSentParams)) {
         // pugテンプレートに渡す変数を最小化(2026-06-19~)
@@ -27,16 +26,16 @@ async function createSendEmailMessageActions(params, setting) {
                 // ...(params.emailMessage !== undefined) ? { emailMessage: params.emailMessage } : undefined
             }, setting);
             emailMessages.push(emailMessage);
-            // 送信アクション最適化に対応(2024-04-29~)
-            const sendEmailMessageActionObject = {
-                identifier: emailMessage.identifier,
-                typeOf: factory_1.factory.creativeWorkType.EmailMessage
-            };
-            // optimize(2024-05-07~)
-            sendEmailMessageActions.push({
-                object: sendEmailMessageActionObject
-            });
+            // // 送信アクション最適化に対応(2024-04-29~)
+            // const sendEmailMessageActionObject: factory.action.transfer.send.message.email.IObject = {
+            //     identifier: emailMessage.identifier,
+            //     typeOf: factory.creativeWorkType.EmailMessage
+            // };
+            // // optimize(2024-05-07~)
+            // sendEmailMessageActions.push({
+            //     object: sendEmailMessageActionObject
+            // });
         }));
     }
-    return { sendEmailMessageActions, emailMessages };
+    return { emailMessages };
 }

package/lib/chevre/service/transaction/placeOrder/confirm/potentialActions.d.ts

@@ -1,6 +1,8 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
+import { IPotentialActionsParams } from './potentialActions/sendEmailMessage';
 import { IOrderAsResult } from './factory/result';
+export { IPotentialActionsParams };
 /**
  * 取引のポストアクションを作成する
  */
@@ -15,8 +17,8 @@ export declare function createPotentialActions(params: {
     customer: factory.order.ICustomer;
     seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
-    potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
+    potentialActions?: IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
-    potentialActions: factory.transaction.placeOrder.IPotentialActions;
+    potentialActions?: never;
     emailMessages: factory.creativeWork.message.email.ICreativeWork[];
 }>;

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

@@ -7,14 +7,13 @@ const sendEmailMessage_1 = require("./potentialActions/sendEmailMessage");
  */
 async function createPotentialActions(params, setting) {
     // 注文処理開始メール送信設定
-    const { emailMessages, sendEmailMessageActions } = await (0, sendEmailMessage_1.createSendEmailMessageActions)(params, setting);
+    const { emailMessages } = await (0, sendEmailMessage_1.createSendEmailMessageActions)(params, setting);
     return {
         emailMessages,
-        potentialActions: {
-            order: {
-                onOrderProcessing: { sendEmailMessage: sendEmailMessageActions } // optimize(2024-06-29~)
-                // potentialActions: { sendOrder: sendOrderActionAttributes }
-            }
-        }
+        // potentialActions: {
+        //     order: {
+        //         onOrderProcessing: { sendEmailMessage: sendEmailMessageActions } // optimize(2024-06-29~)
+        //     }
+        // }
     };
 }