@chevre/domain 24.1.0-alpha.8 → 25.0.0-alpha.0

package/lib/chevre/emailMessageBuilder.d.ts

@@ -4,7 +4,7 @@ type ISendableEmailMessage = factory.action.transfer.send.message.email.IObjectA
     identifier: string;
     name: string;
 };
-export type IOrderAsCreateEmailParams = Pick<factory.order.IOrder, 'confirmationNumber' | 'identifier' | 'customer' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'price' | 'priceCurrency' | 'seller' | 'typeOf'>;
+export type IOrderAsCreateEmailParams = Pick<factory.order.IOrder, 'confirmationNumber' | 'customer' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'price' | 'priceCurrency' | 'seller' | 'typeOf'>;
 /**
  * 注文配送メッセージを作成する
  */

package/lib/chevre/emailMessageBuilder.js

@@ -93,9 +93,7 @@ async function createEmailMessageAbout(params) {
     }
     return about;
 }
-function createEmailMessageSender(params, 
-// settings: Settings
-setting) {
+function createEmailMessageSender(params, setting) {
     if (typeof setting.defaultSenderEmail !== 'string') {
         throw new factory_1.factory.errors.NotFound('setting.defaultSenderEmail');
     }
@@ -113,9 +111,7 @@ setting) {
 /**
  * 注文配送メッセージを作成する
  */
-async function createSendOrderMessage(params, 
-// settings: Settings
-setting) {
+async function createSendOrderMessage(params, setting) {
     const emailMessageText = await createEmailMessageText({
         order: params.order,
         email: params.email,
@@ -169,9 +165,7 @@ setting) {
 /**
  * 注文返品メッセージを作成する
  */
-async function createReturnOrderMessage(params, 
-// settings: Settings
-setting) {
+async function createReturnOrderMessage(params, setting) {
     const emailMessageText = await createEmailMessageText({
         order: params.order,
         email: params.email,
@@ -225,9 +219,7 @@ setting) {
 /**
  * 返金メッセージを作成する
  */
-async function createRefundMessage(params, 
-// settings: Settings
-setting) {
+async function createRefundMessage(params, setting) {
     const emailMessageText = await createEmailMessageText({
         order: params.order,
         email: params.email

package/lib/chevre/factory/transaction/placeOrder.d.ts

@@ -1,17 +1,9 @@
 import { factory } from '../../factory';
-export type IStartParams = factory.transaction.placeOrder.IStartParamsWithoutDetail & {
-    broker?: factory.order.IBroker;
-};
-export type IOrderURLGenerator = (order: factory.transaction.placeOrder.IOrderAsResult) => string;
-export type IResultOrderParams = factory.transaction.placeOrder.IResultOrderParams & {
+export interface IResultOrderParams {
     /**
      * 注文日時
      */
     orderDate: Date;
-    /**
-     * 注文確認URLのカスタム指定
-     */
-    url?: string | IOrderURLGenerator;
     /**
      * オファー制約
      */
@@ -29,7 +21,7 @@ export type IResultOrderParams = factory.transaction.placeOrder.IResultOrderPara
     orderedItem: {
         maxValue: number;
     };
-};
+}
 export type IConfirmParams = factory.transaction.placeOrder.IConfirmParams & {
     project: {
         id: string;

package/lib/chevre/factory/transaction/placeOrder.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/chevre/index.d.ts

@@ -1,4 +1,3 @@
-import { credentials } from './credentials';
 import * as errorHandler from './errorHandler';
 import * as eventEmitter from './eventEmitter';
 import { factory } from './factory';
@@ -6,4 +5,4 @@ import * as repository from './repository';
 import * as service from './service';
 import * as settings from './settings';
 import * as taskSettings from './taskSettings';
-export { credentials, errorHandler, eventEmitter, factory, repository, service, settings, taskSettings };
+export { errorHandler, eventEmitter, factory, repository, service, settings, taskSettings };

package/lib/chevre/index.js

@@ -33,9 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taskSettings = exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = exports.credentials = void 0;
-const credentials_1 = require("./credentials");
-Object.defineProperty(exports, "credentials", { enumerable: true, get: function () { return credentials_1.credentials; } });
+exports.taskSettings = exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = void 0;
 const errorHandler = __importStar(require("./errorHandler"));
 exports.errorHandler = errorHandler;
 const eventEmitter = __importStar(require("./eventEmitter"));

package/lib/chevre/repo/acceptedOffer.d.ts

@@ -1,28 +1,34 @@
 import type { Connection } from 'mongoose';
 import { factory } from '../factory';
+import { AcceptedOfferInReserveRepo, IAcceptedOffer } from './acceptedOfferInReserve';
 type IProjection4searchWithUnwoundAcceptedOffers = {
     [key in keyof factory.order.IOrder]?: 1;
-} & {
-    _id?: 0 | 1;
-};
-type IDistinctField = 'acceptedOffers.id' | 'acceptedOffers.itemOffered.reservationNumber' | 'acceptedOffers.itemOffered.reservationFor.id' | 'acceptedOffers.itemOffered.issuedThrough.id' | 'acceptedOffers.itemOffered.typeOf' | 'acceptedOffers.serialNumber' | 'acceptedOffers.offeredThrough.identifier' | 'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode' | 'acceptedOffers.itemOffered.object.pendingTransaction.transactionNumber';
-type IAcceptedOffer = factory.order.IAcceptedOffer;
+} & {};
+type IDistinctField = 'acceptedOffers.id' | 'acceptedOffers.itemOffered.reservationNumber' | 'acceptedOffers.itemOffered.reservationFor.id' | 'acceptedOffers.serialNumber' | 'acceptedOffers.offeredThrough.identifier' | 'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode';
 interface ISearchSlicedAcceptedOffersResult {
-    acceptedOffers: IAcceptedOffer[];
+    acceptedOffers: Pick<IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[];
     numAcceptedOffers: number;
 }
 /**
  * 注文オファーリポジトリ
  */
-export declare class AcceptedOfferRepo {
+export declare class AcceptedOfferRepo extends AcceptedOfferInReserveRepo {
     private readonly orderModel;
     constructor(connection: Connection);
     /**
      * オファー展開の注文検索
+     * admin API経由で呼ばれる想定
      */
-    searchWithUnwoundAcceptedOffers(params: factory.order.ISearchConditions, projection: IProjection4searchWithUnwoundAcceptedOffers, options: {
-        useLimitAfterSkip: boolean;
-    }): Promise<factory.order.IOrder[]>;
+    findAcceptedOffers(
+    /**
+     * 索条件を最小化(2026-06-05~)
+     */
+    params: Pick<factory.order.ISearchConditions, 'limit' | 'orderNumbers' | 'page' | 'project' | 'provider' | 'sort' | 'orderDate'>, projection: IProjection4searchWithUnwoundAcceptedOffers, options: {
+        noName: boolean;
+    }): Promise<(factory.order.IOrder & {
+        acceptedOffers: [IAcceptedOffer];
+        _id?: never;
+    })[]>;
     aggreateOwnershipInfosByOrder(filter: {
         orderNumber: {
             $eq: string;
@@ -32,11 +38,14 @@ export declare class AcceptedOfferRepo {
     }[]>;
     /**
      * 注文オファーを展開して検索する
+     * 注文番号指定で1注文ドキュメントから参照する想定
      */
     searchAcceptedOffersByOrderNumber(filter: {
+        /**
+         * 未指定であれば注文内オファー全件が対象
+         */
         limit?: number;
         page?: number;
-        $slice?: [number, number];
         orderNumber: {
             $eq: string;
         };
@@ -53,24 +62,13 @@ export declare class AcceptedOfferRepo {
                 id?: {
                     $eq?: string;
                 };
-                typeOf?: {
-                    $in?: factory.order.IItemOffered['typeOf'][];
-                };
-                reservationFor?: {
-                    id?: {
-                        $in?: string[];
-                    };
-                };
-                reservedTicket?: {
-                    ticketedSeat?: {
-                        seatNumber?: {
-                            $in?: string[];
-                        };
-                    };
-                };
+                reservationFor?: never;
+                reservedTicket?: never;
             };
         };
-    }, inclusion?: (keyof IAcceptedOffer)[]): Promise<IAcceptedOffer[]>;
+    }, options: {
+        noName: boolean;
+    }): Promise<Pick<IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[]>;
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
      */

package/lib/chevre/repo/acceptedOffer.js

@@ -3,23 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcceptedOfferRepo = void 0;
 const factory_1 = require("../factory");
 const order_1 = require("./mongoose/schemas/order");
+const acceptedOfferInReserve_1 = require("./acceptedOfferInReserve");
 const order_2 = require("./order");
 const settings_1 = require("../settings");
+// const debug = createDebug('chevre-domain:repo:acceptedOffer');
 /**
  * 注文オファーリポジトリ
  */
-class AcceptedOfferRepo {
+class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveRepo {
     orderModel;
     constructor(connection) {
+        super(connection);
         this.orderModel = connection.model(order_1.modelName, (0, order_1.createSchema)());
     }
     /**
      * オファー展開の注文検索
+     * admin API経由で呼ばれる想定
      */
-    async searchWithUnwoundAcceptedOffers(params, projection, options) {
-        const { useLimitAfterSkip } = options;
+    async findAcceptedOffers(
+    /**
+     * 索条件を最小化(2026-06-05~)
+     */
+    params, projection, options) {
         const conditions = order_2.OrderRepo.CREATE_MONGO_CONDITIONS(params);
         const aggregate = this.orderModel.aggregate();
+        // unwind->matchでは遅い
+        // match->unwind->matchにする(2026-05-08~)
+        conditions.forEach((c) => {
+            aggregate.match(c);
+        });
         // pipelineの順序に注意
         // @see https://docs.mongodb.com/manual/reference/operator/aggregation/sort/
         /* istanbul ignore else */
@@ -32,35 +44,77 @@ class AcceptedOfferRepo {
         });
         aggregate.project({
             ...projection,
+            _id: 0, // hide _id(2026-05-16~)
             acceptedOffers: ['$acceptedOffers']
         });
         if (typeof params.limit === 'number' && params.limit > 0) {
             const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
             // support skip -> limit(2025-07-09~)
-            if (useLimitAfterSkip) {
-                aggregate.skip(params.limit * (page - 1))
-                    .limit(params.limit);
-            }
-            else {
-                aggregate.limit(params.limit * page)
-                    .skip(params.limit * (page - 1));
-            }
+            aggregate.skip(params.limit * (page - 1))
+                .limit(params.limit);
         }
-        return aggregate
-            // .allowDiskUse(true) // false化(2023-11-30~)
+        const orders = await aggregate
             .option({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .exec();
+        // 予約取引を参照(2026-05-17~)
+        const offeredThroughIdentifier = orders.at(0)?.acceptedOffers[0].offeredThrough?.identifier;
+        const useReserveTransaction = offeredThroughIdentifier !== factory_1.factory.service.webAPI.Identifier.COA; // COAでは予約取引を参照しない
+        if (useReserveTransaction) {
+            const reservationNumbers = [...new Set(orders.map((order) => String(order.acceptedOffers[0].serialNumber)))];
+            let acceptedOffersByReserveTransaction = [];
+            if (reservationNumbers.length > 0) {
+                acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers }, options);
+            }
+            return orders.map((order) => {
+                const acceptedOffer = order.acceptedOffers[0];
+                const acceptedOfferByReserveTransaction = acceptedOffersByReserveTransaction.find(((offer) => offer.itemOffered.id === acceptedOffer.itemOffered.id));
+                // 予約は必ず存在するはず
+                if (acceptedOfferByReserveTransaction === undefined) {
+                    console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: acceptedOfferByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
+                }
+                const priceSpecByReserveTransaction = acceptedOfferByReserveTransaction?.priceSpecification;
+                // 予約の価格は必ず存在するはず
+                if (priceSpecByReserveTransaction === undefined) {
+                    console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: priceSpecByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
+                }
+                const itemOfferedByReserve = acceptedOfferByReserveTransaction?.itemOffered;
+                // itemOfferedByReserveは必ず存在するはず
+                if (itemOfferedByReserve === undefined) {
+                    console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+                }
+                const nameByReserveTransaction = acceptedOfferByReserveTransaction?.name;
+                const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
+                name: _originalName, // 注文ドキュメントのnameはもう採用しない(2026-06-09~)
+                itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
+                return {
+                    ...order,
+                    acceptedOffers: [
+                        {
+                            ...acceptedOfferWithoutPrice,
+                            ...((nameByReserveTransaction !== undefined) && { name: nameByReserveTransaction }), // 予約取引参照の値で上書き(2026-06-09~)
+                            ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
+                            ...(itemOfferedByReserve !== undefined)
+                                ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き(2026-05-25~)
+                                : { itemOffered }
+                        }
+                    ]
+                };
+            });
+        }
+        else {
+            return orders;
+        }
     }
     async aggreateOwnershipInfosByOrder(filter) {
         const aggregate = this.orderModel.aggregate([
+            { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
+            { $match: { typeOf: { $eq: factory_1.factory.order.OrderType.Order } } },
             {
                 $unwind: {
                     path: '$acceptedOffers',
                     includeArrayIndex: 'acceptedOfferIndex'
                 }
             },
-            { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
-            { $match: { typeOf: { $eq: factory_1.factory.order.OrderType.Order } } },
             {
                 $project: {
                     _id: 0,
@@ -80,43 +134,27 @@ class AcceptedOfferRepo {
     }
     /**
      * 注文オファーを展開して検索する
+     * 注文番号指定で1注文ドキュメントから参照する想定
      */
-    async searchAcceptedOffersByOrderNumber(filter, inclusion) {
-        const matchStages = [
+    async searchAcceptedOffersByOrderNumber(filter, options) {
+        /**
+         * unwind前に1ドキュメントを特定するためのstage
+         */
+        const matchStagesOneDocument = [
             { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
             { $match: { 'project.id': { $eq: filter.project.id.$eq } } },
             { $match: { typeOf: { $eq: factory_1.factory.order.OrderType.Order } } }
         ];
+        /**
+         * unwind後にオファー内容で絞るstage
+         */
+        const matchStages = [];
         const itemOfferedIdEq = filter.acceptedOffers?.itemOffered?.id?.$eq;
         if (typeof itemOfferedIdEq === 'string') {
             matchStages.push({ $match: { 'acceptedOffers.itemOffered.id': { $exists: true, $eq: itemOfferedIdEq } } });
         }
-        const itemOfferedTypeOfIn = filter.acceptedOffers?.itemOffered?.typeOf?.$in;
-        if (Array.isArray(itemOfferedTypeOfIn)) {
-            matchStages.push({
-                $match: { 'acceptedOffers.itemOffered.typeOf': { $exists: true, $in: itemOfferedTypeOfIn } }
-            });
-        }
-        const resevationForIdIn = filter.acceptedOffers?.itemOffered?.reservationFor?.id?.$in;
-        if (Array.isArray(resevationForIdIn)) {
-            matchStages.push({
-                $match: {
-                    'acceptedOffers.itemOffered.reservationFor.id': { $exists: true, $in: resevationForIdIn }
-                }
-            });
-        }
-        const ticketedSeatNumberIn = filter.acceptedOffers?.itemOffered?.reservedTicket?.ticketedSeat?.seatNumber?.$in;
-        if (Array.isArray(ticketedSeatNumberIn)) {
-            matchStages.push({
-                $match: {
-                    'acceptedOffers.itemOffered.reservedTicket.ticketedSeat.seatNumber': { $exists: true, $in: ticketedSeatNumberIn }
-                }
-            });
-        }
         const aggregate = this.orderModel.aggregate([
-            // if (typeof params.sort?.orderDate === 'number') {
-            //     aggregate.sort({ orderDate: params.sort.orderDate });
-            // }
+            ...matchStagesOneDocument,
             {
                 $unwind: {
                     path: '$acceptedOffers'
@@ -125,35 +163,27 @@ class AcceptedOfferRepo {
             },
             ...matchStages
         ]);
-        if (Array.isArray(inclusion) && inclusion.length > 0) {
-            const specifiedProjection = {
-                _id: 0
-            };
-            inclusion.forEach((key) => {
-                specifiedProjection[key] = `$acceptedOffers.${key}`;
-            });
-            aggregate.project(specifiedProjection);
-        }
-        else {
-            aggregate.project({
-                _id: 0,
-                itemOffered: '$acceptedOffers.itemOffered',
-                priceSpecification: '$acceptedOffers.priceSpecification',
-                typeOf: '$acceptedOffers.typeOf',
-                id: '$acceptedOffers.id',
-                offeredThrough: '$acceptedOffers.offeredThrough',
-                name: '$acceptedOffers.name',
-                serialNumber: '$acceptedOffers.serialNumber'
-            });
-        }
+        aggregate.project({
+            _id: 0,
+            itemOffered: '$acceptedOffers.itemOffered',
+            priceSpecification: '$acceptedOffers.priceSpecification',
+            typeOf: '$acceptedOffers.typeOf',
+            id: '$acceptedOffers.id',
+            offeredThrough: '$acceptedOffers.offeredThrough',
+            // name: '$acceptedOffers.name', // 名称はaddAcceptedOffersDetailsメソッドにて予約取引から参照される(2026-06-09~)
+            serialNumber: '$acceptedOffers.serialNumber'
+        });
         if (typeof filter.limit === 'number' && filter.limit > 0) {
             const page = (typeof filter.page === 'number' && filter.page > 0) ? filter.page : 1;
-            aggregate.limit(filter.limit * page)
-                .skip(filter.limit * (page - 1));
+            // support skip -> limit(2026-05-12~)
+            aggregate.skip(filter.limit * (page - 1))
+                .limit(filter.limit);
         }
-        return aggregate
+        const acceptedOffers = await aggregate
             .option({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .exec();
+        // 予約取引を参照(2026-05-18~)
+        return this.addAcceptedOffersDetails(acceptedOffers, options);
     }
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
@@ -177,7 +207,12 @@ class AcceptedOfferRepo {
         if (result === undefined) {
             throw new factory_1.factory.errors.NotFound(factory_1.factory.order.OrderType.Order);
         }
-        return result;
+        const { acceptedOffers, numAcceptedOffers } = result;
+        // 予約取引を参照(2026-05-18~)
+        return {
+            acceptedOffers: await this.addAcceptedOffersDetails(acceptedOffers, { noName: true }),
+            numAcceptedOffers
+        };
     }
     async countByOrderNumber(filter) {
         const aggregate = this.orderModel.aggregate([

package/lib/chevre/repo/acceptedOfferInReserve.d.ts

@@ -0,0 +1,34 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+import { IModel } from './mongoose/schemas/assetTransaction';
+import { IAcceptedOfferByReserveTransaction } from './factory/acceptedOffer/reserveTransaction2itemOffered';
+export type IAcceptedOffer = Pick<factory.order.IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'serialNumber' | 'typeOf' | 'name'> & {
+    /**
+     * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
+     */
+    priceSpecification?: factory.order.ITicketPriceSpecification;
+};
+/**
+ * 予約取引に依存した注文オファーリポジトリ
+ */
+export declare class AcceptedOfferInReserveRepo {
+    protected readonly reserveTransactionModel: IModel;
+    constructor(connection: Connection);
+    /**
+     * 予約番号指定で予約取引から注文オファーを生成する
+     */
+    protected findAcceptedOffersByReservationNumbers(params: {
+        /**
+         * 予約番号リスト
+         */
+        reservationNumbers: string[];
+    }, options: {
+        noName: boolean;
+    }): Promise<IAcceptedOfferByReserveTransaction[]>;
+    /**
+     * 予約取引からオファー詳細情報を付加する
+     */
+    protected addAcceptedOffersDetails(acceptedOffers: IAcceptedOffer[], options: {
+        noName: boolean;
+    }): Promise<IAcceptedOffer[]>;
+}

package/lib/chevre/repo/acceptedOfferInReserve.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcceptedOfferInReserveRepo = void 0;
+const debug_1 = __importDefault(require("debug"));
+const factory_1 = require("../factory");
+const assetTransaction_1 = require("./mongoose/schemas/assetTransaction");
+const reserveTransaction2itemOffered_1 = require("./factory/acceptedOffer/reserveTransaction2itemOffered");
+const debug = (0, debug_1.default)('chevre-domain:repo:acceptedOffer');
+/**
+ * 予約取引に依存した注文オファーリポジトリ
+ */
+class AcceptedOfferInReserveRepo {
+    reserveTransactionModel;
+    constructor(connection) {
+        this.reserveTransactionModel = connection.model(assetTransaction_1.modelName, (0, assetTransaction_1.createSchema)());
+    }
+    /**
+     * 予約番号指定で予約取引から注文オファーを生成する
+     */
+    async findAcceptedOffersByReservationNumbers(params, options) {
+        const { reservationNumbers } = params;
+        if (!Array.isArray(reservationNumbers) || reservationNumbers.length === 0) {
+            throw new factory_1.factory.errors.ArgumentNull('reservationNumbers');
+        }
+        const reserveTransactions = await this.reserveTransactionModel.find({
+            transactionNumber: { $in: reservationNumbers },
+            typeOf: { $eq: factory_1.factory.assetTransactionType.Reserve }
+        }, {
+            object: 1
+        })
+            .lean()
+            .exec();
+        debug('findSubReservationsByReservationNumbers: reservationNumbers.length === reserveTransactions.length?', reservationNumbers.length === reserveTransactions.length);
+        return reserveTransactions.reduce((a, b) => {
+            return [...a, ...(0, reserveTransaction2itemOffered_1.reserveTransaction2itemOffered)(b, options)];
+        }, []);
+    }
+    /**
+     * 予約取引からオファー詳細情報を付加する
+     */
+    async addAcceptedOffersDetails(acceptedOffers, options) {
+        const offeredThroughIdentifier = acceptedOffers.at(0)?.offeredThrough?.identifier;
+        if (offeredThroughIdentifier === factory_1.factory.service.webAPI.Identifier.COA) {
+            // COAでは予約取引を参照しない
+            return acceptedOffers;
+        }
+        const reservationNumbers = [...new Set(acceptedOffers.map((acceptedOffer) => String(acceptedOffer.serialNumber)))];
+        let acceptedOffersByReserveTransaction = [];
+        if (reservationNumbers.length > 0) {
+            acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers }, options);
+        }
+        return acceptedOffers.map((acceptedOffer) => {
+            const acceptedOfferByReserveTransaction = acceptedOffersByReserveTransaction.find(((offer) => offer.itemOffered.id === acceptedOffer.itemOffered.id));
+            // 予約は必ず存在するはず
+            if (acceptedOfferByReserveTransaction === undefined) {
+                console.error('repo:acceptedOffer: addAcceptedOffersDetails: acceptedOfferByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
+            }
+            const priceSpecByReserveTransaction = acceptedOfferByReserveTransaction?.priceSpecification;
+            // 予約の価格は必ず存在するはず
+            if (priceSpecByReserveTransaction === undefined) {
+                console.error('repo:acceptedOffer: addAcceptedOffersDetails: priceSpecByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
+            }
+            const itemOfferedByReserve = acceptedOfferByReserveTransaction?.itemOffered;
+            // itemOfferedByReserveは必ず存在するはず
+            if (itemOfferedByReserve === undefined) {
+                console.error('repo:acceptedOffer: addAcceptedOffersDetails: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+            }
+            const nameByReserveTransaction = acceptedOfferByReserveTransaction?.name;
+            const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
+            name: _originalName, // 注文ドキュメントのnameはもう採用しない(2026-06-09~)
+            itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
+            return {
+                ...acceptedOfferWithoutPrice,
+                ...((nameByReserveTransaction !== undefined) && { name: nameByReserveTransaction }), // 予約取引参照の値で上書き(2026-06-09~)
+                ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
+                ...(itemOfferedByReserve !== undefined)
+                    ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き
+                    : { itemOffered }
+            };
+        });
+    }
+}
+exports.AcceptedOfferInReserveRepo = AcceptedOfferInReserveRepo;

package/lib/chevre/repo/accountingReport.js

@@ -48,30 +48,6 @@ class AccountingReportRepo {
                 $match: { 'mainEntity.orderDate': { $lte: orderDateLte } }
             });
         }
-        // discontinue(2026-05-01~)
-        // const reservationForStartDateGte = params.order?.acceptedOffers?.itemOffered?.reservationFor?.startDate?.$gte;
-        // if (reservationForStartDateGte instanceof Date) {
-        //     matchStages.push({
-        //         $match: {
-        //             'mainEntity.acceptedOffers.itemOffered.reservationFor.startDate': {
-        //                 $exists: true,
-        //                 $gte: reservationForStartDateGte
-        //             }
-        //         }
-        //     });
-        // }
-        // discontinue(2026-05-01~)
-        // const reservationForStartDateLte = params.order?.acceptedOffers?.itemOffered?.reservationFor?.startDate?.$lte;
-        // if (reservationForStartDateLte instanceof Date) {
-        //     matchStages.push({
-        //         $match: {
-        //             'mainEntity.acceptedOffers.itemOffered.reservationFor.startDate': {
-        //                 $exists: true,
-        //                 $lte: reservationForStartDateLte
-        //             }
-        //         }
-        //     });
-        // }
         return matchStages;
     }
     async syncMainEntity(params) {
@@ -138,15 +114,14 @@ class AccountingReportRepo {
     }
     async findAccountingReports(params) {
         const { limit, page } = params;
-        const unwindAcceptedOffers = params.$unwindAcceptedOffers === '1';
         const matchStages = AccountingReportRepo.CREATE_MONGO_CONDITIONS(params);
         const aggregate = this.accountingReportModel.aggregate([
+            ...matchStages,
             // pipelineの順序に注意
             // @see https://docs.mongodb.com/manual/reference/operator/aggregation/sort/
             { $sort: { 'mainEntity.orderDate': factory_1.factory.sortType.Descending } },
             { $unwind: '$hasPart' },
-            ...(unwindAcceptedOffers) ? [{ $unwind: '$mainEntity.acceptedOffers' }] : [],
-            ...matchStages,
+            // hasPart内に対する検索条件は存在しないため、unwind後のmatchは不要
             {
                 $project: {
                     _id: 0,
@@ -158,11 +133,8 @@ class AccountingReportRepo {
             }
         ]);
         return aggregate
-            // .limit(limit * page)
-            // .skip(limit * (page - 1))
             .skip(limit * (page - 1))
             .limit(limit)
-            // .setOptions({ maxTimeMS: 10000 })
             .exec();
     }
     async unsetUnnecessaryFields(params) {

package/lib/chevre/repo/action/actionProcess.d.ts

@@ -30,7 +30,7 @@ export type IRecipeAsActionAttributes<T extends factory.recipe.RecipeCategory> =
 export type IMinimizedPurchaseNumberAuthResult = Pick<factory.action.check.paymentMethod.movieTicket.IPurchaseNumberAuthResult, 'mkknmiNumSum' | 'resultInfo' | 'ykknmiNumSum'> & {
     knyknrNoInfoOut: Omit<factory.action.check.paymentMethod.movieTicket.IPurchaseNumberInfo, 'ykknInfo' | 'mkknInfo'>[] | null;
 };
-export type IKeyOfProjection = keyof IAction<factory.actionType> | keyof IAction<factory.actionType.AuthorizeAction> | keyof IAction<factory.actionType.MoneyTransfer> | keyof IAction<factory.actionType.ReplaceAction> | 'identifier';
+export type IKeyOfProjection = keyof IAction<factory.actionType> | keyof IAction<factory.actionType.AuthorizeAction> | keyof IAction<factory.actionType.ReplaceAction> | 'identifier';
 export declare const AVAILABLE_PROJECT_FIELDS: IKeyOfProjection[];
 /**
  * アクション状態管理リポジトリ

package/lib/chevre/repo/assetTransaction/reserve.d.ts

@@ -1,8 +1,7 @@
 import type { Connection } from 'mongoose';
 import { factory } from '../../factory';
 type ISubReservationAsFindResult = Pick<factory.reservation.eventReservation.IReservation, 'underName' | 'id'> & {
-    price?: factory.reservation.eventReservation.IPrice;
-    reservedTicket?: Pick<factory.reservation.eventReservation.IReservedTicket, 'ticketType'>;
+    reservedTicket?: Pick<factory.assetTransaction.reserve.ISubReservationReservedTicket, 'ticketType'>;
     reservationFor?: factory.assetTransaction.reserve.IReservationFor;
 };
 /**