@chevre/domain 24.0.0-alpha.6 → 24.0.0-alpha.60

package/lib/chevre/service/payment/any/invalidatePaymentUrl.d.ts

@@ -0,0 +1,29 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+interface IInvalidatePaymentUrlRepos {
+    accountingReport: AccountingReportRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+/**
+ * 決済承認中止タスクから決済URLを無効化する
+ */
+declare function invalidatePaymentUrl(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    sameAs?: {
+        id: string;
+    };
+}): (repos: IInvalidatePaymentUrlRepos) => Promise<void>;
+export { IInvalidatePaymentUrlRepos, invalidatePaymentUrl, };

package/lib/chevre/service/payment/any/invalidatePaymentUrl.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidatePaymentUrl = invalidatePaymentUrl;
+const factory = __importStar(require("../../../factory"));
+/**
+ * 決済承認中止タスクから決済URLを無効化する
+ */
+function invalidatePaymentUrl(params) {
+    return async (repos
+    // settings: Settings
+    ) => {
+        if (params.purpose.typeOf !== factory.transactionType.PlaceOrder) {
+            throw new factory.errors.Argument('purpose.typeOf', `must be ${factory.transactionType.PlaceOrder}`);
+        }
+        const transaction = await repos.placeOrder.findPlaceOrderById({
+            typeOf: params.purpose.typeOf,
+            id: params.purpose.id
+        }, ['typeOf', 'status', 'object', 'project', 'seller', 'agent']);
+        // const orderCancelled: boolean = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+        // if (transaction.status === factory.transactionStatusType.Confirmed) {
+        //     if (!orderCancelled) {
+        //         // no op
+        //         return;
+        //     }
+        // }
+        // support multiple accept actions(2025-02-25~)
+        let acceptPayActions = await repos.acceptPayAction.findAcceptActionsByPurpose({
+            // project: { id: { $eq: transaction.project.id } },
+            // typeOf: { $eq: factory.actionType.AcceptAction },
+            // // actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] }, // all statuses(2025-02-26~)
+            // purpose: { id: { $in: [transaction.id] } },
+            // object: {
+            //     // transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
+            //     typeOf: { $eq: factory.assetTransactionType.Pay }
+            // }
+            project: { id: transaction.project.id },
+            purpose: { id: transaction.id },
+        }, ['object']);
+        switch (transaction.status) {
+            case factory.transactionStatusType.InProgress:
+                throw new factory.errors.NotImplemented(`${transaction.status} not implemented`);
+            case factory.transactionStatusType.Confirmed: {
+                // support OrderCanceled(2025-02-25~)
+                const orderCancelled = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+                if (!orderCancelled) {
+                    const paymentMethodIdByPaymentUrl = transaction.object.paymentMethods?.paymentMethodId;
+                    if (typeof paymentMethodIdByPaymentUrl === 'string') {
+                        acceptPayActions = acceptPayActions.filter(({ object }) => object.transactionNumber !== paymentMethodIdByPaymentUrl);
+                    }
+                }
+                break;
+            }
+            default:
+            // no op
+        }
+        const invalidatePaymentUrlTasks = [];
+        const runsAt = new Date();
+        for (const acceptPayAction of acceptPayActions) {
+            const paymentMethodIdByPaymentUrl = acceptPayAction.object.transactionNumber;
+            const paymentMethodType = acceptPayAction.object.object.paymentMethod.identifier;
+            if (typeof paymentMethodType === 'string' && paymentMethodType.length > 0) {
+                // create task(2025-02-26~)
+                // await PayTransactionService.invalidatePaymentUrl({})(repos, settings);
+                const invalidatePaymentUrlData = {
+                    project: transaction.project,
+                    typeOf: factory.actionType.RefundAction,
+                    agent: {
+                        typeOf: transaction.seller.typeOf,
+                        name: (typeof transaction.seller.name === 'string')
+                            ? transaction.seller.name
+                            : String(transaction.seller.name?.ja),
+                        id: transaction.seller.id
+                    },
+                    recipient: {
+                        typeOf: transaction.agent.typeOf,
+                        id: transaction.agent.id,
+                        name: transaction.agent.name
+                    },
+                    object: [{
+                            typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+                            id: acceptPayAction.object.object.id,
+                            paymentMethod: {
+                                additionalProperty: [],
+                                name: paymentMethodType,
+                                typeOf: paymentMethodType,
+                                paymentMethodId: paymentMethodIdByPaymentUrl
+                            },
+                            refundFee: 0
+                        }],
+                    purpose: { typeOf: transaction.typeOf, id: transaction.id },
+                    instrument: []
+                    // ...(typeof params.sameAs?.id === 'string') ? { sameAs: params.sameAs } : undefined
+                };
+                invalidatePaymentUrlTasks.push({
+                    project: transaction.project,
+                    name: factory.taskName.InvalidatePaymentUrl,
+                    status: factory.taskStatus.Ready,
+                    runsAt,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: invalidatePaymentUrlData
+                });
+            }
+        }
+        if (invalidatePaymentUrlTasks.length > 0) {
+            await repos.task.saveMany(invalidatePaymentUrlTasks, { emitImmediately: true });
+        }
+        // const paymentMethodIdByPaymentUrl = transaction.object.paymentMethods?.paymentMethodId;
+        // if (typeof paymentMethodIdByPaymentUrl === 'string' && paymentMethodIdByPaymentUrl.length > 0) {
+        //     const acceptPayAction = (<Pick<IAcceptPayAction, 'object'>[]>await repos.action.search(
+        //         {
+        //             limit: 1,
+        //             page: 1,
+        //             project: { id: { $eq: transaction.project.id } },
+        //             typeOf: { $eq: factory.actionType.AcceptAction },
+        //             actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
+        //             purpose: { id: { $in: [transaction.id] } },
+        //             object: {
+        //                 transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
+        //                 typeOf: { $eq: factory.assetTransactionType.Pay }
+        //             }
+        //         },
+        //         ['object']
+        //     )).shift();
+        //     if (acceptPayAction !== undefined) {
+        //         // const paymentMethodType = transaction.object.paymentMethods?.typeOf;
+        //         const paymentMethodType = acceptPayAction.object.object.paymentMethod.identifier;
+        //         if (typeof paymentMethodType === 'string' && paymentMethodType.length > 0) {
+        //             // chevreで決済URL無効化
+        //             await PayTransactionService.invalidatePaymentUrl({
+        //                 project: transaction.project,
+        //                 typeOf: factory.actionType.RefundAction,
+        //                 agent: {
+        //                     typeOf: transaction.seller.typeOf,
+        //                     name: (typeof transaction.seller.name === 'string')
+        //                         ? transaction.seller.name
+        //                         : String(transaction.seller.name?.ja),
+        //                     id: transaction.seller.id
+        //                 },
+        //                 recipient: {
+        //                     typeOf: transaction.agent.typeOf,
+        //                     id: transaction.agent.id,
+        //                     name: transaction.agent.name
+        //                 },
+        //                 object: [{
+        //                     typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+        //                     id: acceptPayAction.object.object.id,
+        //                     paymentMethod: {
+        //                         additionalProperty: [],
+        //                         name: paymentMethodType,
+        //                         typeOf: paymentMethodType,
+        //                         paymentMethodId: paymentMethodIdByPaymentUrl
+        //                     },
+        //                     refundFee: 0
+        //                 }],
+        //                 purpose: { typeOf: transaction.typeOf, id: transaction.id },
+        //                 instrument: [],
+        //                 ...(typeof params.sameAs?.id === 'string') ? { sameAs: params.sameAs } : undefined
+        //             })(repos, settings);
+        //         }
+        //     }
+        // }
+    };
+}

