@chevre/domain 25.0.0-alpha.19 → 25.0.0-alpha.20

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

@@ -79,21 +79,18 @@ export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
         onlyPlaceOrder: boolean;
     }): Promise<string>;
     /**
-     * 注文取引からcustomerを参照する
-     * 存在しなければNotFoundError
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
      */
-    findCustomerByIdentifier(params: {
+    findCustomerByOrderIdentifier(params: {
         identifier: string;
-        project: {
-            id: string;
-        };
-    }): Promise<Pick<IOrderInTransaction, 'customer'>>;
+    }): Promise<factory.order.ICustomer>;
     /**
      * 取引進行中の注文からacceptedOffersを検索する
      * 予約取引から予約ごとの価格仕様も参照する
      */
-    findAcceptedOffersWithPriceByOrderNumber(params: {
-        orderNumber: string;
+    findAcceptedOffersWithPriceByIdentifier(params: {
+        identifier: string;
         project: {
             id: string;
         };
@@ -104,20 +101,22 @@ export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
      * 注文を受注する
      * typeOf: PlaceOrder -> typeOf: Order
      */
-    placeOrder(order: IPlacingOrder): Promise<void>;
+    placeOrderByIdentifier(filter: {
+        identifier: string;
+    }, order: IPlacingOrder): Promise<void>;
     /**
      * 注文documentがなければ作成し、受け入れられたオファーを追加する
      * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
      */
-    acceptOffer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project' | 'identifier'> & {
+    acceptOfferByIdentifier(params: Pick<IOrderInTransaction, 'project' | 'identifier'> & {
         acceptedOffers: IMinimizedAcceptedOffer[] | factory.order.ICOAAcceptedOffer[];
     }): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
     /**
      * serialNumberからオファーを除外する
      * ホワイトリストとブラックリスト両方に対応
      */
-    voidAcceptedOfferBySerialNumber(params: {
-        orderNumber: string;
+    voidAcceptedOfferByIdentifier(params: {
+        identifier: string;
         acceptedOffers: {
             serialNumber: {
                 $in?: string[];
@@ -125,20 +124,11 @@ export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
             };
         };
     }): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
-    setCustomer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project' | 'identifier'> & {
+    setCustomerByIdentifier(params: Pick<IOrderInTransaction, 'project' | 'identifier'> & {
         customer: factory.order.ICustomer;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
-    /**
-     * 注文ドキュメントからcustomer属性を参照する
-     * customer未設定であれば、NotFound
-     */
-    findCustomerByOrderNumber(params: {
-        orderNumber: {
-            $eq: string;
-        };
-    }): Promise<factory.order.ICustomer>;
-    deleteByOrderNumber(params: {
-        orderNumber: string;
+    deleteByIdentifier(params: {
+        identifier: string;
     }): Promise<import("mongodb").DeleteResult>;
 }
 export {};

package/lib/chevre/repo/orderInTransaction.js

@@ -68,15 +68,13 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         return doc.orderNumber;
     }
     /**
-     * 注文取引からcustomerを参照する
-     * 存在しなければNotFoundError
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
      */
-    async findCustomerByIdentifier(params) {
-        const { project, identifier } = params;
+    async findCustomerByOrderIdentifier(params) {
         const doc = await this.orderModel.findOne({
-            identifier: { $eq: identifier },
-            typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            'project.id': { $eq: project.id }
+            identifier: { $eq: params.identifier }
+            // typeOf: { $eq: factory.transactionType.PlaceOrder } // 検証しない
         }, {
             _id: 0,
             customer: 1
@@ -86,15 +84,18 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         if (doc === null) {
             throw new factory_1.factory.errors.NotFound('orderInTransaction');
         }
-        return doc;
+        if (typeof doc.customer?.typeOf !== 'string') {
+            throw new factory_1.factory.errors.NotFound('orderInTransaction.customer');
+        }
+        return doc.customer;
     }
     /**
      * 取引進行中の注文からacceptedOffersを検索する
      * 予約取引から予約ごとの価格仕様も参照する
      */
-    async findAcceptedOffersWithPriceByOrderNumber(params) {
+    async findAcceptedOffersWithPriceByIdentifier(params) {
         const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber },
+            identifier: { $eq: params.identifier },
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
         }, { acceptedOffers: 1 })
             .lean()
@@ -136,16 +137,15 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
      * 注文を受注する
      * typeOf: PlaceOrder -> typeOf: Order
      */
-    async placeOrder(order) {
+    async placeOrderByIdentifier(filter, order) {
+        const { identifier } = filter;
         if (!(order.orderDate instanceof Date)) {
             throw new factory_1.factory.errors.Argument('orderDate', 'must be Date');
         }
-        // acceptedOffersを上書きしない
-        // const { acceptedOffers, ...orderWithoutAcceptedOffers } = order;
         const setFields = order;
         // typeOf:PlaceOrderのドキュメントが存在すれば、typeOf:Orderに変更する
         await this.orderModel.updateOne({
-            orderNumber: { $eq: order.orderNumber },
+            identifier: { $eq: identifier },
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
         }, { $set: setFields }, {})
             .exec();
@@ -154,15 +154,13 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
      * 注文documentがなければ作成し、受け入れられたオファーを追加する
      * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
      */
-    async acceptOffer(params) {
+    async acceptOfferByIdentifier(params) {
         if (!Array.isArray(params.acceptedOffers) || params.acceptedOffers.length === 0) {
             return;
         }
-        // const { orderNumber, project, identifier } = params;
-        // await this.createPlaceOrderIfNotExists({ orderNumber, project, identifier }); // 取引開始時に完全移行(2026-06-25~)
         const result = await this.orderModel.updateOne({
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber },
+            identifier: { $eq: params.identifier },
             // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
             // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
             'project.id': { $eq: params.project.id }
@@ -187,13 +185,13 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
      * serialNumberからオファーを除外する
      * ホワイトリストとブラックリスト両方に対応
      */
-    async voidAcceptedOfferBySerialNumber(params) {
+    async voidAcceptedOfferByIdentifier(params) {
         const serialNumberIn = params.acceptedOffers.serialNumber.$in;
         const serialNumberNin = params.acceptedOffers.serialNumber.$nin;
         if (Array.isArray(serialNumberIn) && serialNumberIn.length > 0) {
             return this.orderModel.updateOne({
                 typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-                orderNumber: { $eq: params.orderNumber }
+                identifier: { $eq: params.identifier }
             }, {
                 $pull: {
                     acceptedOffers: {
@@ -206,7 +204,7 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         else if (Array.isArray(serialNumberNin) && serialNumberNin.length > 0) {
             return this.orderModel.updateOne({
                 typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-                orderNumber: { $eq: params.orderNumber }
+                identifier: { $eq: params.identifier }
             }, {
                 $pull: {
                     acceptedOffers: {
@@ -220,16 +218,15 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
             return;
         }
     }
-    async setCustomer(params) {
-        const { customer, orderNumber, project } = params;
+    async setCustomerByIdentifier(params) {
+        const { customer, identifier, project } = params;
         const filter = {
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: orderNumber },
+            identifier: { $eq: identifier },
             // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
             // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
             'project.id': { $eq: project.id }
         };
-        // await this.createPlaceOrderIfNotExists({ orderNumber, project, identifier }); // 取引開始時に完全移行(2026-06-25~)
         const setKeys = { customer };
         const result = await this.orderModel.updateOne(filter, {
             // $setOnInsert: setOnInsert, // createPlaceOrderIfNotExistsへ移行(2026-06-24~)
@@ -244,29 +241,10 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         }
         return result;
     }
-    /**
-     * 注文ドキュメントからcustomer属性を参照する
-     * customer未設定であれば、NotFound
-     */
-    async findCustomerByOrderNumber(params) {
-        const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber.$eq }
-            // typeOf: { $eq: factory.transactionType.PlaceOrder } // 検証しない
-        }, { customer: 1 })
-            .lean()
-            .exec();
-        if (doc === null) {
-            throw new factory_1.factory.errors.NotFound('orderInTransaction');
-        }
-        if (typeof doc.customer?.typeOf !== 'string') {
-            throw new factory_1.factory.errors.NotFound('orderInTransaction.customer');
-        }
-        return doc.customer;
-    }
-    async deleteByOrderNumber(params) {
+    async deleteByIdentifier(params) {
         return this.orderModel.deleteOne({
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber }
+            identifier: { $eq: params.identifier }
         })
             .exec();
     }

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

@@ -6,7 +6,6 @@ interface IAcceptOfferOperationRepos {
 type IAcceptOfferOperation<T> = (repos: IAcceptOfferOperationRepos) => Promise<T>;
 export type IAuthorizeActionWithInstrument = Pick<factory.action.authorize.offer.eventService.IAction, 'instrument'>;
 export declare function acceptOffer(params: {
-    orderNumber: string;
     project: {
         id: string;
     };
@@ -21,7 +20,7 @@ export declare function voidAcceptedOffer(params: {
      * instrument.serialNumberからvoidする場合に指定
      */
     authorizeActionsWithInstrument: IAuthorizeActionWithInstrument[];
-    orderNumber: string;
+    placeOrderId: string;
 }): (repos: {
     orderInTransaction: OrderInTransactionRepo;
 }) => Promise<void>;

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

@@ -10,8 +10,7 @@ const factory_1 = require("../../factory");
 const debug = (0, debug_1.default)('chevre-domain:service:offer');
 function acceptOffer(params) {
     return async (repos) => {
-        await repos.orderInTransaction.acceptOffer({
-            orderNumber: params.orderNumber,
+        await repos.orderInTransaction.acceptOfferByIdentifier({
             project: { id: params.project.id, typeOf: factory_1.factory.organizationType.Project },
             identifier: params.placeOrderId,
             acceptedOffers: params.acceptedOffers
@@ -20,7 +19,7 @@ function acceptOffer(params) {
 }
 function voidAcceptedOffer(params) {
     return async (repos) => {
-        const { orderNumber } = params;
+        const { placeOrderId } = params;
         // let reservationNumbers: string[] = [];
         // authorizeActions.forEach((authorizeAction) => {
         //     const reserveTransactionNumberByAction = authorizeAction.object.pendingTransaction?.transactionNumber;
@@ -41,10 +40,11 @@ function voidAcceptedOffer(params) {
             const serialNumbers = params.authorizeActionsWithInstrument
                 .filter(({ instrument }) => typeof instrument.transactionNumber === 'string')
                 .map(({ instrument }) => String(instrument.transactionNumber));
-            debug('removing acceptedOffers from PlaceOrder...', orderNumber, 'serialNumbers:', serialNumbers);
+            debug('removing acceptedOffers from PlaceOrder...', placeOrderId, 'serialNumbers:', serialNumbers);
             if (serialNumbers.length > 0) {
-                const result = await repos.orderInTransaction.voidAcceptedOfferBySerialNumber({
-                    orderNumber,
+                const result = await repos.orderInTransaction.voidAcceptedOfferByIdentifier({
+                    // orderNumber,
+                    identifier: placeOrderId,
                     acceptedOffers: { serialNumber: { $in: serialNumbers } }
                 });
                 debug('acceptedOffers removed from PlaceOrder by serialNumbers.', result);

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

@@ -63,7 +63,6 @@ function authorize(params, options) {
                     };
                 });
                 await (0, any_1.acceptOffer)({
-                    orderNumber,
                     project: transaction.project,
                     placeOrderId: transaction.id,
                     acceptedOffers: minimizedAcceptedOffers

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

@@ -48,23 +48,35 @@ function voidTransaction(params) {
             default:
             // no op
         }
-        // add orderInTransaction(2024-01-15~)
-        // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
-        const orderNumberByTransaction = transaction.object.orderNumber;
-        if (typeof orderNumberByTransaction === 'string') {
-            switch (transaction.status) {
-                case factory_1.factory.transactionStatusType.Confirmed:
-                    // 確定取引の場合、不要なオファーのみ除外
-                    await (0, any_1.voidAcceptedOffer)({
-                        // authorizeActions,
-                        authorizeActionsWithInstrument: authorizeActions,
-                        orderNumber: orderNumberByTransaction
-                    })(repos);
-                    break;
-                default:
-                    // orderInTransaction自体を削除
-                    await repos.orderInTransaction.deleteByOrderNumber({ orderNumber: orderNumberByTransaction });
-            }
+        // // add orderInTransaction(2024-01-15~)
+        // // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
+        // const orderNumberByTransaction = transaction.object.orderNumber;
+        // if (typeof orderNumberByTransaction === 'string') {
+        //     switch (transaction.status) {
+        //         case factory.transactionStatusType.Confirmed:
+        //             // 確定取引の場合、不要なオファーのみ除外
+        //             await voidAcceptedOffer({
+        //                 // authorizeActions,
+        //                 authorizeActionsWithInstrument: authorizeActions,
+        //                 orderNumber: orderNumberByTransaction
+        //             })(repos);
+        //             break;
+        //         default:
+        //             // orderInTransaction自体を削除
+        //             await repos.orderInTransaction.deleteByOrderNumber({ orderNumber: orderNumberByTransaction });
+        //     }
+        // }
+        switch (transaction.status) {
+            case factory_1.factory.transactionStatusType.Confirmed:
+                // 確定取引の場合、不要なオファーのみ除外
+                await (0, any_1.voidAcceptedOffer)({
+                    authorizeActionsWithInstrument: authorizeActions,
+                    placeOrderId: params.purpose.id
+                })(repos);
+                break;
+            default:
+                // orderInTransaction自体を削除
+                await repos.orderInTransaction.deleteByIdentifier({ identifier: params.purpose.id });
         }
         await Promise.all(authorizeActions.map(async (action) => {
             await repos.authorizeOfferAction.cancelWithVoid({ typeOf: action.typeOf, id: action.id, cancelAction });

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

@@ -26,7 +26,7 @@ function voidTransactionByActionId(params) {
         // if (transaction.agent.id !== params.agent.id) {
         //     throw new factory.errors.Forbidden('Transaction not yours');
         // }
-        const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.purpose.id });
+        // const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.purpose.id });
         const action = await repos.authorizeOfferAction.findById({ typeOf: factory_1.factory.actionType.AuthorizeAction, id: params.id });
         if (action.purpose.typeOf !== transaction.typeOf || action.purpose.id !== transaction.id) {
             throw new factory_1.factory.errors.Argument('Transaction', 'Action not found in the transaction');
@@ -34,17 +34,21 @@ function voidTransactionByActionId(params) {
         // MongoDBでcompleteステータスであるにも関わらず、Chevreでは削除されている、というのが最悪の状況
         // それだけは回避するためにMongoDBを先に変更
         await repos.authorizeOfferAction.cancelWithVoid({ typeOf: factory_1.factory.actionType.AuthorizeAction, id: params.id, cancelAction });
-        // add orderInTransaction(2024-01-15~)
-        // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
-        // const orderNumberByTransaction = transaction.object.orderNumber;
-        const orderNumberByTransaction = orderNumber; // transaction.objectへのアクセス回避(2024-05-30~)
-        if (typeof orderNumberByTransaction === 'string') {
-            await (0, any_1.voidAcceptedOffer)({
-                // authorizeActions: [action],
-                authorizeActionsWithInstrument: [action],
-                orderNumber: orderNumberByTransaction
-            })(repos);
-        }
+        // // add orderInTransaction(2024-01-15~)
+        // // USE_CREATE_ORDER_ON_OFFER_ACCEPTEDの場合、orderNumber発行済のはず
+        // // const orderNumberByTransaction = transaction.object.orderNumber;
+        // const orderNumberByTransaction = orderNumber; // transaction.objectへのアクセス回避(2024-05-30~)
+        // if (typeof orderNumberByTransaction === 'string') {
+        //     await voidAcceptedOffer({
+        //         // authorizeActions: [action],
+        //         authorizeActionsWithInstrument: [action],
+        //         orderNumber: orderNumberByTransaction
+        //     })(repos);
+        // }
+        await (0, any_1.voidAcceptedOffer)({
+            authorizeActionsWithInstrument: [action],
+            placeOrderId: params.purpose.id
+        })(repos);
         switch (action.instrument.typeOf) {
             case factory_1.factory.assetTransactionType.COAReserveTransaction: {
                 const { reserveService } = repos;

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

@@ -123,11 +123,11 @@ function reAcceptOffer(params) {
             typeOf: factory_1.factory.transactionType.PlaceOrder,
             id: params.purpose.id
         }, ['project', 'agent', 'typeOf']);
-        const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: transaction.id });
-        if (typeof orderNumber !== 'string') {
-            // 事前に発行されているはず
-            throw new factory_1.factory.errors.NotFound('transaction.object.orderNumber');
-        }
+        // const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: transaction.id });
+        // if (typeof orderNumber !== 'string') {
+        //     // 事前に発行されているはず
+        //     throw new factory.errors.NotFound('transaction.object.orderNumber');
+        // }
         const coaInfo = await findCOAInfo({ id: params.object.event.id, project: { id: transaction.project.id } })(repos);
         // 承認アクション存在検証
         await repos.authorizeOfferAction.findById({ id: params.potentialActions.id, typeOf: factory_1.factory.actionType.AuthorizeAction }, ['id'], []);

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

@@ -80,11 +80,11 @@ function authorize(params) {
             await repos.action.giveUp({ typeOf: failedAction.typeOf, id: failedAction.id, error });
             throw error;
         }
-        const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.transaction.id });
-        if (typeof orderNumber !== 'string') {
-            // 事前に発行されているはず(acceptCOAOfferにて)
-            throw new factory_2.factory.errors.NotFound('transaction.object.orderNumber');
-        }
+        // const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.transaction.id });
+        // if (typeof orderNumber !== 'string') {
+        //     // 事前に発行されているはず(acceptCOAOfferにて)
+        //     throw new factory.errors.NotFound('transaction.object.orderNumber');
+        // }
         let result;
         // 承認アクションを開始
         const actionAttributes = (0, factory_1.createAuthorizeSeatReservationActionAttributes)({
@@ -117,7 +117,6 @@ function authorize(params) {
             // add orderInTransaction(2024-01-15~)
             // if (params.options.useCreateOrderOnOfferAccepted) {
             await (0, any_1.acceptOffer)({
-                orderNumber,
                 project: transaction.project,
                 placeOrderId: params.transaction.id,
                 acceptedOffers: acceptedOffers4result

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

@@ -22,11 +22,11 @@ function changeOffers(params) {
         if (transaction.agent.id !== params.agent.id) {
             throw new factory_2.factory.errors.Forbidden('Transaction not yours');
         }
-        const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.transaction.id });
-        if (typeof orderNumber !== 'string') {
-            // 事前に発行されているはず
-            throw new factory_2.factory.errors.NotFound('transaction.object.orderNumber');
-        }
+        // const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.transaction.id });
+        // if (typeof orderNumber !== 'string') {
+        //     // 事前に発行されているはず
+        //     throw new factory.errors.NotFound('transaction.object.orderNumber');
+        // }
         // 取引内のアクションかどうか確認
         const authorizeAction = await repos.action.findById({ typeOf: factory_2.factory.actionType.AuthorizeAction, id: params.id });
         if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
@@ -139,20 +139,23 @@ function changeOffers(params) {
         // ActiveActionStatus->CompletedActionStatusで再実装(2024-01-15~)
         await repos.action.reStart({ id: authorizeAction.id, typeOf: authorizeAction.typeOf });
         try {
-            // まずvoidAcceptedOffer
-            // const orderNumberByTransaction = transaction.object.orderNumber;
-            const orderNumberByTransaction = orderNumber; // transaction.objectへのアクセス回避(2024-05-30~)
-            if (typeof orderNumberByTransaction === 'string') {
-                await (0, any_1.voidAcceptedOffer)({
-                    // authorizeActions: [authorizeAction],
-                    authorizeActionsWithInstrument: [authorizeAction],
-                    orderNumber: orderNumberByTransaction
-                })(repos);
-            }
+            // // まずvoidAcceptedOffer
+            // // const orderNumberByTransaction = transaction.object.orderNumber;
+            // const orderNumberByTransaction = orderNumber; // transaction.objectへのアクセス回避(2024-05-30~)
+            // if (typeof orderNumberByTransaction === 'string') {
+            //     await voidAcceptedOffer({
+            //         // authorizeActions: [authorizeAction],
+            //         authorizeActionsWithInstrument: [authorizeAction],
+            //         orderNumber: orderNumberByTransaction
+            //     })(repos);
+            // }
+            await (0, any_1.voidAcceptedOffer)({
+                authorizeActionsWithInstrument: [authorizeAction],
+                placeOrderId: params.transaction.id
+            })(repos);
             // add orderInTransaction(2024-01-15~)
             // if (params.options.useCreateOrderOnOfferAccepted) {
             await (0, any_1.acceptOffer)({
-                orderNumber,
                 project: transaction.project,
                 placeOrderId: params.transaction.id,
                 acceptedOffers: acceptedOffers4result

package/lib/chevre/service/order/placeOrder/createPlacingOrderFromExistingTransaction.js

@@ -89,8 +89,9 @@ function createPlacingOrderFromExistingTransaction(params) {
             .map(({ instrument }) => String(instrument.transactionNumber));
         try {
             // すでにtypeOf: Orderに変更済の場合acceptedOffersは空になるが、そもそもorderedItemはその後上書きされないので、空のまま処理して問題なし
-            acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByOrderNumber({
-                orderNumber,
+            acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByIdentifier({
+                // orderNumber,
+                identifier: placeOrderTransactionWithResult.id,
                 project: { id: params.project.id }
             }))
                 .filter(({ serialNumber }) => typeof serialNumber === 'string' && serialNumbers.includes(serialNumber));

package/lib/chevre/service/order/placeOrder/voidAcceptedOfferIfNecessary.d.ts

@@ -1,8 +1,6 @@
 import type { OrderInTransactionRepo } from '../../../repo/orderInTransaction';
 declare function voidAcceptedOfferIfNecessary(params: {
-    object: {
-        orderNumber: string;
-    };
+    placeOrderId: string;
     serialNumbers: string[];
 }): (repos: {
     orderInTransaction: OrderInTransactionRepo;

package/lib/chevre/service/order/placeOrder/voidAcceptedOfferIfNecessary.js

@@ -1,27 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.voidAcceptedOfferIfNecessary = voidAcceptedOfferIfNecessary;
-const debug_1 = __importDefault(require("debug"));
-// import type { TransactionRepo } from '../../../repo/transaction';
-// import { factory } from '../../../factory';
-const debug = (0, debug_1.default)('chevre-domain:service:order');
-// type IPlaceOrderTransaction = Pick<
-//     factory.transaction.placeOrder.ITransaction,
-//     'id' | 'project' | 'typeOf' | 'result' | 'object' | 'seller'
-// >;
 function voidAcceptedOfferIfNecessary(params) {
     return async (repos) => {
         if (Array.isArray(params.serialNumbers) && params.serialNumbers.length > 0) {
             // 取引に保管された承認アクション以外のアクションについて、オファーを除外する
-            debug('voidAcceptedOfferBySerialNumber processing...', params.object.orderNumber, 'serialNumbersMustBeIn:', params.serialNumbers);
-            const voidAcceptedOfferBySerialNumberResult = await repos.orderInTransaction.voidAcceptedOfferBySerialNumber({
-                orderNumber: params.object.orderNumber,
+            // const voidAcceptedOfferBySerialNumberResult =
+            await repos.orderInTransaction.voidAcceptedOfferByIdentifier({
+                identifier: params.placeOrderId,
                 acceptedOffers: { serialNumber: { $nin: params.serialNumbers } }
             });
-            debug('voidAcceptedOfferBySerialNumber processed.', params.object.orderNumber, 'voidAcceptedOfferBySerialNumberResult:', voidAcceptedOfferBySerialNumberResult);
         }
     };
 }

package/lib/chevre/service/order/placeOrder.js

@@ -61,11 +61,11 @@ function placeOrder(params) {
             try {
                 // 冗長なオファーを除外する(念のため)
                 await (0, voidAcceptedOfferIfNecessary_1.voidAcceptedOfferIfNecessary)({
-                    object: { orderNumber: order.orderNumber },
-                    // purpose: placeOrderTransaction,
+                    // object: { orderNumber: order.orderNumber },
+                    placeOrderId: placeOrderTransaction.id,
                     serialNumbers
                 })(repos);
-                await repos.orderInTransaction.placeOrder(order);
+                await repos.orderInTransaction.placeOrderByIdentifier({ identifier: placeOrderTransaction.id }, order);
             }
             catch (error) {
                 try {

package/lib/chevre/service/transaction/placeOrder/confirm.d.ts

@@ -39,10 +39,6 @@ interface IConfirmOptions {
      * 注文における最大CreditCardIF決済方法数
      */
     maxNumCreditCardPaymentMethod: number;
-    /**
-     * 取引ドキュメントのresult.order,result,numAcceptedOffersを保管しないオプション(2026-06-15~)
-     */
-    disableResultOrder: boolean;
 }
 type IConfirmParams = PlaceOrderFactory.IConfirmParams;
 interface IConfirmResult {

package/lib/chevre/service/transaction/placeOrder/confirm.js

@@ -23,8 +23,8 @@ function processTransactionNotInProgress(params) {
     return async (repos) => {
         const { transaction, orderNumber } = params;
         if (transaction.status === factory_1.factory.transactionStatusType.Confirmed) {
-            const resultCustomer = await repos.orderInTransaction.findCustomerByOrderNumber({
-                orderNumber: { $eq: orderNumber }
+            const resultCustomer = await repos.orderInTransaction.findCustomerByOrderIdentifier({
+                identifier: transaction.id
             });
             // if (resultCustomer === undefined) {
             //     throw new factory.errors.Internal('resultCustomer undefined'); // impossible process
@@ -108,8 +108,9 @@ function confirm(params, options) {
         // authorizeProductOfferActions,
         serialNumbers } = dissolveAuthorizeActions(completedAuthorizeActions);
         // orderInTransactionから検索する(2024-03-04~)
-        const acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByOrderNumber({
-            orderNumber,
+        const acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByIdentifier({
+            // orderNumber,
+            identifier: transaction.id,
             project: { id: transaction.project.id }
         }))
             .filter(({ serialNumber }) => typeof serialNumber === 'string' && serialNumbers.includes(serialNumber));
@@ -126,7 +127,7 @@ function confirm(params, options) {
         }
         // retrieve customer from orderInTransaction(2024-06-24~)
         // let customer: factory.order.ICustomer = createCustomer({ transaction });
-        const customer = await repos.orderInTransaction.findCustomerByOrderNumber({ orderNumber: { $eq: orderNumber } });
+        const customer = await repos.orderInTransaction.findCustomerByOrderIdentifier({ identifier: transaction.id });
         const seller = (0, factory_2.createSeller)({ transaction });
         const { paymentMethods, placingOrder, result, eventId, reservationIds } = createResult({
             ...params,

package/lib/chevre/service/transaction/placeOrder/issueOrderNumberIfNotExist.js

@@ -8,15 +8,6 @@ const factory_1 = require("../../../factory");
  */
 function issueOrderNumberIfNotExist(params) {
     return async (repos) => {
-        // // issueForceオプションあるいは、廃止予定の発行オプションの場合、注文番号を新たに発行する
-        // const issueOrderNumber = options?.issueForce === true || USE_LEGACY_ISSUE_ORDER_NUMBER;
-        // if (!issueOrderNumber) {
-        //     // 注文ドキュメントを参照(2026-06-24~)
-        //     return repos.orderInTransaction.findOrderNumberByIdentifier({
-        //         identifier: params.id,
-        //         project: { id: params.project.id }
-        //     })
-        // }
         // 1. 最初のチェック
         let orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.id });
         // すでに発行済であれば何もしない

package/lib/chevre/service/transaction/placeOrder/updateAgent.js

@@ -28,9 +28,9 @@ function fixCustomer(params) {
         let customer;
         if (transaction.typeOf === factory_1.factory.transactionType.PlaceOrder) {
             // orderInTransaction.customer?.typeOfは取引開始時にセットされている前提で再実装(2026-06-24~)
-            const { customer: customerByTransaction } = await repos.orderInTransaction.findCustomerByIdentifier({
+            const customerByTransaction = await repos.orderInTransaction.findCustomerByOrderIdentifier({
                 identifier: params.id,
-                project: { id: transaction.project.id }
+                // project: { id: transaction.project.id }
             });
             // // いったんtransaction.object.customer?.typeOfは取引開始時にセットされている前提
             // const customerByTransaction = transaction.object.customer;
@@ -73,11 +73,11 @@ function updateAgent(params) {
         const { customer, transaction } = await fixCustomer(params)(repos);
         // also save in orderInTransaction(2024-06-20~)
         if (customer !== undefined) {
-            // 注文ドキュメントを参照(2026-06-24~)
-            const orderNumber = await repos.orderInTransaction.findOrderNumberByIdentifier({
-                identifier: params.id,
-                project: { id: transaction.project.id },
-            }, { onlyPlaceOrder: true });
+            // // 注文ドキュメントを参照(2026-06-24~)
+            // const orderNumber = await repos.orderInTransaction.findOrderNumberByIdentifier({
+            //     identifier: params.id,
+            //     project: { id: transaction.project.id },
+            // }, { onlyPlaceOrder: true });
             const customerName = (typeof customer.name === 'string' && customer.name !== '')
                 ? customer.name
                 : (typeof customer.givenName === 'string' && typeof customer.familyName === 'string'
@@ -89,8 +89,7 @@ function updateAgent(params) {
                 identifier: (Array.isArray(customer.identifier)) ? customer.identifier : [],
                 ...(typeof customerName === 'string') ? { name: customerName } : undefined
             };
-            await repos.orderInTransaction.setCustomer({
-                orderNumber,
+            await repos.orderInTransaction.setCustomerByIdentifier({
                 project: transaction.project,
                 identifier: params.id,
                 customer: customerInOrder

package/package.json

@@ -91,5 +91,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "25.0.0-alpha.19"
+  "version": "25.0.0-alpha.20"
 }