@chevre/domain 24.0.0-alpha.5 → 24.0.0-alpha.52

package/lib/chevre/service/assetTransaction/cancelReservation/factory.js

@@ -119,23 +119,7 @@ function createPotentialActions(params) {
             transaction.object.reservations.map((reservation) => {
                 // 最適化(2022-06-06~)
                 let cancelObject;
-                if (reservation.typeOf === factory.reservationType.BusReservation) {
-                    cancelObject = {
-                        typeOf: reservation.typeOf,
-                        id: reservation.id,
-                        issuedThrough: {
-                            typeOf: reservation.issuedThrough?.typeOf
-                        },
-                        reservationFor: {
-                            typeOf: reservation.reservationFor.typeOf,
-                            id: String(reservation.reservationFor.id)
-                        },
-                        reservationNumber: reservation.reservationNumber,
-                        // ReservationConfirmed->ReservationCancelledのみ処理されるように保証する
-                        reservationStatus: factory.reservationStatusType.ReservationConfirmed
-                    };
-                }
-                else if (reservation.typeOf === factory.reservationType.EventReservation) {
+                if (reservation.typeOf === factory.reservationType.EventReservation) {
                     cancelObject = {
                         typeOf: reservation.typeOf,
                         id: reservation.id,

package/lib/chevre/service/assetTransaction/cancelReservation/start.d.ts

@@ -18,8 +18,8 @@ export declare function validateStartParams(params: IStartParams): (repos: {
     assetTransaction: AssetTransactionRepo;
 }) => Promise<{
     reserveTransaction: import("@chevre/factory/lib/assetTransaction/reserve").ITransaction | undefined;
-    reservations: (Pick<import("@chevre/factory/lib/reservation/event").IReservation, "id" | "typeOf" | "issuedThrough" | "reservationNumber"> & {
-        reservationFor: Pick<factory.reservation.IReservationFor<factory.reservationType.EventReservation>, "id" | "typeOf">;
+    reservations: (Pick<import("@chevre/factory/lib/reservation/event").IReservation, "id" | "typeOf" | "reservationNumber" | "issuedThrough"> & {
+        reservationFor: Pick<factory.reservation.eventReservation.IReservationFor, "id" | "typeOf">;
     })[] | undefined;
 }>;
 /**

package/lib/chevre/service/assetTransaction/cancelReservation/start.js

@@ -63,7 +63,7 @@ function validateStartParams(params) {
         if (reserveTransaction === undefined) {
             // 予約存在確認
             if (typeof params.object.reservation?.id === 'string') {
-                const reservation = await repos.reservation.projectFieldsById({
+                const reservation = await repos.reservation.findReservationById({
                     id: params.object.reservation.id,
                     inclusion: [
                         'issuedThrough', 'typeOf', 'reservationNumber', 'reservationFor.id', 'reservationFor.typeOf', 'provider', 'reservationStatus'

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

@@ -61,8 +61,8 @@ function start(params) {
             throw new factory.errors.NotFound('Product');
         }
         // fromとtoをfix
-        const { fromLocation } = await fixFromLocation(params, product)(repos);
-        const { toLocation } = await fixToLocation(params, product)(repos);
+        const { fromLocation } = await fixFromLocation(params, product)({});
+        const { toLocation } = await fixToLocation(params, product)({});
         const amount = fixMonetaryAmount(params, product);
         // 自動発行廃止(2022-05-17~)
         const transactionNumber = params.transactionNumber;
@@ -202,7 +202,7 @@ function fixFromLocation(params, product) {
         const transactionType = params.object.pendingTransaction?.typeOf;
         switch (transactionType) {
             case factory.account.transactionType.Withdraw:
-            case factory.account.transactionType.Transfer:
+            case factory.account.transactionType.Transfer: {
                 const fromLocationObject = fromLocation;
                 // Permitの存在しない注文口座に対応する
                 const hasNoPermit = fromLocationObject.hasNoPermit === true;
@@ -237,6 +237,7 @@ function fixFromLocation(params, product) {
                     issuedThrough: { id: fromLocationObject.issuedThrough?.id }
                 };
                 break;
+            }
             default:
             // no op
         }
@@ -264,7 +265,7 @@ function fixToLocation(params, product) {
         const transactionType = params.object.pendingTransaction?.typeOf;
         switch (transactionType) {
             case factory.account.transactionType.Deposit:
-            case factory.account.transactionType.Transfer:
+            case factory.account.transactionType.Transfer: {
                 const toLocationObject = toLocation;
                 // Permitの存在しない注文口座に対応する
                 const hasNoPermit = toLocationObject.hasNoPermit === true;
@@ -299,6 +300,7 @@ function fixToLocation(params, product) {
                     issuedThrough: { id: toLocationObject.issuedThrough?.id }
                 };
                 break;
+            }
             default:
             // no op
         }
@@ -408,7 +410,7 @@ function exportTasksById(params) {
                 }
                 break;
             case factory.transactionStatusType.Canceled:
-            case factory.transactionStatusType.Expired:
+            case factory.transactionStatusType.Expired: {
                 const cancelMoneyTransferTaskAttributes = {
                     project: { typeOf: transaction.project.typeOf, id: transaction.project.id },
                     name: factory.taskName.CancelMoneyTransfer,
@@ -423,6 +425,7 @@ function exportTasksById(params) {
                 };
                 taskAttributes.push(cancelMoneyTransferTaskAttributes);
                 break;
+            }
             default:
                 throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
         }

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

@@ -1,20 +1,21 @@
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
-import type { ActionRepo } from '../../../repo/action';
+import type { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
 import type { CredentialsRepo } from '../../../repo/credentials';
 import type { EventRepo } from '../../../repo/event';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
 import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
 import * as MovieTicketPayment from '../../payment/movieTicket';
-export type ICheckOperation<T> = (repos: {
-    action: ActionRepo;
+export interface ICheckRepos {
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
+}
+export type ICheckOperation<T> = (repos: ICheckRepos, settings: Settings) => Promise<T>;
 /**
  * 決済方法認証
  */

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

@@ -20,5 +20,5 @@ export type IConfirmOperation<T> = (repos: IConfirmRepos) => Promise<T>;
  * 取引確定
  */
 export declare function confirm(params: factory.assetTransaction.pay.IConfirmParams & {
-    options: {};
+    options: Record<string, never>;
 }): IConfirmOperation<void>;

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

@@ -94,7 +94,7 @@ function exportTasksById(params) {
             data: onAssetTransactionStatusChangedTaskData
         };
         switch (transaction.status) {
-            case factory.transactionStatusType.Confirmed:
+            case factory.transactionStatusType.Confirmed: {
                 const payActions = potentialActions?.pay;
                 if (Array.isArray(payActions) && payActions.length > 0) {
                     const payTasks = payActions.map(({ object, purpose }) => {
@@ -113,6 +113,7 @@ function exportTasksById(params) {
                     taskAttributes.push(...payTasks);
                 }
                 break;
+            }
             case factory.transactionStatusType.Canceled:
                 taskAttributes.push(voidPaymentTasks, onAssetTransactionStatusChangedTask);
                 break;

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

@@ -1,22 +1,27 @@
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
 import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
-import type { ActionRepo } from '../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
 import type { EventRepo } from '../../../repo/event';
 import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { IssuerRepo } from '../../../repo/issuer';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
 import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
 import * as CreditCardPayment from '../../payment/creditCard';
-export type IPublishPaymentUrlOperation<T> = (repos: {
+export interface IPublishPaymentUrlRepos {
     acceptedPaymentMethod: AcceptedPaymentMethodRepo;
-    action: ActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
     event: EventRepo;
     eventSeries: EventSeriesRepo;
+    issuer: IssuerRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;
-}, settings: Settings) => Promise<T>;
+}
+export type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos, settings: Settings) => Promise<T>;
 export type IPublishPaymentUrlResult = CreditCardPayment.IPaymentAgencyTransaction & {
     paymentMethodId: string;
     paymentUrl: string;

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

@@ -102,12 +102,12 @@ function publishPaymentUrl(params, options) {
                 : undefined,
             ...(typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined
         };
-        const action = await repos.action.start(actionAttributes);
+        const action = await repos.acceptPayAction.start(actionAttributes);
         let result;
         let recipe;
         try {
             switch (paymentServiceType) {
-                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                case factory.service.paymentService.PaymentServiceType.CreditCard: {
                     const authorizeResult = await CreditCardPayment.authorize({
                         ...params,
                         id: '' // 決済URL発行プロセスにおいては決済取引IDは使用しないので空文字でok
@@ -141,13 +141,14 @@ function publishPaymentUrl(params, options) {
                         result
                     });
                     break;
+                }
                 default:
                     throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
             }
         }
         catch (error) {
             try {
-                await repos.action.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
+                await repos.acceptPayAction.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
             }
             catch (__) {
                 // 失敗したら仕方ない
@@ -158,7 +159,7 @@ function publishPaymentUrl(params, options) {
             paymentMethodId: result.paymentMethodId,
             paymentUrl: result.paymentUrl
         };
-        await repos.action.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
+        await repos.acceptPayAction.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
         return result;
     };
 }

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

@@ -83,7 +83,7 @@ function createStartParams(params, options) {
             };
             accountId = ''; // 強制的に空文字化(2024-06-14~)
             break;
-        case factory.service.paymentService.PaymentServiceType.MovieTicket:
+        case factory.service.paymentService.PaymentServiceType.MovieTicket: {
             const specifiedMovieTickets = params.object.paymentMethod?.movieTickets;
             totalPaymentDue = {
                 typeOf: 'MonetaryAmount',
@@ -103,6 +103,7 @@ function createStartParams(params, options) {
                 ? specifiedMovieTickets[0].identifier // 決済カードidentifierは1つのみ許可の前提
                 : '';
             break;
+        }
         default:
         // no op
     }

package/lib/chevre/service/assetTransaction/pay/start/preStart/validateAcceptedPaymentMethodIfNeeded.d.ts

@@ -2,20 +2,17 @@ import * as factory from '../../../../../factory';
 import type { AcceptedPaymentMethodRepo } from '../../../../../repo/acceptedPaymentMethod';
 import type { EventRepo } from '../../../../../repo/event';
 import type { EventSeriesRepo } from '../../../../../repo/eventSeries';
+import type { IssuerRepo } from '../../../../../repo/issuer';
+import type { PaymentServiceRepo } from '../../../../../repo/paymentService';
 /**
  * 必要あらば関連リソースの対応決済方法を検証する
  */
 export declare function validateAcceptedPaymentMethodIfNeeded(params: Pick<factory.assetTransaction.pay.IStartParamsWithoutDetail, 'object'> & {
     instrument: factory.action.trade.pay.IPlaceOrderRelatedInstrument[];
-} | {
-    object: factory.action.accept.pay.IPayObject & {
-        paymentMethod: factory.action.accept.pay.IPaymentMethod & {
-            movieTickets: never;
-        };
-    };
-    instrument: factory.action.accept.pay.IInstrument[];
 }): (repos: {
     acceptedPaymentMethod: AcceptedPaymentMethodRepo;
     event: EventRepo;
     eventSeries: EventSeriesRepo;
+    issuer: IssuerRepo;
+    paymentService: PaymentServiceRepo;
 }) => Promise<void>;

package/lib/chevre/service/assetTransaction/pay/start/preStart/validateAcceptedPaymentMethodIfNeeded.js

@@ -28,18 +28,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAcceptedPaymentMethodIfNeeded = validateAcceptedPaymentMethodIfNeeded;
 const debug_1 = __importDefault(require("debug"));
+// import * as jwt from 'jsonwebtoken';
 const factory = __importStar(require("../../../../../factory"));
 const debug = (0, debug_1.default)('chevre-domain:service:assetTransaction:pay');
 /**
  * 必要あらば関連リソースの対応決済方法を検証する
  */
-function validateAcceptedPaymentMethodIfNeeded(params) {
+function validateAcceptedPaymentMethodIfNeeded(params
+// | {
+//     object: factory.action.accept.pay.IPayObject & {
+//         paymentMethod: factory.action.accept.pay.IPaymentMethod & {
+//             movieTickets: never;
+//         };
+//     };
+//     instrument: factory.action.accept.pay.IInstrument[];
+// }
+) {
     return async (repos) => {
         const now = new Date();
         /**
          * 検証対象のイベントIDリスト
          */
         let checkingEventIds;
+        let paymentService;
         const paymentServiceType = params.object.typeOf;
         const paymentServiceId = params.object.id;
         // CreditCard or MovieTicket?
@@ -49,6 +60,16 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
             if (Array.isArray(orderedItems)) {
                 checkingEventIds = orderedItems.map((orderedItem) => orderedItem.orderedItem.serviceOutput.reservationFor.id);
             }
+            paymentService = (await repos.paymentService.projectFields({
+                limit: 1,
+                page: 1,
+                // project: { id: { $eq: params.project.id } },
+                typeOf: { $eq: paymentServiceType },
+                id: { $eq: paymentServiceId }
+            }, ['availableChannel', 'serviceType'])).shift();
+            if (paymentService === undefined) {
+                throw new factory.errors.NotFound(factory.service.paymentService.PaymentServiceType.CreditCard);
+            }
         }
         else if (paymentServiceType === factory.service.paymentService.PaymentServiceType.MovieTicket) {
             const movieTickets = params.object.paymentMethod.movieTickets;
@@ -59,12 +80,22 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
                     throw new factory.errors.Argument('movieTickets', 'Number of events must be 1');
                 }
             }
+            paymentService = (await repos.paymentService.projectFields({
+                limit: 1,
+                page: 1,
+                // project: { id: { $eq: params.project.id } },
+                typeOf: { $eq: paymentServiceType },
+                id: { $eq: paymentServiceId }
+            }, ['availableChannel', 'serviceType'])).shift();
+            if (paymentService === undefined) {
+                throw new factory.errors.NotFound(factory.service.paymentService.PaymentServiceType.MovieTicket);
+            }
         }
         else {
             // 対面決済ではひとまず対応決済方法検証なし
         }
         debug('validateAcceptedPaymentMethodIfNeeded: checkingEventIds:', checkingEventIds, paymentServiceType);
-        if (Array.isArray(checkingEventIds)) {
+        if (Array.isArray(checkingEventIds) && paymentService !== undefined) {
             // 検証対象のイベントIDが存在する場合、その数が0ということはありえない
             if (checkingEventIds.length === 0) {
                 throw new factory.errors.ArgumentNull('object.serviceOutput.referencesOrder.orderedItem');
@@ -81,47 +112,235 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
             }
             const uniqueEventSeriesIds = [...new Set(eventSeriesIds)];
             debug('validateAcceptedPaymentMethodIfNeeded: eventSeries with AggregateOffer?', uniqueEventSeriesIds);
-            for (const eventSeriesId of uniqueEventSeriesIds) {
-                const eventSeries = (await repos.eventSeries.projectEventSeriesFields({
-                    limit: 1,
-                    page: 1,
-                    id: { $eq: eventSeriesId }
-                }, ['offers'])).shift();
-                if (eventSeries === undefined) {
-                    throw new factory.errors.NotFound(factory.eventType.ScreeningEventSeries);
-                }
-                if (eventSeries.offers?.typeOf === factory.offerType.AggregateOffer) {
-                    // 対応決済方法オファーIDの指定が必要
-                    const acceptedPaymentMethodOfferIds = [];
-                    params.instrument.forEach((instrument) => {
-                        if (instrument.typeOf === factory.offerType.Offer) {
-                            acceptedPaymentMethodOfferIds.push(instrument.id);
-                        }
-                    });
-                    if (acceptedPaymentMethodOfferIds.length === 0) {
-                        throw new factory.errors.ArgumentNull('acceptedPaymentMethodOfferIds');
-                    }
-                    // 全施設コンテンツについて有効な対応決済方法オファーの存在を検証
-                    const validAcceptedPaymentMethodOffer = (await repos.acceptedPaymentMethod.findAcceptedPaymentMethods({
-                        limit: 1,
-                        page: 1,
-                        id: { $in: acceptedPaymentMethodOfferIds }, // 指定されたIDで
-                        itemOffered: { id: { $eq: eventSeriesId } }, // リソースに対して
-                        acceptedPaymentMethod: { id: { $eq: paymentServiceId } }, // 決済方法を許可
-                        validFrom: { $lte: now }, // 現在有効
-                        validThrough: { $gte: now } // 現在有効
-                    }, ['identifier'])).shift();
-                    if (validAcceptedPaymentMethodOffer === undefined) {
-                        throw new factory.errors.NotFound(factory.offerType.Offer, `payment not accepted. eventSeriesId: ${eventSeriesId}`);
-                    }
-                }
-                else {
-                    // 集約オファーでなければ検証の必要なし
-                }
+            // 決済方法に設定されたカスタム検証URLに依存する場合はこちら↓
+            const customValidationUrl = paymentService.availableChannel?.customValidationUrl;
+            if (typeof customValidationUrl === 'string' && customValidationUrl !== '') {
+                await validateByCustomUrl({
+                    customValidationUrl,
+                    eventSeriesIds: uniqueEventSeriesIds,
+                    paymentMethodType: paymentService.serviceType.codeValue,
+                    // amount: number,
+                    now
+                });
             }
+            // トークンで検証する場合はこち↓
+            // // 指定された全トークンを抽出
+            // const acceptedPaymentMethodOfferTokens: string[] = [];
+            // params.instrument.forEach((instrument) => {
+            //     if (instrument.typeOf === factory.offerType.Offer) {
+            //         acceptedPaymentMethodOfferTokens.push(instrument.id);
+            //     }
+            // });
+            // await validateAllItemTokens(
+            //     paymentServiceId,
+            //     uniqueEventSeriesIds,
+            //     acceptedPaymentMethodOfferTokens,
+            //     now
+            // )(repos);
         }
         else {
             // 関連注文の指定がなければ検証の必要なし
         }
     };
 }
+const TIMEOUT = 2000;
+// interface ICustomValidationResponse {
+//     isAllowed: boolean;
+// };
+async function validateByCustomUrl(params) {
+    try {
+        // 判定エンジンへのリクエスト
+        const validationRequest = {
+            eventSeriesIds: params.eventSeriesIds,
+            paymentMethodType: params.paymentMethodType,
+            // amount: params.amount
+        };
+        const res = await fetch(params.customValidationUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(validationRequest),
+            // body data type must match "Content-Type" header
+            signal: AbortSignal.timeout(TIMEOUT)
+        });
+        if (!res.ok) {
+            throw new factory.errors.Argument('paymentMethod', `paymentMethod denied by the customValidation. statusCode: ${res.status}`);
+        }
+    }
+    catch (error) {
+        // ネットワークエラーやタイムアウト時のハンドリング
+        // サービス継続を優先するか、安全側に倒してエラーにするかはポリシー次第
+        debug('Custom validation failed:', error.message);
+        throw error;
+    }
+}
+// /**
+//  * トークンのペイロード構造
+//  */
+// interface IPaymentOfferPayload extends Pick<factory.acceptedPaymentMethodOffer.IAcceptedPaymentMethodOffer, 'acceptedPaymentMethod' | 'itemOffered' | 'validFrom' | 'validThrough'> {
+//     iss: string;
+//     // sub: string; // 商品ID
+//     // paymentOffer: {
+//     //     allowedMethods: string[];
+//     //     limitAmount: number;
+//     //     currency: string;
+//     // };
+// }
+// async function verifyOfferToken(params: {
+//     token: string;
+//     secret: string;
+//     issuer?: string;
+// }): Promise<IPaymentOfferPayload> {
+//     let result: IPaymentOfferPayload;
+//     const { issuer, secret, token } = params;
+//     try {
+//         result = await new Promise<IPaymentOfferPayload>((resolve, reject) => {
+//             jwt.verify(
+//                 token,
+//                 secret,
+//                 {
+//                     algorithms: ['HS256'],
+//                     issuer
+//                     // ...(Array.isArray(params.audience)) ? { audience: params.audience } : undefined
+//                 },
+//                 (err, decoded: any) => {
+//                     if (err instanceof Error) {
+//                         reject(err);
+//                     } else {
+//                         resolve(decoded);
+//                     }
+//                 });
+//         });
+//     } catch (error) {
+//         // JWTエラーをハンドリング
+//         if (error instanceof jwt.TokenExpiredError) {
+//             throw new factory.errors.Argument('token', `invalid token. [${error.message} expiredAt:${error.expiredAt}]`);
+//         } else if (error instanceof jwt.JsonWebTokenError) {
+//             throw new factory.errors.Argument('token', `invalid token. [${error.message}]`);
+//         }
+//         throw error;
+//     }
+//     return result;
+// }
+// /**
+//  * 複数アイテムのトークン検証メイン関数
+//  */
+// function validateAllItemTokens(
+//     selectedMethodId: string,   // ユーザーが選択した決済方法ID
+//     eventSeriesIds: string[],   // DBから取得した注文商品リスト
+//     providedTokens: string[],    // クライアントから送られたJWT配列
+//     now: Date
+// ) {
+//     return async (repos: {
+//         eventSeries: EventSeriesRepo;
+//         issuer: IssuerRepo;
+//     }) => {
+//         // 1. トークンをデコードして、商品ID（sub）をキーにしたマップを作成
+//         // ※ここでは署名検証前なので、decodeのみ行う
+//         const tokenMap = new Map<string, string>();
+//         providedTokens.forEach(t => {
+//             try {
+//                 const decoded = jwt.decode(t) as IPaymentOfferPayload;
+//                 if (decoded && typeof decoded.itemOffered?.id === 'string') {
+//                     tokenMap.set(decoded.itemOffered.id, t);
+//                 }
+//             } catch {
+//                 // no op
+//             }
+//         });
+//         // 2. 全アイテムについてループを回して検証
+//         for (const eventSeriesId of eventSeriesIds) {
+//             const eventSeries = (await repos.eventSeries.projectEventSeriesFields(
+//                 {
+//                     limit: 1,
+//                     page: 1,
+//                     id: { $eq: eventSeriesId }
+//                 },
+//                 ['offers', 'project']
+//             )).shift();
+//             if (eventSeries === undefined) {
+//                 throw new factory.errors.NotFound(factory.eventType.ScreeningEventSeries);
+//             }
+//             if (eventSeries.offers?.typeOf === factory.offerType.AggregateOffer) {
+//                 // // 対応決済方法オファーIDの指定が必要
+//                 // const acceptedPaymentMethodOfferTokens: string[] = [];
+//                 // // const acceptedPaymentMethodOfferIds: string[] = [];
+//                 // params.instrument.forEach((instrument) => {
+//                 //     if (instrument.typeOf === factory.offerType.Offer) {
+//                 //         acceptedPaymentMethodOfferTokens.push(instrument.id);
+//                 //         // acceptedPaymentMethodOfferIds.push(instrument.id);
+//                 //     }
+//                 // });
+//                 // if (acceptedPaymentMethodOfferTokens.length === 0) {
+//                 //     throw new factory.errors.ArgumentNull('acceptedPaymentMethodOfferTokens');
+//                 // }
+//                 // // if (acceptedPaymentMethodOfferIds.length === 0) {
+//                 // //     throw new factory.errors.ArgumentNull('acceptedPaymentMethodOfferIds');
+//                 // // }
+//                 const token = tokenMap.get(eventSeriesId);
+//                 if (!token) {
+//                     // throw new Error(`商品[${eventSeriesId}]の決済許可トークンが不足しています。`);
+//                     throw new factory.errors.ArgumentNull(
+//                         factory.offerType.Offer,
+//                         `token required. eventSeriesId: ${eventSeriesId}`
+//                     );
+//                 }
+//                 console.log('check token...:', token);
+//                 // 3. 既存の「発行者管理」から公開鍵を取得
+//                 const issuerCode = 'DefaultTokenIssuer';
+//                 const issuer = await repos.issuer.findByIdentifier({
+//                     project: { id: eventSeries.project.id },
+//                     identifier: issuerCode
+//                 });
+//                 if (typeof issuer.tokenSecret !== 'string' || issuer.tokenSecret === '') {
+//                     throw new factory.errors.NotFound('issuer.tokenSecret');
+//                 }
+//                 const verifiedOffer = await verifyOfferToken({
+//                     secret: issuer.tokenSecret,
+//                     issuer: issuer.url,
+//                     token
+//                 });
+//                 // 5. ビジネスルールの厳密な検証
+//                 // (a) トークン内の商品IDが、現在のアイテムと一致するか（すり替え防止）
+//                 if (verifiedOffer.itemOffered.id !== eventSeriesId) {
+//                     throw new factory.errors.Argument('token', `invalid token. [itemOffered.id not matched]`);
+//                 }
+//                 // (b) 選択された決済方法が、この商品の許可リストに含まれているか
+//                 if (verifiedOffer.acceptedPaymentMethod.id !== selectedMethodId) {
+//                     throw new factory.errors.NotFound(
+//                         factory.offerType.Offer,
+//                         `payment not accepted. eventSeriesId: ${eventSeriesId}`
+//                     );
+//                 }
+//                 // // (c) 金額の検証（判定時より金額が上がっていないか）
+//                 // if (item.amount > payload.paymentOffer.limitAmount) {
+//                 //     throw new Error(`商品[${item.productId}]の金額が承認された上限を超えています。`);
+//                 // }
+//                 // 現在有効検証
+//                 console.log('check validFrom?:', now);
+//                 // // 全施設コンテンツについて有効な対応決済方法オファーの存在を検証
+//                 // const validAcceptedPaymentMethodOffer = (await repos.acceptedPaymentMethod.findAcceptedPaymentMethods(
+//                 //     {
+//                 //         limit: 1,
+//                 //         page: 1,
+//                 //         id: { $in: acceptedPaymentMethodOfferIds }, // 指定されたIDで
+//                 //         itemOffered: { id: { $eq: eventSeriesId } }, // リソースに対して
+//                 //         acceptedPaymentMethod: { id: { $eq: paymentServiceId } }, // 決済方法を許可
+//                 //         validFrom: { $lte: now }, // 現在有効
+//                 //         validThrough: { $gte: now } // 現在有効
+//                 //     },
+//                 //     ['identifier']
+//                 // )).shift();
+//                 // if (validAcceptedPaymentMethodOffer === undefined) {
+//                 //     throw new factory.errors.NotFound(
+//                 //         factory.offerType.Offer,
+//                 //         `payment not accepted. eventSeriesId: ${eventSeriesId}`
+//                 //     );
+//                 // }
+//             } else {
+//                 // 集約オファーでなければ検証の必要なし
+//             }
+//         }
+//         // 全てのアイテムで検証が通れば true
+//         return true;
+//     }
+// }

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

@@ -1,7 +1,10 @@
 import * as factory from '../../../../factory';
 import { Settings } from '../../../../settings';
 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 { CheckMovieTicketActionRepo } from '../../../../repo/action/checkMovieTicket';
+import type { AuthorizeInvoiceActionRepo } from '../../../../repo/action/authorizeInvoice';
 import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { CredentialsRepo } from '../../../../repo/credentials';
 import type { EventRepo } from '../../../../repo/event';
@@ -13,7 +16,13 @@ import type { TaskRepo } from '../../../../repo/task';
 import { IPaymentAgencyTransaction } from '../../../payment/creditCard';
 export interface IProcessAuthorizeOperationRepos {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;