@chevre/domain 25.2.0-alpha.5 → 25.2.0-alpha.51

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

@@ -82,7 +82,8 @@ function createStartParams(params, options) {
             break;
         }
         default:
-        // no op
+            // no op
+            throw new factory_1.factory.errors.NotImplemented(`paymentServiceType: ${params.paymentServiceType} not implemented`);
     }
     // const informPaymentParams = createInformPaymentParams({
     //     paymentService: <factory.service.paymentService.IService | undefined>params.paymentService
@@ -122,12 +123,10 @@ function createStartParams(params, options) {
             : paymentMethodType,
         amount: paymentMethodAmount, // MonetaryAmount対応(2023-08-14~)
         identifier: paymentMethodType, // 追加(2023-08-29~)
+        totalPaymentDue,
         ...(typeof params.object.paymentMethod?.description === 'string')
             ? { description: params.object.paymentMethod?.description }
             : undefined,
-        ...(totalPaymentDue !== undefined)
-            ? { totalPaymentDue: totalPaymentDue }
-            : undefined,
         ...(typeof accountId === 'string') ? { accountId: accountId } : undefined,
         ...(typeof params.object.paymentMethod?.method === 'string')
             ? { method: params.object.paymentMethod?.method }

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

@@ -44,7 +44,7 @@ export { IPaymentAgencyTransaction };
  * 取引開始
  */
 export declare function start(params: factory.assetTransaction.pay.IStartParamsWithoutDetail & {
-    instrument: factory.action.trade.pay.IPlaceOrderRelatedInstrument[];
+    instrument: factory.action.trade.pay.IPayTransactionInstrument[];
 }, options: {
     pendingPaymentAgencyTransaction?: IPaymentAgencyTransaction;
     /**

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

@@ -0,0 +1,16 @@
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction } from '../eventEmitter/task';
+type IExecuteSettings = IMinimumExecuteSettings;
+type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
+declare function executeAsyncActionById(params: {
+    /**
+     * タスクID
+     */
+    id: string;
+    executor: {
+        /**
+         * タスク実行者名称
+         */
+        name: string;
+    };
+}, next?: INextFunction): IOperation<void>;
+export { executeAsyncActionById };

package/lib/chevre/service/asyncAction.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAsyncActionById = executeAsyncActionById;
+/**
+ * 非同期アクションサービス
+ */
+const debug_1 = __importDefault(require("debug"));
+const asyncActionHandler_1 = require("./asyncActionHandler");
+const debug = (0, debug_1.default)('chevre-domain:service:task');
+function executeAsyncActionById(params, next) {
+    return async (settings) => {
+        const asyncActionRepo = new (await import('../repo/asyncAction.js')).AsyncActionRepo(settings.connection);
+        const { id, executor } = params;
+        let task = null;
+        try {
+            task = await asyncActionRepo.executeAsyncActionById({
+                id,
+                executor: { name: executor.name }
+            });
+        }
+        catch (error) {
+            /* istanbul ignore next */
+            debug('service.asyncAction.executeAsyncActionById error:', error);
+        }
+        // タスクがなければ終了
+        if (task !== null) {
+            await (0, asyncActionHandler_1.executeAsyncAction)(task, (typeof next === 'function') ? next : undefined)(settings, {
+                executeById: true,
+                executeByName: false
+            });
+        }
+    };
+}

package/lib/chevre/service/asyncActionHandler/onOperationFailed.d.ts

@@ -0,0 +1,15 @@
+import type { IExecutedTask } from '../../eventEmitter/task';
+import type { AsyncActionRepo, IExecutableAsyncAction } from '../../repo/asyncAction';
+/**
+ * タスク実行失敗時処理
+ */
+declare function onOperationFailed(params: {
+    task: IExecutableAsyncAction;
+    now: Date;
+    error: any;
+}): (repos: {
+    asyncAction: AsyncActionRepo;
+}) => Promise<{
+    executedTask: IExecutedTask;
+}>;
+export { onOperationFailed };

package/lib/chevre/service/asyncActionHandler/onOperationFailed.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperationFailed = onOperationFailed;
+const factory_1 = require("../../factory");
+/**
+ * タスク実行失敗時処理
+ */
+function onOperationFailed(params) {
+    return async (repos) => {
+        let error = params.error;
+        const { task, now } = params;
+        if (error === null || typeof error !== 'object') {
+            error = { message: String(error) };
+        }
+        const endDate = new Date();
+        // 非同期アクションはワンタイムタスクなのでリトライはありえない
+        // ワンタイムタスクは分析連携しない
+        const result = {
+            executedAt: now,
+            endDate,
+            error: {
+                ...error,
+                code: error.code,
+                message: error.message,
+                name: error.name,
+                stack: error.stack
+            }
+        };
+        await repos.asyncAction.setExecutionResultAndStatus({ id: task.id }, {
+            status: factory_1.factory.taskStatus.Aborted,
+            executionResult: result
+        });
+        const executedTask = {
+            id: task.id,
+            remainingNumberOfTries: 0,
+            name: task.name,
+            status: factory_1.factory.taskStatus.Aborted,
+            executionResult: result
+        };
+        return { executedTask };
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { INextFunction } from '../eventEmitter/task';
+import type { ICallResult, ICallableTaskOperation, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { IExecutableAsyncAction } from '../repo/asyncAction';
+export declare const taskLoader: {
+    load: (taskName: string) => Promise<{
+        call: ICallableTaskOperation;
+    }>;
+};
+/**
+ * 非同期アクションを実行する
+ */
+declare function executeAsyncAction(task: IExecutableAsyncAction, next?: INextFunction): IOperationExecute<void>;
+export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeAsyncAction };

package/lib/chevre/service/asyncActionHandler.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskLoader = void 0;
+exports.executeAsyncAction = executeAsyncAction;
+const debug_1 = __importDefault(require("debug"));
+const moment_1 = __importDefault(require("moment"));
+const factory_1 = require("../factory");
+const onOperationFailed_1 = require("./asyncActionHandler/onOperationFailed");
+const debug = (0, debug_1.default)('chevre-domain:service:asyncActionHandler');
+exports.taskLoader = {
+    load: (taskName) => {
+        return import(`./task/${taskName}.js`);
+    }
+};
+/**
+ * 非同期アクションを実行する
+ */
+function executeAsyncAction(task, next) {
+    const now = new Date();
+    debug('executing an executableTask...', task, now);
+    return async (settings, options) => {
+        const asyncActionRepo = new (await import('../repo/asyncAction.js')).AsyncActionRepo(settings.connection);
+        let executedTask;
+        try {
+            // 期限検証(2024-04-23~)
+            if (task.expires instanceof Date) {
+                const taskExpired = (0, moment_1.default)(now)
+                    .isAfter(task.expires);
+                if (taskExpired) {
+                    throw new factory_1.factory.errors.Internal(`task expired [expires:${task.expires}]`);
+                }
+            }
+            // remainingNumberOfTriesは存在しないので検証不要
+            // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
+            const callResult = await call({
+                ...task,
+                numberOfTried: 1, // ひとまず固定でok(2026-07-26~)
+                remainingNumberOfTries: 0 // ひとまず固定でok(2026-07-26~)
+            })(settings, options);
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
+                error: (callResult?.error instanceof Error)
+                    ? {
+                        ...callResult.error,
+                        message: callResult.error.message
+                    }
+                    : ''
+            };
+            await asyncActionRepo.setExecutionResultAndStatus({ id: task.id }, {
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            });
+            executedTask = {
+                id: task.id,
+                remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                name: task.name,
+                status: factory_1.factory.taskStatus.Executed,
+                executionResult: result
+            };
+        }
+        catch (error) {
+            const onOperationFailedResult = await (0, onOperationFailed_1.onOperationFailed)({
+                task, now, error,
+            })({ asyncAction: asyncActionRepo });
+            executedTask = onOperationFailedResult.executedTask;
+        }
+        finally {
+            if (typeof next === 'function') {
+                if (executedTask === undefined) {
+                    executedTask = {
+                        id: task.id,
+                        remainingNumberOfTries: 0, // one timeの前提なのでひとまず固定で0
+                        name: task.name,
+                        status: factory_1.factory.taskStatus.Aborted,
+                        executionResult: {} // eslint-disable-line @typescript-eslint/no-explicit-any
+                    };
+                }
+                await next(executedTask)(settings);
+            }
+        }
+    };
+}

package/lib/chevre/service/notification/factory.d.ts

@@ -5,11 +5,9 @@ export interface ILineNotifyMessage {
     subject: string;
     content: string;
 }
-export declare function task2lineNotify(params: {
-    task: factory.task.ITask<factory.taskName>;
-}): ILineNotifyMessage;
 export declare function tasks2lineNotify(params: {
-    tasks: factory.task.ITask<factory.taskName>[];
+    tasks: Pick<factory.task.ITask<factory.taskName>, 'id' | 'executionResults' | 'project' | 'name' | 'runsAt'>[];
+    limit: number;
 }): ILineNotifyMessage;
 export declare function createSendEmailMessageRecipe(params: {
     mailData?: MailData;

package/lib/chevre/service/notification/factory.js

@@ -4,37 +4,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ABORT_REPORT_SUBJECT = void 0;
-exports.task2lineNotify = task2lineNotify;
 exports.tasks2lineNotify = tasks2lineNotify;
 exports.createSendEmailMessageRecipe = createSendEmailMessageRecipe;
 const moment_1 = __importDefault(require("moment"));
 const factory_1 = require("../../factory");
 exports.ABORT_REPORT_SUBJECT = 'tasks aborted';
-function task2lineNotify(params) {
-    const task = params.task;
-    const lastExecutionResult = (task.executionResults.length > 0) ? task.executionResults.slice(-1)[0] : undefined;
-    let lastError = lastExecutionResult?.error;
-    if (typeof lastError === 'string') {
-        lastError = { message: lastError, name: 'Error' };
-    }
-    const lastMessage = `${String(lastError?.name)} ${String(lastError?.message)}`;
-    const content = `project:${task.project?.id}
-id:${task.id}
-name:${task.name}
-runsAt:${(0, moment_1.default)(task.runsAt)
-        .toISOString()}
-lastTriedAt:${(0, moment_1.default)(task.lastTriedAt)
-        .toISOString()}
-numberOfTried:${task.numberOfTried}
-lastMessage:${lastMessage}`;
-    return {
-        subject: exports.ABORT_REPORT_SUBJECT,
-        content: content
-    };
-}
+// function task2lineNotify(params: {
+//     task: factory.task.ITask<factory.taskName>;
+// }): ILineNotifyMessage {
+//     const task = params.task;
+//     const lastExecutionResult = (task.executionResults.length > 0) ? task.executionResults.slice(-1)[0] : undefined;
+//     let lastError = lastExecutionResult?.error;
+//     if (typeof lastError === 'string') {
+//         lastError = { message: lastError, name: 'Error' };
+//     }
+//     const lastMessage = `${String(lastError?.name)} ${String(lastError?.message)}`;
+//     const content = `project:${task.project?.id}
+// id:${task.id}
+// name:${task.name}
+// runsAt:${moment(task.runsAt)
+//             .toISOString()}
+// lastTriedAt:${moment((task.lastTriedAt as Date))
+//             .toISOString()}
+// numberOfTried:${task.numberOfTried}
+// lastMessage:${lastMessage}`;
+//     return {
+//         subject: ABORT_REPORT_SUBJECT,
+//         content: content
+//     };
+// }
 const MAX_LAST_MESSAGE_LENGTH = 60;
 function tasks2lineNotify(params) {
-    const subject = `${params.tasks.length} ${exports.ABORT_REPORT_SUBJECT}`;
+    const abortedTasksCount = (params.tasks.length >= params.limit) ? `over ${params.tasks.length}` : params.tasks.length;
+    const subject = `${abortedTasksCount} ${exports.ABORT_REPORT_SUBJECT}`;
     let content;
     // あまりに通知タスク数が多いケースに対応
     if (params.tasks.length > 10) {

package/lib/chevre/service/notification/notifyAbortedTasksByEmail.d.ts

@@ -1,13 +1,19 @@
 import type { TaskRepo } from '../../repo/task';
 import type { IntegrationSettingRepo } from '../../repo/setting/integration';
+interface INotifyAbortedTasksRepos {
+    task: TaskRepo;
+    integrationSetting: IntegrationSettingRepo;
+}
 /**
  * 中止されたタスクリストをEメールで通知する
  * add(2025-03-13~)
  */
 declare function notifyAbortedTasksByEmail(params: {
     dateAbortedGte: Date;
-}): (repos: {
-    task: TaskRepo;
-    integrationSetting: IntegrationSettingRepo;
-}) => Promise<void>;
-export { notifyAbortedTasksByEmail };
+    dateAbortedLte: Date;
+    /**
+     * 中止タスクがあまりに多いと性能に影響するので、現実的にタスク数を制限する
+     */
+    limit: number;
+}): (repos: INotifyAbortedTasksRepos) => Promise<void>;
+export { notifyAbortedTasksByEmail, INotifyAbortedTasksRepos };

package/lib/chevre/service/notification/notifyAbortedTasksByEmail.js

@@ -17,16 +17,24 @@ function notifyAbortedTasksByEmail(params) {
     return async (repos) => {
         const abortedTasksWithoutReport = await repos.integrationSetting.getByKey('abortedTasksWithoutReport');
         const abortedTasks = await repos.task.projectFields({
+            limit: params.limit,
+            page: 1,
             status: { $eq: factory_1.factory.taskStatus.Aborted },
-            dateAborted: { $gte: params.dateAbortedGte },
+            dateAborted: {
+                $gte: params.dateAbortedGte,
+                $lte: params.dateAbortedLte,
+            },
             // 中止を報告しないタスク以外にフィルター
             ...(abortedTasksWithoutReport.length > 0)
                 ? { name: { $nin: abortedTasksWithoutReport } }
                 : undefined
-        }, []);
+        }, ['executionResults', 'name', 'project', 'runsAt']);
         if (abortedTasks.length > 0) {
             // 開発者へ報告
-            const message = (0, factory_2.tasks2lineNotify)({ tasks: abortedTasks });
+            const message = (0, factory_2.tasks2lineNotify)({
+                tasks: abortedTasks,
+                limit: params.limit
+            });
             const notifyResult = await (0, notifyByEmail_1.notifyByEmail)({
                 subject: message.subject, content: message.content,
                 logLevel: 'error'

package/lib/chevre/service/offer/event/authorize/factory.d.ts

@@ -1,5 +1,4 @@
 import { factory } from '../../../../factory';
-import { IMinimizedIndividualEvent } from '../../../../factory/event';
 declare function createReserveTransactionStartParams(params: {
     project: {
         id: string;
@@ -13,7 +12,6 @@ declare function createReserveTransactionStartParams(params: {
     transactionNumber: string;
 }): factory.assetTransaction.reserve.IStartParamsWithoutDetail;
 declare function createAuthorizeSeatReservationActionAttributes(params: {
-    event: Pick<IMinimizedIndividualEvent, 'id'>;
     instrument: {
         /**
          * 予約取引番号
@@ -21,8 +19,6 @@ declare function createAuthorizeSeatReservationActionAttributes(params: {
         transactionNumber: string;
     };
     transaction: Pick<factory.transaction.ITransaction<factory.transactionType.PlaceOrder>, 'agent' | 'id' | 'project' | 'seller' | 'typeOf'>;
-}, options: {
-    useLegacyAuthorizeOfferObject: boolean;
 }): factory.action.authorize.offer.eventService.IAttributes;
 declare function acceptedOffers2amount(params: {
     acceptedOffers: Pick<IResultAcceptedOffer, 'priceSpecification' | 'id'>[];
@@ -31,7 +27,9 @@ declare function acceptedOffers2authorizeResult(params: {
     acceptedOffers4result: IResultAcceptedOffer[];
     noOfferSpecified: boolean;
     ticketOffers: factory.product.ITicketOffer[];
-}): factory.action.authorize.offer.eventService.IResult;
+}): factory.action.authorize.offer.eventService.IResult & {
+    onlyPrice?: boolean;
+};
 type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
 export type IResultAcceptedOffer = Omit<factory.order.IOptimizedAcceptedOffer, 'priceSpecification'> & {
     itemOffered: factory.order.IEventReservation;

package/lib/chevre/service/offer/event/authorize/factory.js

@@ -80,16 +80,16 @@ function createReserveTransactionStartParams(params) {
             .toDate() // 余裕を持って
     };
 }
-function createAuthorizeSeatReservationActionAttributes(params, options) {
-    const { useLegacyAuthorizeOfferObject } = options;
-    const { event, transaction } = params;
-    const authorizeObjectEvent = {
-        id: event.id,
-        typeOf: factory_1.factory.eventType.ScreeningEvent // fix(2024-07-17~)
-    };
+function createAuthorizeSeatReservationActionAttributes(params) {
+    // const { useLegacyAuthorizeOfferObject } = options;
+    const { transaction } = params;
+    // const authorizeObjectEvent: factory.action.authorize.offer.eventService.IEventInObject = {
+    //     id: event.id,
+    //     typeOf: factory.eventType.ScreeningEvent // fix(2024-07-17~)
+    // };
     const object = {
         typeOf: factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation,
-        ...((useLegacyAuthorizeOfferObject) && { event: authorizeObjectEvent })
+        // ...((useLegacyAuthorizeOfferObject) && { event: authorizeObjectEvent })
     };
     const instrument = {
         typeOf: factory_1.factory.assetTransactionType.Reserve, // 変更(2024-03-08~)
@@ -144,82 +144,100 @@ function acceptedOffers2amount(params) {
     });
     return amount;
 }
-function acceptedOffers2programMembershipUsed(params) {
-    const programMembershipUsed = [];
-    const permitIdentifiers = [];
-    params.acceptedOffers.forEach(({ itemOffered }) => {
-        if (itemOffered.programMembershipUsed?.typeOf === factory_1.factory.programMembership.ProgramMembershipType.ProgramMembership) {
-            // メンバーシップコードに対してユニークに集計
-            if (!permitIdentifiers.includes(itemOffered.programMembershipUsed.identifier)) {
-                permitIdentifiers.push(itemOffered.programMembershipUsed.identifier);
-                const issuedThroughTypeOf = itemOffered.programMembershipUsed.issuedThrough.typeOf;
-                if (issuedThroughTypeOf === factory_1.factory.service.paymentService.PaymentServiceType.FaceToFace) {
-                    programMembershipUsed.push({
-                        typeOf: factory_1.factory.permit.PermitType.Permit,
-                        identifier: itemOffered.programMembershipUsed.identifier,
-                        issuedThrough: { typeOf: issuedThroughTypeOf }
-                    });
-                }
-                else {
-                    programMembershipUsed.push({
-                        typeOf: factory_1.factory.permit.PermitType.Permit,
-                        identifier: itemOffered.programMembershipUsed.identifier,
-                        issuedThrough: { typeOf: issuedThroughTypeOf, id: itemOffered.programMembershipUsed.issuedThrough.id }
-                    });
-                }
-            }
-        }
-    });
-    return programMembershipUsed;
-}
+// function acceptedOffers2programMembershipUsed(params: {
+//     acceptedOffers: IResultAcceptedOffer[];
+// }): factory.action.authorize.offer.eventService.IAggregateProgramMembershipUsed {
+//     const programMembershipUsed: factory.action.authorize.offer.eventService.IAggregateProgramMembershipUsed = [];
+//     const permitIdentifiers: string[] = [];
+//     params.acceptedOffers.forEach(
+//         ({ itemOffered }) => {
+//             if (itemOffered.programMembershipUsed?.typeOf === factory.programMembership.ProgramMembershipType.ProgramMembership) {
+//                 // メンバーシップコードに対してユニークに集計
+//                 if (!permitIdentifiers.includes(itemOffered.programMembershipUsed.identifier)) {
+//                     permitIdentifiers.push(itemOffered.programMembershipUsed.identifier);
+//                     const issuedThroughTypeOf = itemOffered.programMembershipUsed.issuedThrough.typeOf;
+//                     if (issuedThroughTypeOf === factory.service.paymentService.PaymentServiceType.FaceToFace) {
+//                         programMembershipUsed.push({
+//                             typeOf: factory.permit.PermitType.Permit,
+//                             identifier: itemOffered.programMembershipUsed.identifier,
+//                             issuedThrough: { typeOf: issuedThroughTypeOf }
+//                         });
+//                     } else {
+//                         programMembershipUsed.push({
+//                             typeOf: factory.permit.PermitType.Permit,
+//                             identifier: itemOffered.programMembershipUsed.identifier,
+//                             issuedThrough: { typeOf: issuedThroughTypeOf, id: itemOffered.programMembershipUsed.issuedThrough.id }
+//                         });
+//                     }
+//                 }
+//             }
+//         }
+//     );
+//     return programMembershipUsed;
+// }
 function acceptedOffers2authorizeResult(params) {
-    const { acceptedOffers4result, noOfferSpecified, ticketOffers } = params;
-    // const priceCurrency = factory.priceCurrency.JPY; // fix(2024-07-03~)
-    let offers;
+    const { acceptedOffers4result, noOfferSpecified,
+    // ticketOffers
+     } = params;
+    // let offers: factory.action.authorize.offer.eventService.IAcceptedOfferInResult[] | undefined;
     let price;
-    let programMembershipUsed = [];
+    // let programMembershipUsed: factory.action.authorize.offer.eventService.IAggregateProgramMembershipUsed = [];
     if (!noOfferSpecified) {
         price = acceptedOffers2amount({ acceptedOffers: acceptedOffers4result }); // オファー指定の場合のみ金額計算(2023-11-27~)
-        programMembershipUsed = acceptedOffers2programMembershipUsed({ acceptedOffers: acceptedOffers4result });
+        // programMembershipUsed = acceptedOffers2programMembershipUsed({ acceptedOffers: acceptedOffers4result });
         // オファーIDごとに集計
-        const offerIds = [...new Set(acceptedOffers4result.map((o) => String(o.id)))];
-        // const offerIds = [...new Set(acceptedOffers.map((o) => o.id))];
-        offers = offerIds.map((offerId) => {
-            const acceptedOffer = ticketOffers.find(({ id }) => id === offerId);
-            if (acceptedOffer === undefined) {
-                throw new factory_1.factory.errors.Internal(`acceptedOffer not found [id:${offerId}]`);
-            }
-            const amountOfThisGood = acceptedOffers4result.filter(({ id }) => id === offerId).length;
-            // const amountOfThisGood: number = acceptedOffers.filter(({ id }) => id === offerId).length;
-            const { acceptedPaymentMethod, priceSpecification } = acceptedOffer;
-            const unitPriceSpec = priceSpecification.priceComponent.find((spec) => spec.typeOf === factory_1.factory.priceSpecificationType.UnitPriceSpecification
-                && (!Array.isArray(spec.appliesToAddOn)) // アドオン単価ではない
-            );
-            if (unitPriceSpec === undefined) {
-                throw new factory_1.factory.errors.Internal(`unitPriceSpec not found [id:${offerId}]`);
-            }
-            const { eligibleQuantity } = unitPriceSpec;
-            return {
-                id: offerId,
-                includesObject: { amountOfThisGood },
-                typeOf: factory_1.factory.offerType.Offer,
-                priceSpecification: {
-                    ...(eligibleQuantity !== undefined) ? { eligibleQuantity } : undefined,
-                    // ...(eligibleTransactionVolume !== undefined) ? { eligibleTransactionVolume } : undefined // discontinue(2026-07-05~)
-                },
-                ...(acceptedPaymentMethod !== undefined) ? { acceptedPaymentMethod } : undefined
-            };
-        });
+        // const offerIds = [...new Set(acceptedOffers4result.map((o) => String(o.id)))];
+        // offers = offerIds.map<factory.action.authorize.offer.eventService.IAcceptedOfferInResult>((offerId) => {
+        //     const acceptedOffer = ticketOffers.find(({ id }) => id === offerId);
+        //     if (acceptedOffer === undefined) {
+        //         throw new factory.errors.Internal(`acceptedOffer not found [id:${offerId}]`);
+        //     }
+        //     const amountOfThisGood: number = acceptedOffers4result.filter(({ id }) => id === offerId).length;
+        //     // const amountOfThisGood: number = acceptedOffers.filter(({ id }) => id === offerId).length;
+        //     const { acceptedPaymentMethod, priceSpecification } = acceptedOffer;
+        //     const unitPriceSpec = priceSpecification.priceComponent.find(
+        //         (spec) => spec.typeOf === factory.priceSpecificationType.UnitPriceSpecification
+        //             && (!Array.isArray(spec.appliesToAddOn)) // アドオン単価ではない
+        //     ) as IUnitPriceSpecification | undefined;
+        //     if (unitPriceSpec === undefined) {
+        //         throw new factory.errors.Internal(`unitPriceSpec not found [id:${offerId}]`);
+        //     }
+        //     const { eligibleQuantity } = unitPriceSpec;
+        //     return {
+        //         id: offerId,
+        //         includesObject: { amountOfThisGood },
+        //         typeOf: factory.offerType.Offer,
+        //         priceSpecification: {
+        //             ...(eligibleQuantity !== undefined) ? { eligibleQuantity } : undefined,
+        //             // ...(eligibleTransactionVolume !== undefined) ? { eligibleTransactionVolume } : undefined // discontinue(2026-07-05~)
+        //         },
+        //         ...(acceptedPaymentMethod !== undefined) ? { acceptedPaymentMethod } : undefined
+        //     };
+        // });
     }
+    // discontinue useLegacyAuthorizeOfferResult(2026-07-18~)
+    // if (useLegacyAuthorizeOfferResult) {
+    //     return {
+    //         typeOf: factory.offerType.AggregateOffer,
+    //         // priceCurrency, // discontinue(2026-07-06~)
+    //         // amount: [], // discontinue(2026-07-06~)
+    //         itemOffered: {
+    //             serviceOutput: { programMembershipUsed } // add programMembershipUsed required(2024-08-15~)
+    //         },
+    //         ...(typeof price === 'number') ? { price } : undefined,
+    //         ...(Array.isArray(offers)) ? { offers } : undefined
+    //     };
+    // } else {
+    //     return {
+    //         typeOf: factory.offerType.AggregateOffer,
+    //         onlyPrice: true,
+    //         ...(typeof price === 'number') ? { price } : undefined,
+    //     };
+    // }
     return {
         typeOf: factory_1.factory.offerType.AggregateOffer,
-        // priceCurrency, // discontinue(2026-07-06~)
-        // amount: [], // discontinue(2026-07-06~)
-        itemOffered: {
-            serviceOutput: { programMembershipUsed } // add programMembershipUsed required(2024-08-15~)
-        },
+        onlyPrice: true,
         ...(typeof price === 'number') ? { price } : undefined,
-        ...(Array.isArray(offers)) ? { offers } : undefined
     };
 }
 function responseBody2acceptedOffers4result(params) {

package/lib/chevre/service/offer/event/authorize.d.ts

@@ -63,10 +63,6 @@ interface IAuthorizeOptions {
      * 最大n日前から予約可能
      */
     maxReservationGracePeriodInDays: number;
-    /**
-     * 2026-07-04~
-     */
-    useLegacyAuthorizeOfferObject: boolean;
 }
 /**
  * 興行オファー承認

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

@@ -32,9 +32,9 @@ function authorize(params, options) {
         // まず取引番号発行
         const { transactionNumber } = await repos.transactionNumber.publishByTimestamp({ startDate: now });
         const actionAttributes = (0, factory_2.createAuthorizeSeatReservationActionAttributes)({
-            event, transaction,
+            transaction,
             instrument: { transactionNumber }
-        }, options);
+        });
         const action = await repos.authorizeOfferAction.start(actionAttributes);
         try {
             const processStartReserveResult = await (0, processStartReserve4chevre_1.processStartReserve4chevre)({