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

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,6 +80,16 @@ 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 {
             // 対面決済ではひとまず対応決済方法検証なし
@@ -81,47 +112,237 @@ 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);
-                        }
+            // 決済方法に設定されたカスタム検証URLに依存する場合はこちら↓
+            if (paymentService !== undefined) {
+                const customValidationUrl = paymentService.availableChannel?.customValidationUrl;
+                if (typeof customValidationUrl === 'string' && customValidationUrl !== '') {
+                    await validateByCustomUrl({
+                        customValidationUrl,
+                        eventSeriesIds: uniqueEventSeriesIds,
+                        paymentMethodType: paymentService.serviceType.codeValue,
+                        // amount: number,
+                        now
                     });
-                    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 {
-                    // 集約オファーでなければ検証の必要なし
                 }
             }
+            // トークンで検証する場合はこち↓
+            // // 指定された全トークンを抽出
+            // 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;

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

@@ -1,6 +1,6 @@
 import * as factory from '../../../../factory';
 import { Settings } from '../../../../settings';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AuthorizeInvoiceActionRepo } from '../../../../repo/action/authorizeInvoice';
 import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../../repo/paymentServiceProvider';
@@ -21,7 +21,7 @@ export declare function processAuthorizeCreditCard(params: factory.assetTransact
         id?: string;
     };
 }): (repos: {
-    action: ActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;

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

@@ -1,7 +1,9 @@
 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 { AssetTransactionRepo } from '../../../../repo/assetTransaction';
 import type { CredentialsRepo } from '../../../../repo/credentials';
 import type { EventRepo } from '../../../../repo/event';
@@ -31,7 +33,12 @@ export declare function processAuthorizeMovieTicket(params: factory.assetTransac
     };
 }): (repos: {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;

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

@@ -1,12 +1,15 @@
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
-import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
 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';
 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 { PotentialActionRepo } from '../../../repo/potentialAction';
@@ -15,11 +18,17 @@ import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccep
 import type { TaskRepo } from '../../../repo/task';
 import { IPaymentAgencyTransaction } from '../../payment/creditCard';
 export interface IStartOperationRepos {
-    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
     credentials: CredentialsRepo;
     event: EventRepo;
+    issuer: IssuerRepo;
     eventSeries: EventSeriesRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;

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

@@ -1,12 +1,15 @@
 import * as factory from '../../factory';
-import type { ActionRepo } from '../../repo/action';
+import type { PayActionRepo } from '../../repo/action/pay';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../repo/paymentService';
 import type { PotentialActionRepo } from '../../repo/potentialAction';
 import type { ProductRepo } from '../../repo/product';
 import type { TaskRepo } from '../../repo/task';
 export interface IStartOperationRepos {
-    action: ActionRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+    };
     paymentService: PaymentServiceRepo;
     potentialAction: PotentialActionRepo;
     product: ProductRepo;

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

@@ -54,7 +54,7 @@ function start(params) {
         });
         const paymentServiceType = payTransaction.object.typeOf;
         // PayActionを確認する
-        const payAction = await repos.action.findPayAction({ project: { id: params.project.id }, paymentMethodId });
+        const payAction = await repos.actions.pay.findPayActionByPaymentMethodId({ project: { id: params.project.id }, paymentMethodId });
         if (payAction === undefined) {
             throw new factory.errors.NotFound(factory.actionType.PayAction);
         }

package/lib/chevre/service/assetTransaction/reserve/confirm/factory.d.ts

@@ -3,6 +3,6 @@ declare function createPotentialActions(params: {
     order?: Pick<factory.order.IOrder, 'orderNumber' | 'customer' | 'typeOf'>;
 }): {
     potentialActions: factory.assetTransaction.reserve.IPotentialActions;
-    underName?: factory.reservation.IUnderName<factory.reservationType.EventReservation>;
+    underName?: factory.assetTransaction.reserve.IUnderName;
 };
 export { createPotentialActions };

package/lib/chevre/service/assetTransaction/reserve/start/createSubReservations.js

@@ -421,7 +421,7 @@ function validateProgramMembershipUsed(params) {
                 throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', `invalid issuedThrough.typeOf: ${issuedThroughTypeOf}`);
             }
             switch (permitIssuedThrough.typeOf) {
-                case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                case factory.service.paymentService.PaymentServiceType.FaceToFace: {
                     // 適用メンバーシップ条件有のオファーであれば、問答無用に受け入れる
                     const eligibleMembershipType = params.availableOffer.eligibleMembershipType?.[0]?.codeValue;
                     if (typeof eligibleMembershipType === 'string') {
@@ -435,8 +435,9 @@ function validateProgramMembershipUsed(params) {
                         };
                     }
                     break;
+                }
                 // 発行サービスがCreditCardのケースに対応(2023-09-01~)
-                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                case factory.service.paymentService.PaymentServiceType.CreditCard: {
                     // 決済サービスのserviceOutputにPermitが存在すれば、設定されたメンバーシップ区分のPermitをprogramMembershipUsedとして適用する
                     let issuedThroughServiceType;
                     if (Array.isArray(permitIssuedThrough.serviceOutput)) {
@@ -460,7 +461,8 @@ function validateProgramMembershipUsed(params) {
                         throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', 'issuedThrough has no serviceOutput as Permit');
                     }
                     break;
-                case factory.product.ProductType.MembershipService:
+                }
+                case factory.product.ProductType.MembershipService: {
                     // requestedProgramMembershipUsedの発行サービスIDから外部連携設定を取得する
                     const permitService = await createPermitService({ issuedThrough: { id: permitIssuedThrough.id } })(repos);
                     // メンバーシップの存在確認
@@ -492,6 +494,7 @@ function validateProgramMembershipUsed(params) {
                         };
                     }
                     break;
+                }
                 default:
                     throw new factory.errors.Argument('acceptedOffer.itemOffered.serviceOutput.programMembershipUsed', `${permitIssuedThrough.typeOf} not implemented`);
             }

package/lib/chevre/service/assetTransaction/reserve/start/factory/createReservation.d.ts

@@ -2,10 +2,7 @@ import * as factory from '../../../../../factory';
 import { IMinimizedIndividualEvent } from '../../../../../factory/event';
 import { IAcceptedAddOn } from './price';
 type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
-/**
- * 確定時予約のITicket
- */
-type IReservedTicket = Pick<factory.reservation.ITicket, 'identifier' | 'issuedBy' | 'ticketType' | 'ticketedSeat' | 'typeOf'>;
+type IReservedTicket = Pick<factory.assetTransaction.reserve.ISubReservationReservedTicket, 'identifier' | 'issuedBy' | 'ticketType' | 'ticketedSeat' | 'typeOf'>;
 declare function createReservedTicket(params: {
     id: string;
     acceptedOffer: factory.assetTransaction.reserve.IAcceptedTicketOfferWithoutDetail;
@@ -43,14 +40,14 @@ declare function createReservation(params: {
     };
     id: string;
     reservationFor: IMinimizedIndividualEvent;
-    reservedTicket: IReservedTicket;
+    reservedTicket: factory.assetTransaction.reserve.ISubReservationReservedTicket;
     additionalProperty?: factory.propertyValue.IPropertyValue<string>[];
     additionalTicketText?: string;
     ticketOffer: factory.product.ITicketOffer;
     seatPriceComponent: factory.place.seat.IPriceComponent[];
     acceptedAddOns: IAcceptedAddOn[];
-    subReservation?: factory.reservation.ISubReservation<factory.reservationType.EventReservation>[];
-    programMembershipUsed?: factory.reservation.IProgramMembershipUsed<factory.reservationType.EventReservation>;
+    subReservation?: factory.reservation.eventReservation.ISubReservation[];
+    programMembershipUsed?: factory.reservation.IProgramMembershipUsed;
     availableOffer: factory.unitPriceOffer.IUnitPriceOffer;
     appliesToMovieTicket?: factory.assetTransaction.reserve.IAcceptedAppliesToMovieTicket;
     validateAppliesToMovieTicket: boolean;

package/lib/chevre/service/assetTransaction/reserve/start/factory/createReservation.js

@@ -393,46 +393,6 @@ function createReservation(params) {
         };
     }
     else {
-        return {
-            // project: params.project,
-            typeOf: factory.reservationType.BusReservation,
-            id: params.id,
-            // reservationPackage保管に移行(2023-06-06~)
-            // issuedThrough,
-            additionalProperty: params.additionalProperty,
-            // bookingTime: params.reserveDate,
-            // modifiedTime: params.reserveDate,
-            numSeats: 1,
-            price: price4reservation,
-            priceCurrency: factory.priceCurrency.JPY,
-            // reservationNumber: params.reservationNumber,
-            // statusは不要なので削除(2023-07-19~)
-            // reservationStatus: factory.reservationStatusType.ReservationPending,
-            reservedTicket: params.reservedTicket,
-            // underName: {
-            //     typeOf: params.agent.typeOf,
-            //     name: params.agent.name
-            // },
-            // checkedIn: false,
-            // attended: false,
-            ...(typeof params.additionalTicketText === 'string') ? { additionalTicketText: params.additionalTicketText } : undefined,
-            ...(Array.isArray(params.subReservation))
-                ? {
-                    subReservation: params.subReservation.map((r) => {
-                        return {
-                            reservedTicket: {
-                                ticketedSeat: r.reservedTicket.ticketedSeat,
-                                typeOf: 'Ticket'
-                            }
-                        };
-                    })
-                }
-                : undefined,
-            // reservationPackage保管に移行(2023-06-06~)
-            // ...(typeof params.broker?.typeOf === 'string') ? { broker: params.broker } : undefined,
-            ...(typeof params.programMembershipUsed?.identifier === 'string')
-                ? { programMembershipUsed: params.programMembershipUsed }
-                : undefined
-        };
+        throw new factory.errors.NotImplemented(`reservationFor not implemented. typeOf:${params.reservationFor.typeOf}`);
     }
 }

package/lib/chevre/service/assetTransaction/reserve/start/factory/createStartParams.js

@@ -125,17 +125,15 @@ function createIssuedThrough(params) {
             typeOf: 'CategoryCode'
         }
         : undefined;
-    const availableChannel = eventOffers.itemOffered.availableChannel;
-    if (availableChannel === undefined) {
+    if (typeof eventOffers.itemOffered.id !== 'string') {
         // availableChannelは必ず存在するはず
-        throw new factory.errors.NotFound('reservationFor.offers.availableChannel');
+        throw new factory.errors.NotFound('reservationFor.offers.itemOffered.id');
     }
     if (params.reservationFor.typeOf === factory.eventType.ScreeningEvent) {
         const issuedThrough = {
             typeOf: factory.product.ProductType.EventService,
             // 興行IDを追加(2022-09-08~)
             id: eventOffers.itemOffered.id,
-            availableChannel,
             // issuedThrough.serviceTypeを連携
             ...(typeof serviceTypeOfIssuedThrough?.typeOf === 'string') ? { serviceType: serviceTypeOfIssuedThrough } : undefined
         };
@@ -144,16 +142,6 @@ function createIssuedThrough(params) {
         };
     }
     else {
-        const issuedThrough = {
-            typeOf: factory.product.ProductType.Transportation,
-            // 興行IDを追加(2022-09-08~)
-            id: eventOffers.itemOffered.id,
-            availableChannel,
-            // issuedThrough.serviceTypeを連携
-            ...(typeof serviceTypeOfIssuedThrough?.typeOf === 'string') ? { serviceType: serviceTypeOfIssuedThrough } : undefined
-        };
-        return {
-            issuedThrough
-        };
+        throw new factory.errors.NotImplemented(`reservationFor not implemented. typeOf:${params.reservationFor.typeOf}`);
     }
 }

package/lib/chevre/service/assetTransaction/reserve/start/factory/price.d.ts

@@ -14,4 +14,4 @@ export declare function createPrice(params: {
     seatPriceComponent: factory.place.seat.IPriceComponent[];
     acceptedAddOns: IAcceptedAddOn[];
     appliesToMovieTicket?: factory.assetTransaction.reserve.IAcceptedAppliesToMovieTicket;
-}): factory.reservation.IPriceSpecification<factory.reservationType.EventReservation>;
+}): factory.reservation.eventReservation.IPrice;