package/lib/chevre/service/payment/any/onPayActionCompleted.d.ts

@@ -3,11 +3,20 @@
  */
 import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { PayActionRepo } from '../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../repo/action/refund';
 import type { TaskRepo } from '../../../repo/task';
-declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: {
-    action: ActionRepo;
+interface IOnPayActionCompletedRepos {
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
     accountingReport: AccountingReportRepo;
     task: TaskRepo;
-}) => Promise<void>;
-export { onPayActionCompleted };
+}
+/**
+ * 決済アクション完了時処理
+ */
+declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: IOnPayActionCompletedRepos) => Promise<void>;
+export { IOnPayActionCompletedRepos, onPayActionCompleted };

package/lib/chevre/service/payment/any/onPayActionCompleted.js

@@ -30,6 +30,9 @@ exports.onPayActionCompleted = onPayActionCompleted;
 const factory = __importStar(require("../../../factory"));
 const factory_1 = require("./factory");
 const onPaymentStatusChanged_1 = require("./onPaymentStatusChanged");
+/**
+ * 決済アクション完了時処理
+ */
 function onPayActionCompleted(payAction) {
     return async (repos) => {
         const aciton4inform = (0, factory_1.optimizeAction4inform)(payAction);
@@ -42,12 +45,15 @@ function onPayActionCompleted(payAction) {
             await (0, onPaymentStatusChanged_1.onPaymentStatusChanged)(aciton4inform)(repos);
         }
         const informPayment = potentialActions?.informPayment;
+        /* istanbul ignore else -- @preserve */
         if (Array.isArray(informPayment)) {
             taskAttributes.push(...informPayment.map(({ purpose, id }) => {
                 let data;
                 if (typeof id === 'string' && id !== '') {
                     let about;
+                    /* istanbul ignore else -- @preserve */
                     if (payAction.purpose.typeOf === factory.order.OrderType.Order) {
+                        /* istanbul ignore else -- @preserve */
                         if (typeof payAction.purpose.orderNumber === 'string') {
                             about = { orderNumber: payAction.purpose.orderNumber, typeOf: factory.order.OrderType.Order };
                         }
@@ -61,8 +67,10 @@ function onPayActionCompleted(payAction) {
                         object: aciton4inform,
                         id, // add potentialAction(2025-02-05~)
                         typeOf: factory.actionType.InformAction,
-                        ...(typeof purpose?.typeOf === 'string') ? { purpose } : undefined,
-                        ...(typeof about?.typeOf === 'string') ? { about } : undefined // add(2025-02-14~)
+                        // ...(typeof purpose?.typeOf === 'string') ? { purpose } : {},
+                        // ...(typeof about?.typeOf === 'string') ? { about } : {}, // add(2025-02-14~)
+                        ...(typeof purpose?.typeOf === 'string' && { purpose }),
+                        ...(typeof about?.typeOf === 'string' && { about }),
                     };
                 }
                 else {

package/lib/chevre/service/payment/any/onPaymentStatusChanged.d.ts

@@ -1,10 +1,15 @@
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { PayActionRepo } from '../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../repo/action/refund';
 import { INotification } from './factory';
+export interface IOnPaymentStatusChangedRepos {
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    accountingReport: AccountingReportRepo;
+}
 /**
  * 決済ステータス変更イベント
  */
-export declare function onPaymentStatusChanged(params: INotification): (repos: {
-    action: ActionRepo;
-    accountingReport: AccountingReportRepo;
-}) => Promise<void>;
+export declare function onPaymentStatusChanged(params: Pick<INotification, 'id' | 'typeOf'>): (repos: IOnPaymentStatusChangedRepos) => Promise<void>;

package/lib/chevre/service/payment/any/onPaymentStatusChanged.js

@@ -32,19 +32,27 @@ const onRefunded_1 = require("./onPaymentStatusChanged/onRefunded");
  */
 function onPaymentStatusChanged(params) {
     return async (repos) => {
-        // アクションリポジトリから実アクションを参照する
-        // そうすることで、通知する情報は最低限で済む
-        const action = await repos.action.findById({ id: params.id, typeOf: params.typeOf });
-        const optimizedAction = optimizeAction4report(action);
-        switch (optimizedAction.typeOf) {
-            case factory.actionType.PayAction:
+        switch (params.typeOf) {
+            case factory.actionType.PayAction: {
+                // アクションリポジトリから実アクションを参照する
+                // そうすることで、通知する情報は最低限で済む
+                const action = await repos.actions.pay.findById({ id: params.id, typeOf: params.typeOf });
+                const optimizedAction = optimizeAction4report((action));
                 await (0, onPaid_1.onPaid)(optimizedAction, { id: action.project.id })(repos);
                 break;
-            case factory.actionType.RefundAction:
+            }
+            case factory.actionType.RefundAction: {
+                // アクションリポジトリから実アクションを参照する
+                // そうすることで、通知する情報は最低限で済む
+                const action = await repos.actions.refund.findById({ id: params.id, typeOf: params.typeOf });
+                const optimizedAction = optimizeAction4report((action));
                 await (0, onRefunded_1.onRefunded)(optimizedAction, { id: action.project.id })(repos);
                 break;
-            default:
-            // no op
+            }
+            /* istanbul ignore next */
+            default: {
+                // no op
+            }
         }
     };
 }
@@ -56,7 +64,7 @@ function optimizeAction4report(action) {
     // 現時点で経理レポートで使用されているのは、typeOf,object,purpose,startDate
     const actionTypeOf = action.typeOf;
     switch (actionTypeOf) {
-        case factory.actionType.PayAction:
+        case factory.actionType.PayAction: {
             const optimizedPayActionObject = action.object.map((o) => {
                 return {
                     id: o.id,
@@ -77,7 +85,8 @@ function optimizeAction4report(action) {
             };
             optimizedAction = optimizedPayAction;
             break;
-        case factory.actionType.RefundAction:
+        }
+        case factory.actionType.RefundAction: {
             const optimizedRefundActionObject = action.object.map((o) => {
                 return {
                     id: o.id,
@@ -100,6 +109,7 @@ function optimizeAction4report(action) {
             };
             optimizedAction = optimizedRefundAction;
             break;
+        }
         default:
             throw new factory.errors.NotImplemented(`action type '${actionTypeOf}' not implemented`);
     }

package/lib/chevre/service/payment/any/onRefundActionCompletedOrFailed.d.ts

@@ -1,18 +1,21 @@
-/**
- * 汎用決済サービス
- */
 import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { PayActionRepo } from '../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../repo/action/refund';
 import type { TaskRepo } from '../../../repo/task';
+interface IOnRefundActionCompletedOrFailedRepos {
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    accountingReport: AccountingReportRepo;
+    task: TaskRepo;
+}
 /**
  * 返金後のアクション
  */
 declare function onRefundActionCompletedOrFailed(refundAction: Pick<factory.action.trade.refund.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'> & {
     actionStatus: factory.actionStatusType.CompletedActionStatus | factory.actionStatusType.FailedActionStatus;
-}): (repos: {
-    action: ActionRepo;
-    accountingReport: AccountingReportRepo;
-    task: TaskRepo;
-}) => Promise<void>;
-export { onRefundActionCompletedOrFailed };
+}): (repos: IOnRefundActionCompletedOrFailedRepos) => Promise<void>;
+export { IOnRefundActionCompletedOrFailedRepos, onRefundActionCompletedOrFailed };

package/lib/chevre/service/payment/any/onRefundActionCompletedOrFailed.js

@@ -24,9 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onRefundActionCompletedOrFailed = onRefundActionCompletedOrFailed;
-/**
- * 汎用決済サービス
- */
 const factory = __importStar(require("../../../factory"));
 const factory_1 = require("./factory");
 const onPaymentStatusChanged_1 = require("./onPaymentStatusChanged");
@@ -54,12 +51,14 @@ function onRefundActionCompletedOrFailed(refundAction) {
             // CreditCardIFのみ(2023-06-29~)
             const firstObject = refundAction.object[0];
             const paymentServiceType = firstObject?.typeOf;
+            /* istanbul ignore else -- @preserve */
             if (paymentServiceType === factory.service.paymentService.PaymentServiceType.CreditCard) {
                 const refundFee = firstObject?.refundFee;
                 if (typeof refundFee === 'number' && refundFee > 0) {
                     // purpose.typeOf:PlaceOrderは外部決済URL無効化における返金アクションのみなので、手数料決済から除外してよい(2024-03-19~)
                     // purpose.typeOf:Orderは決済カード承認時着券の取消なので、手数料決済から除外してよい
                     // 手数料決済は注文返品による返金アクションからしか発生しないはず(2024-06-13~)
+                    /* istanbul ignore else -- @preserve */
                     if (refundAction.purpose.typeOf === factory.actionType.ReturnAction) {
                         const payReturnFeeObject = [{
                                 typeOf: firstObject.typeOf,
@@ -86,7 +85,7 @@ function onRefundActionCompletedOrFailed(refundAction) {
                             object: payReturnFeeObject,
                             purpose: refundAction.purpose,
                             potentialActions: {
-                                informPayment: (Array.isArray(informPayment)) ? informPayment : [],
+                                informPayment: (Array.isArray(informPayment)) ? informPayment : /* istanbul ignore next -- @preserve */ [],
                                 add2report: true
                             },
                             instrument // add(2025-02-19~)
@@ -105,11 +104,13 @@ function onRefundActionCompletedOrFailed(refundAction) {
                     }
                 }
             }
+            /* istanbul ignore else -- @preserve */
             if (Array.isArray(informPayment)) {
                 taskAttributes.push(...informPayment.map(({ purpose, id }) => {
                     let data;
                     if (typeof id === 'string' && id !== '') {
                         let about;
+                        /* istanbul ignore else -- @preserve */
                         if (refundAction.purpose.typeOf === factory.actionType.ReturnAction) {
                             about = {
                                 orderNumber: refundAction.purpose.object.orderNumber,
@@ -122,8 +123,10 @@ function onRefundActionCompletedOrFailed(refundAction) {
                             object: aciton4inform,
                             id, // add potentialAction(2025-02-05~)
                             typeOf: factory.actionType.InformAction,
-                            ...(typeof purpose?.typeOf === 'string') ? { purpose } : undefined,
-                            ...(typeof about?.typeOf === 'string') ? { about } : undefined // add(2025-02-14~)
+                            // ...(typeof purpose?.typeOf === 'string') ? { purpose } : undefined,
+                            // ...(typeof about?.typeOf === 'string') ? { about } : undefined // add(2025-02-14~)
+                            ...(typeof purpose?.typeOf === 'string' && { purpose }),
+                            ...(typeof about?.typeOf === 'string' && { about }),
                         };
                     }
                     else {

package/lib/chevre/service/payment/any/processVoidPayTransaction.d.ts

@@ -0,0 +1,30 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+interface IProcessVoidPayTransactionRepos {
+    action?: never;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    accountingReport: AccountingReportRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+declare function processVoidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    project: {
+        id: string;
+    };
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+}): (repos: IProcessVoidPayTransactionRepos) => Promise<void>;
+export { IProcessVoidPayTransactionRepos, processVoidPayTransaction, };

package/lib/chevre/service/payment/any/processVoidPayTransaction.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVoidPayTransaction = processVoidPayTransaction;
+const factory = __importStar(require("../../../factory"));
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+function processVoidPayTransaction(params) {
+    return async (repos) => {
+        const cancelAction = {
+            startTime: new Date(),
+            agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+            ...(typeof params.sameAs?.id === 'string') ? { sameAs: { id: params.sameAs.id, typeOf: 'Task' } } : undefined
+        };
+        let transaction;
+        // アクションID指定の場合、進行中取引検証(2023-02-24~)
+        if (typeof params.id === 'string') {
+            transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: params.purpose.typeOf, id: params.purpose.id }, ['typeOf', 'status']);
+        }
+        else {
+            transaction = await repos.placeOrder.findPlaceOrderById({ typeOf: params.purpose.typeOf, id: params.purpose.id }, ['typeOf', 'status', 'result']);
+        }
+        // 承認アクションを取得
+        let authorizeActions;
+        if (typeof params.id === 'string') {
+            const authorizeAction = await repos.authorizePaymentMethodAction.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            // 取引内のアクションかどうか確認
+            if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
+                throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
+            }
+            authorizeActions = [authorizeAction];
+        }
+        else {
+            authorizeActions = await repos.authorizePaymentMethodAction.findAuthorizePaymentMethodActionsByPurpose({
+                // typeOf: factory.actionType.AuthorizeAction,
+                purpose: { typeOf: transaction.typeOf, id: transaction.id },
+                // object: { typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment } }
+            });
+            switch (transaction.status) {
+                case factory.transactionStatusType.InProgress:
+                    throw new factory.errors.NotImplemented(`${transaction.status} not implemented`);
+                case factory.transactionStatusType.Confirmed: {
+                    // OrderCancelledを考慮(2023-08-30~)
+                    const orderCancelled = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+                    if (!orderCancelled) {
+                        // 取り消すべきアクションに絞る
+                        authorizeActions = authorizeActions.filter(({ actionStatus }) => actionStatus !== factory.actionStatusType.CompletedActionStatus);
+                        const actionIdsFromTransactionResult = transaction.result?.authorizeActions?.map(({ id }) => id);
+                        if (!Array.isArray(actionIdsFromTransactionResult)) {
+                            throw new factory.errors.Argument('Transaction', `${transaction.id} must have result.authorizeActions`);
+                        }
+                        authorizeActions = authorizeActions.filter(({ id }) => !actionIdsFromTransactionResult.includes(id));
+                        // CreditCardIFでは、事前発行のpaymentMethodIdを承認時に指定するケースがある
+                        // その場合、paymentMethodIdの重複がありうる
+                        // exclude paymentMethodId in the order(2025-02-25~)
+                        let authorizedPaymentMethodIds = [];
+                        authorizedPaymentMethodIds = authorizeActions.filter(({ id }) => actionIdsFromTransactionResult.includes(id))
+                            .map(({ object }) => object.paymentMethodId);
+                        authorizedPaymentMethodIds = [...new Set(authorizedPaymentMethodIds)];
+                        authorizeActions =
+                            authorizeActions.filter(({ object }) => !authorizedPaymentMethodIds.includes(object.paymentMethodId));
+                    }
+                    break;
+                }
+                default:
+                // no op
+            }
+        }
+        const errors = [];
+        for (const action of authorizeActions) {
+            // 失敗するケースがあっても、残りが少なくとも処理されるようにエラーハンドリング
+            try {
+                await repos.authorizePaymentMethodAction.cancelWithVoid({ typeOf: action.typeOf, id: action.id, cancelAction });
+                // 取引が存在すれば中止
+                const transactionNumber = action.object.paymentMethodId;
+                if (typeof transactionNumber === 'string' && transactionNumber.length > 0) {
+                    const payTransaction = (await repos.assetTransaction.search({
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: action.project.id } },
+                        typeOf: factory.assetTransactionType.Pay,
+                        transactionNumber: { $eq: transactionNumber }
+                    }, ['_id', 'status'])).shift();
+                    if (payTransaction !== undefined) {
+                        // ステータス検証(Expiredから実行される可能性がある)
+                        if (payTransaction.status !== factory.transactionStatusType.Canceled
+                            && payTransaction.status !== factory.transactionStatusType.Expired) {
+                            await PayTransactionService.cancel({ transactionNumber })(repos);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+    };
+}

package/lib/chevre/service/payment/any/publishPaymentUrl/fixTransactionNumberOnPublishPaymentUrl.d.ts

@@ -1,7 +1,7 @@
 import * as factory from '../../../../factory';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress } from '../../../../repo/transaction';
+import type { ITransactionInProgress } from '../../../../repo/transaction/placeOrder';
 import type { TransactionNumberRepo } from '../../../../repo/transactionNumber';
 interface IFixTransactionNumberRepos {
     authorization: AuthorizationRepo;
@@ -17,7 +17,7 @@ type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWi
  */
 declare function fixTransactionNumberOnPublishPaymentUrl(params: {
     object: IObjectWithoutDetail;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'id' | 'project'>;
+    transaction: Pick<ITransactionInProgress, 'id' | 'project'>;
     paymentServiceType: factory.service.paymentService.PaymentServiceType;
 }): IFixTransactionNumberOperation<{
     transactionNumber: string;