@chevre/domain 21.33.0-alpha.9 → 21.33.0

package/lib/chevre/repo/transaction.js

@@ -290,11 +290,12 @@ class MongoRepository {
     /**
      * 特定取引検索
      */
-    findById(params) {
+    findById(params, inclusion, // make required(2024-05-31~)
+    exclusion) {
         return __awaiter(this, void 0, void 0, function* () {
             let projection = {};
-            if (Array.isArray(params.inclusion) && params.inclusion.length > 0) {
-                params.inclusion.forEach((field) => {
+            if (Array.isArray(inclusion) && inclusion.length > 0) {
+                inclusion.forEach((field) => {
                     projection[field] = 1;
                 });
             }
@@ -304,8 +305,8 @@ class MongoRepository {
                     createdAt: 0,
                     updatedAt: 0
                 };
-                if (Array.isArray(params.exclusion) && params.exclusion.length > 0) {
-                    params.exclusion.forEach((field) => {
+                if (Array.isArray(exclusion) && exclusion.length > 0) {
+                    exclusion.forEach((field) => {
                         projection[field] = 0;
                     });
                 }
@@ -360,6 +361,23 @@ class MongoRepository {
             return doc.toObject();
         });
     }
+    /**
+     * 進行中取引に保管された採用済決済方法を検索する
+     */
+    findInProgressPaymentMethodId(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const doc = yield this.transactionModel.findOne({
+                _id: { $eq: params.id },
+                typeOf: { $eq: factory.transactionType.PlaceOrder },
+                status: { $eq: factory.transactionStatusType.InProgress }
+            }, { 'object.paymentMethods': 1 })
+                .exec();
+            if (doc === null) {
+                throw new factory.errors.NotFound(this.transactionModel.modelName);
+            }
+            return doc.toObject().object.paymentMethods;
+        });
+    }
     /**
      * 取引の注文番号を検索する
      */
@@ -481,14 +499,14 @@ class MongoRepository {
                 .exec();
             // NotFoundであれば取引状態確認
             if (doc === null) {
-                const transaction = yield this.findById({ typeOf: params.typeOf, id: params.id });
-                if (transaction.status === factory.transactionStatusType.Confirmed) {
+                const { status } = yield this.findById({ typeOf: params.typeOf, id: params.id }, ['status']);
+                if (status === factory.transactionStatusType.Confirmed) {
                     // すでに確定済の場合スルー
                 }
-                else if (transaction.status === factory.transactionStatusType.Expired) {
+                else if (status === factory.transactionStatusType.Expired) {
                     throw new factory.errors.Argument('Transaction id', 'Already expired');
                 }
-                else if (transaction.status === factory.transactionStatusType.Canceled) {
+                else if (status === factory.transactionStatusType.Canceled) {
                     throw new factory.errors.Argument('Transaction id', 'Already canceled');
                 }
                 else {
@@ -530,12 +548,11 @@ class MongoRepository {
                 .then((doc) => (doc === null) ? null : doc.toObject());
         });
     }
-    // tslint:disable-next-line:no-suspicious-comment
     /**
      * タスクエクスポートリトライ
-     * TODO updatedAtを基準にしているが、タスクエクスポートトライ日時を持たせた方が安全か？
+     * @deprecated use reexportTasksByExportAction
      */
-    reexportTasks(params) {
+    reexportTasksByExportationStatus(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const reexportingTransactions = yield this.transactionModel.find({
                 tasksExportationStatus: { $eq: factory.transactionTasksExportationStatus.Exporting },
@@ -573,6 +590,46 @@ class MongoRepository {
             }
         });
     }
+    reexportTasksByExportAction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reexportingTransactions = yield this.transactionModel.find({
+                'tasksExportAction.actionStatus': {
+                    $exists: true,
+                    $eq: factory.actionStatusType.ActiveActionStatus
+                },
+                'tasksExportAction.startDate': {
+                    $exists: true,
+                    $lt: moment()
+                        .add(-params.intervalInMinutes, 'minutes')
+                        .toDate()
+                }
+            }, { _id: 1, typeOf: 1, status: 1 })
+                .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+                .exec();
+            if (reexportingTransactions.length > 0) {
+                for (const reexportingTransaction of reexportingTransactions) {
+                    yield this.transactionModel.updateOne({
+                        _id: { $eq: reexportingTransaction.id },
+                        'tasksExportAction.actionStatus': {
+                            $exists: true,
+                            $eq: factory.actionStatusType.ActiveActionStatus
+                        }
+                    }, {
+                        tasksExportAction: {
+                            actionStatus: factory.actionStatusType.PotentialActionStatus
+                        },
+                        tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported
+                    })
+                        .exec();
+                    transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+                        id: reexportingTransaction.id,
+                        typeOf: reexportingTransaction.typeOf,
+                        status: reexportingTransaction.status
+                    });
+                }
+            }
+        });
+    }
     /**
      * タスクエクスポートの遅延している取引について明示的にemitTransactionStatusChangedを実行する
      */
@@ -684,14 +741,14 @@ class MongoRepository {
                 .exec();
             // NotFoundであれば取引状態確認
             if (doc === null) {
-                const transaction = yield this.findById(params);
-                if (transaction.status === factory.transactionStatusType.Canceled) {
+                const { status } = yield this.findById(params, ['status']);
+                if (status === factory.transactionStatusType.Canceled) {
                     // すでに中止済の場合スルー
                 }
-                else if (transaction.status === factory.transactionStatusType.Expired) {
+                else if (status === factory.transactionStatusType.Expired) {
                     throw new factory.errors.Argument('Transaction id', 'Transaction already expired');
                 }
-                else if (transaction.status === factory.transactionStatusType.Confirmed) {
+                else if (status === factory.transactionStatusType.Confirmed) {
                     throw new factory.errors.Argument('Transaction id', 'Confirmed transaction unable to cancel');
                 }
                 else {
@@ -758,7 +815,7 @@ class MongoRepository {
         });
     }
     /**
-     * 特定の取引を更新する(汎用)
+     * 特定の進行中取引を更新する(汎用)
      */
     findByIdAndUpdateInProgress(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -777,6 +834,21 @@ class MongoRepository {
             });
         });
     }
+    findByIdAndUpdate4migrate(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transactionModel.findOneAndUpdate({
+                _id: { $eq: params.id }
+            }, params.update, {
+                projection: { _id: 1 }
+            })
+                .exec()
+                .then((doc) => {
+                if (doc === null) {
+                    throw new factory.errors.ArgumentNull(this.transactionModel.modelName);
+                }
+            });
+        });
+    }
     saveOrderNumberIfNotExist(params) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.transactionModel.updateOne({

package/lib/chevre/service/assetTransaction/pay.d.ts

@@ -74,7 +74,7 @@ export type IPublishPaymentUrlResult = CreditCardPayment.IPaymentAgencyTransacti
     paymentUrl: string;
 };
 /**
- * 外部決済ロケーション発行
+ * 決済ロケーション発行
  */
 export declare function publishPaymentUrl(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, options: {
     purposeAsTransaction: {
@@ -95,7 +95,11 @@ export declare function publishPaymentUrl(params: factory.assetTransaction.pay.I
  * 決済ロケーションを無効化する
  * 実質、外部で実行された決済に対する返金処理
  */
-export declare function invalidatePaymentUrl(params: factory.task.refund.IData): IInvalidatePaymentUrlOperation<void>;
+export declare function invalidatePaymentUrl(params: Omit<factory.task.refund.IData, 'sameAs'> & {
+    sameAs?: {
+        id: string;
+    };
+}): IInvalidatePaymentUrlOperation<void>;
 /**
  * 決済方法認証
  */

package/lib/chevre/service/assetTransaction/pay.js

@@ -19,11 +19,46 @@ const PaymentCardPayment = require("../payment/paymentCard");
 const validation_1 = require("./pay/account/validation");
 const factory_1 = require("./pay/factory");
 const debug = createDebug('chevre-domain:service:assetTransaction');
+function publishPaymentUrlResult2recipe(params) {
+    const { project, action, result } = params;
+    return {
+        project: { id: project.id, typeOf: factory.organizationType.Project },
+        typeOf: 'Recipe',
+        recipeCategory: factory.recipe.RecipeCategory.publishPaymentUrl,
+        recipeFor: { id: action.id, typeOf: action.typeOf },
+        step: [{
+                typeOf: 'HowToSection',
+                itemListElement: [
+                    {
+                        typeOf: 'HowToStep',
+                        identifier: factory.recipe.StepIdentifier.entryTran,
+                        itemListElement: [{
+                                typeOf: 'HowToDirection',
+                                beforeMedia: result.entryTranArgs,
+                                afterMedia: result.entryTranResult
+                                // text: 'entryTran'
+                            }]
+                    },
+                    {
+                        typeOf: 'HowToStep',
+                        identifier: factory.recipe.StepIdentifier.execTran,
+                        itemListElement: [{
+                                typeOf: 'HowToDirection',
+                                beforeMedia: result.execTranArgs,
+                                afterMedia: result.execTranResult
+                                // text: 'execTran'
+                            }]
+                    }
+                ]
+            }]
+    };
+}
 /**
- * 外部決済ロケーション発行
+ * 決済ロケーション発行
  */
 // tslint:disable-next-line:max-func-body-length
 function publishPaymentUrl(params, options) {
+    // tslint:disable-next-line:max-func-body-length
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e;
         const paymentServiceType = (_a = params.object) === null || _a === void 0 ? void 0 : _a.typeOf;
@@ -77,6 +112,13 @@ function publishPaymentUrl(params, options) {
                         execTranArgs: authorizeResult.execTranArgs,
                         execTranResult: authorizeResult.execTranResult
                     };
+                    // create recipe(2024-06-02~)
+                    const saveRecipeResult = yield repos.action.saveOneRecipe(publishPaymentUrlResult2recipe({
+                        project: { id: params.project.id },
+                        action: { id: action.id, typeOf: action.typeOf },
+                        result
+                    }));
+                    debug('publishPaymentUrl: recipe saved.', JSON.stringify(saveRecipeResult));
                     break;
                 default:
                     throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
@@ -147,7 +189,7 @@ exports.check = check;
  */
 function start(params, options) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // 金額をfix
         const amount = (_a = params.object.paymentMethod) === null || _a === void 0 ? void 0 : _a.amount;
         if (typeof amount !== 'number') {
@@ -183,7 +225,9 @@ function start(params, options) {
                 break;
             case factory.service.paymentService.PaymentServiceType.MovieTicket:
                 transaction =
-                    yield processAuthorizeMovieTicket(params, transaction, String(paymentService === null || paymentService === void 0 ? void 0 : paymentService.id), options.useCheckMovieTicketBeforePay, options.useCheckByIdentifierIfNotYet)(repos);
+                    yield processAuthorizeMovieTicket(params, transaction, String(paymentService === null || paymentService === void 0 ? void 0 : paymentService.id), options.useCheckMovieTicketBeforePay, options.useCheckByIdentifierIfNotYet, {
+                        executor: (typeof ((_d = options.executor) === null || _d === void 0 ? void 0 : _d.id) === 'string') ? { id: options.executor.id } : {}
+                    })(repos);
                 break;
             default:
                 throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
@@ -347,9 +391,9 @@ function processAuthorizeCreditCard(params, transaction, paymentServiceId, optio
         })(repos);
     });
 }
-function processAuthorizeMovieTicket(params, transaction, paymentServiceId, useCheckMovieTicketBeforePay, useCheckByIdentifierIfNotYet) {
+function processAuthorizeMovieTicket(params, transaction, paymentServiceId, useCheckMovieTicketBeforePay, useCheckByIdentifierIfNotYet, options) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
-        const { accountId, payAction, accountsReceivablesByServiceType } = yield MovieTicketPayment.authorize(params, transaction, paymentServiceId, useCheckMovieTicketBeforePay, useCheckByIdentifierIfNotYet)(repos);
+        const { accountId, payAction, accountsReceivablesByServiceType } = yield MovieTicketPayment.authorize(params, transaction, paymentServiceId, useCheckMovieTicketBeforePay, useCheckByIdentifierIfNotYet, options)(repos);
         const payActionInObject = {
             actionStatus: payAction.actionStatus,
             id: payAction.id,

package/lib/chevre/service/offer/event/voidTransaction.js

@@ -31,9 +31,8 @@ function voidTransaction(params) {
         const cancelAction = Object.assign({ startTime: new Date(), agent: { id: params.project.id, typeOf: factory.organizationType.Project } }, (typeof ((_a = params.sameAs) === null || _a === void 0 ? void 0 : _a.id) === 'string') ? { sameAs: { id: params.sameAs.id, typeOf: 'Task' } } : undefined);
         const transaction = yield repos.transaction.findById({
             typeOf: params.purpose.typeOf,
-            id: params.purpose.id,
-            inclusion: ['_id', 'typeOf', 'status', 'object.orderNumber']
-        });
+            id: params.purpose.id
+        }, ['typeOf', 'status', 'object.orderNumber']);
         // 興行オファー承認アクション検索
         let authorizeActions = yield repos.action.searchByPurpose({
             typeOf: factory.actionType.AuthorizeAction,
@@ -104,9 +103,8 @@ function cancelAcceptActions(params) {
         const cancelAction = Object.assign({ startTime: new Date(), agent: { id: params.project.id, typeOf: factory.organizationType.Project } }, (typeof ((_a = params.sameAs) === null || _a === void 0 ? void 0 : _a.id) === 'string') ? { sameAs: { id: params.sameAs.id, typeOf: 'Task' } } : undefined);
         const transaction = yield repos.transaction.findById({
             typeOf: params.purpose.typeOf,
-            id: params.purpose.id,
-            inclusion: ['_id', 'typeOf', 'status']
-        });
+            id: params.purpose.id
+        }, ['typeOf', 'status']);
         // 興行オファー承認アクション検索
         const completedAuthorizeActions = yield repos.action.searchByPurpose({
             typeOf: factory.actionType.AuthorizeAction,

package/lib/chevre/service/offer/eventServiceByCOA/findAcceptAction.js

@@ -43,7 +43,8 @@ function findAcceptAction(params) {
             default:
                 // タスクがReadyでなければアクション検索
                 const acceptAction = (yield repos.action.searchBySameAs({
-                    sameAs: { id: { $eq: task.id } }
+                    sameAs: { id: { $eq: task.id } },
+                    typeOf: { $eq: factory.actionType.AcceptAction }
                     // purpose: { id: { $eq: String(params.purpose.id) } }
                 })).shift();
                 if (acceptAction !== undefined) {

package/lib/chevre/service/offer/product.js

@@ -192,7 +192,7 @@ function voidTransaction(params) {
         const transaction = yield repos.transaction.findById({
             typeOf: params.purpose.typeOf,
             id: params.purpose.id
-        });
+        }, ['agent', 'status', 'typeOf']);
         if (transaction.status !== factory.transactionStatusType.Canceled
             && transaction.status !== factory.transactionStatusType.Expired
             && transaction.status !== factory.transactionStatusType.InProgress) {

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

@@ -0,0 +1,23 @@
+import * as factory from '../../../factory';
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { ITransactionInProgress, MongoRepository as TransactionRepo } from '../../../repo/transaction';
+import * as PayTransactionService from '../../assetTransaction/pay';
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail;
+declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
+    object: Pick<IObjectWithoutDetail, 'amount' | 'issuedThrough' | 'paymentMethod'>;
+    prePublishedPaymentMethodId: string;
+    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
+}): (repos: {
+    action: ActionRepo;
+    transaction: TransactionRepo;
+}) => Promise<{
+    authorizeParams?: {
+        creditCard: factory.action.authorize.paymentMethod.any.ICreditCard;
+        paymentMethodByTransaction: factory.transaction.placeOrder.IPaymentMethodByPaymentUrl;
+        pendingPaymentAgencyTransaction: PayTransactionService.IPaymentAgencyTransaction;
+    } | undefined;
+    existingCompletedAuthorizeAction?: {
+        id: string;
+    } | undefined;
+}>;
+export { handlePrePublishedPaymentMethodIdOnAuthorizing };

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

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePrePublishedPaymentMethodIdOnAuthorizing = void 0;
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service:payment');
+function recipe2paymentAgencyTransaction(actionRecipe) {
+    var _a;
+    let entryTranArgs;
+    let entryTranResult;
+    let execTranArgs;
+    let execTranResult;
+    if (actionRecipe.recipeCategory !== factory.recipe.RecipeCategory.publishPaymentUrl) {
+        throw new factory.errors.NotFound('', `Recipe with category ${factory.recipe.RecipeCategory.publishPaymentUrl} not found`);
+    }
+    const howToSection = actionRecipe.step;
+    const howToSteps = (_a = howToSection.at(0)) === null || _a === void 0 ? void 0 : _a.itemListElement;
+    if (Array.isArray(howToSteps)) {
+        howToSteps.forEach((howToStep) => {
+            var _a, _b, _c, _d;
+            const stepIdentifier = howToStep.identifier;
+            if (stepIdentifier === factory.recipe.StepIdentifier.entryTran) {
+                entryTranArgs = (_a = howToStep.itemListElement.at(0)) === null || _a === void 0 ? void 0 : _a.beforeMedia;
+                entryTranResult = (_b = howToStep.itemListElement.at(0)) === null || _b === void 0 ? void 0 : _b.afterMedia;
+            }
+            else if (stepIdentifier === factory.recipe.StepIdentifier.execTran) {
+                execTranArgs = (_c = howToStep.itemListElement.at(0)) === null || _c === void 0 ? void 0 : _c.beforeMedia;
+                execTranResult = (_d = howToStep.itemListElement.at(0)) === null || _d === void 0 ? void 0 : _d.afterMedia;
+            }
+            else {
+                throw new factory.errors.NotImplemented(`howToStep.identifier '${stepIdentifier}' not implemented`);
+            }
+        });
+    }
+    if (entryTranArgs === undefined || entryTranResult === undefined
+        || execTranArgs === undefined || execTranResult === undefined) {
+        throw new factory.errors.NotFound(`beforeMedia or afterMedia of actionRecipe`);
+    }
+    return { entryTranArgs, entryTranResult, execTranArgs, execTranResult };
+}
+function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let creditCard;
+        let pendingPaymentAgencyTransaction;
+        let existingCompletedAuthorizeAction;
+        // transaction.objectへのアクセス回避(2024-05-30~)
+        // const paymentMethodByTransaction = transaction.object.paymentMethods;
+        const paymentMethodByTransaction = yield repos.transaction.findInProgressPaymentMethodId({ id: params.transaction.id });
+        if (params.prePublishedPaymentMethodId === (paymentMethodByTransaction === null || paymentMethodByTransaction === void 0 ? void 0 : paymentMethodByTransaction.paymentMethodId)) {
+            // check existence of acceptAction when authorizing payment(2024-06-01~)
+            const acceptPayAction = (yield repos.action.search({
+                limit: 1,
+                page: 1,
+                project: { id: { $eq: params.transaction.project.id } },
+                typeOf: { $eq: factory.actionType.AcceptAction },
+                actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
+                purpose: { id: { $in: [params.transaction.id] } },
+                object: {
+                    transactionNumber: { $eq: params.prePublishedPaymentMethodId },
+                    typeOf: { $eq: factory.assetTransactionType.Pay }
+                }
+            }, ['object', 'result'], [])).shift();
+            if (acceptPayAction === undefined) {
+                throw new factory.errors.NotFound(factory.actionType.AcceptAction);
+            }
+            debug('acceptPayAction found:', acceptPayAction.id);
+            // find recipe(2024-06-02~)
+            const actionRecipe = yield repos.action.findRecipeByAction({
+                project: { id: params.transaction.project.id },
+                recipeFor: { id: acceptPayAction.id }
+            });
+            debug('actionRecipe found:', actionRecipe === null || actionRecipe === void 0 ? void 0 : actionRecipe.recipeCategory);
+            // 検証強化(2024-01-04~)
+            validatePaymentMethodByTransaction({
+                object: params.object,
+                acceptObject: acceptPayAction.object
+            });
+            // use actionRecipe(2024-06-02~)
+            if (typeof (actionRecipe === null || actionRecipe === void 0 ? void 0 : actionRecipe.recipeCategory) === 'string') {
+                pendingPaymentAgencyTransaction = recipe2paymentAgencyTransaction(actionRecipe);
+                creditCard = acceptPayAction.object.object.paymentMethod.creditCard;
+            }
+            else {
+                // discontinue(2024-06-05~)
+                // const { entryTranArgs, entryTranResult, execTranArgs, execTranResult } = paymentMethodByTransaction;
+                // pendingPaymentAgencyTransaction = { entryTranArgs, entryTranResult, execTranArgs, execTranResult };
+            }
+            if (creditCard === undefined) {
+                throw new factory.errors.Argument('paymentMethodId', 'creditCard not found');
+            }
+            if (pendingPaymentAgencyTransaction === undefined) {
+                throw new factory.errors.Argument('paymentMethodId', 'pendingPaymentAgencyTransaction not found');
+            }
+            // 既に承認済であれば何もしない(2023-05-15~)
+            const existingCompletedAuthorizeActions = yield repos.action.searchByPurpose({
+                typeOf: factory.actionType.AuthorizeAction,
+                purpose: { id: params.transaction.id, typeOf: params.transaction.typeOf },
+                actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus },
+                object: {
+                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
+                    typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+                },
+                sort: { startDate: factory.sortType.Ascending }
+            });
+            existingCompletedAuthorizeAction = existingCompletedAuthorizeActions.shift();
+            if (existingCompletedAuthorizeAction !== undefined) {
+                return { existingCompletedAuthorizeAction: { id: existingCompletedAuthorizeAction.id } };
+            }
+            return {
+                authorizeParams: { creditCard, pendingPaymentAgencyTransaction, paymentMethodByTransaction }
+            };
+        }
+        else {
+            // 取引にないpaymentMethodIdの指定はクライアントエラー
+            throw new factory.errors.Argument('paymentMethodId', 'invalid paymentMethodId for the transaction');
+        }
+    });
+}
+exports.handlePrePublishedPaymentMethodIdOnAuthorizing = handlePrePublishedPaymentMethodIdOnAuthorizing;
+/**
+ * 注文取引に保管された決済情報を承認しようとしている決済の整合性を検証する
+ */
+function validatePaymentMethodByTransaction(params) {
+    var _a, _b;
+    const paymentServiceIdByObject = params.object.issuedThrough.id;
+    const amountByObject = params.object.amount;
+    const paymentMethodTypeByObject = params.object.paymentMethod;
+    // const paymentServiceIdByTransaction = params.paymentMethodByTransaction.issuedThrough.id;
+    // const amountByTransaction = params.paymentMethodByTransaction.paymentMethod?.amount;
+    // const paymentMethodTypeByTransaction = params.paymentMethodByTransaction.paymentMethod?.identifier;
+    const paymentServiceIdByTransaction = params.acceptObject.object.id;
+    const amountByTransaction = (_a = params.acceptObject.object.paymentMethod) === null || _a === void 0 ? void 0 : _a.amount;
+    const paymentMethodTypeByTransaction = (_b = params.acceptObject.object.paymentMethod) === null || _b === void 0 ? void 0 : _b.identifier;
+    // 決済サービスID検証
+    if (paymentServiceIdByObject !== paymentServiceIdByTransaction) {
+        throw new factory.errors.Argument('object.issuedThrough.id', 'issuedThrough.id must match the target of the paymentUrl');
+    }
+    // 金額検証
+    if (amountByObject !== amountByTransaction) {
+        throw new factory.errors.Argument('object.amount', 'amount must match the target of the paymentUrl');
+    }
+    // 決済方法区分検証
+    if (paymentMethodTypeByObject !== paymentMethodTypeByTransaction) {
+        throw new factory.errors.Argument('object.paymentMethod', 'paymentMethod must match the target of the paymentUrl');
+    }
+}

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

@@ -24,7 +24,11 @@ import { person2username } from './any/person2username';
  * 決済承認中止
  * タスクから決済承認を取り消す
  */
-declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction>): (repos: {
+declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    sameAs?: {
+        id: string;
+    };
+}): (repos: {
     accountingReport: AccountingReportRepo;
     action: ActionRepo;
     assetTransaction: AssetTransactionRepo;
@@ -34,7 +38,11 @@ declare function voidPayTransaction(params: factory.task.IData<factory.taskName.
     task: TaskRepo;
     transaction: TransactionRepo;
 }) => Promise<void>;
-declare function invalidatePaymentUrl(params: factory.task.IData<factory.taskName.VoidPayTransaction>): (repos: {
+declare function invalidatePaymentUrl(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    sameAs?: {
+        id: string;
+    };
+}): (repos: {
     accountingReport: AccountingReportRepo;
     action: ActionRepo;
     assetTransaction: AssetTransactionRepo;