@chevre/domain 25.0.0-alpha.2 → 25.0.0-alpha.21

package/lib/chevre/service/transaction/deleteTransaction.d.ts

@@ -3,35 +3,29 @@ import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
 import type { AccountingReportRepo } from '../../repo/accountingReport';
 import type { ActionRepo } from '../../repo/action';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
-import type { EventRepo } from '../../repo/event';
 import type { MessageRepo } from '../../repo/message';
 import type { NoteRepo } from '../../repo/note';
 import type { OrderRepo } from '../../repo/order';
-import type { OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { ReservationRepo } from '../../repo/reservation';
-import type { SettingRepo } from '../../repo/setting';
-import type { TaskRepo } from '../../repo/task';
 import type { TransactionRepo } from '../../repo/transaction';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import type { ReturnOrderRepo } from '../../repo/transaction/returnOrder';
-/**
- * 取引に関わるリソースを削除する
- * 冪等性を確保すること
- */
-export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: {
+interface IDeleteTransactionRepos {
     acceptedOffer: AcceptedOfferRepo;
     accountingReport: AccountingReportRepo;
     action: ActionRepo;
     assetTransaction: AssetTransactionRepo;
-    event: EventRepo;
     message: MessageRepo;
     note: NoteRepo;
     order: OrderRepo;
-    ownershipInfo: OwnershipInfoRepo;
     reservation: ReservationRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
     transaction: TransactionRepo;
     placeOrder: PlaceOrderRepo;
     returnOrder: ReturnOrderRepo;
-}) => Promise<void>;
+}
+/**
+ * 取引に関わるリソースを削除する
+ * 冪等性を確保すること
+ */
+export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: IDeleteTransactionRepos) => Promise<void>;
+export {};

package/lib/chevre/service/transaction/deleteTransaction.js

@@ -11,118 +11,15 @@ const deleteOrder_1 = require("../order/deleteOrder");
 function deleteTransaction(params) {
     return async (repos) => {
         if (params.object.specifyingMethod === factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId) {
-            // transaction.agent.id指定による取引削除に対応(2023-06-30~)
-            await createDeleteTransactionTasksByAgentId(params)(repos);
+            throw new factory_1.factory.errors.NotImplemented('deleteTransaction by agentId discontinued'); // discontinue(2026-06-28~)
+            // // transaction.agent.id指定による取引削除に対応(2023-06-30~)
+            // await createDeleteTransactionTasksByAgentId(params)(repos);
         }
         else {
             await deleteTransactionById(params)(repos);
         }
     };
 }
-function createDeleteTransactionTasksByAgentId(params) {
-    return async (repos) => {
-        if (params.object.specifyingMethod !== factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId) {
-            throw new factory_1.factory.errors.Argument('object.specifyingMethod', `must be ${factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId}`);
-        }
-        const agentIdSpecified = params.object.agent.id;
-        // agentIdによる全取引についてDeleteTransactionタスクを作成する
-        if (typeof agentIdSpecified === 'string' && agentIdSpecified.length > 0) {
-            const transactionTypeOf = params.object.typeOf;
-            let transactions;
-            if (transactionTypeOf === factory_1.factory.transactionType.PlaceOrder) {
-                transactions = await repos.placeOrder.findPlaceOrderTransactions({
-                    project: { id: { $eq: params.object.project.id } },
-                    agent: {
-                        ids: [agentIdSpecified],
-                        typeOf: factory_1.factory.personType.Person
-                    },
-                    typeOf: transactionTypeOf,
-                    inclusion: ['typeOf', 'startDate', 'endDate', 'object', 'project']
-                });
-            }
-            else if (transactionTypeOf === factory_1.factory.transactionType.ReturnOrder) {
-                transactions = await repos.returnOrder.findReturnOrderTransactions({
-                    project: { id: { $eq: params.object.project.id } },
-                    agent: {
-                        ids: [agentIdSpecified],
-                        typeOf: factory_1.factory.personType.Person
-                    },
-                    typeOf: transactionTypeOf,
-                    inclusion: ['typeOf', 'startDate', 'endDate', 'object', 'project']
-                });
-            }
-            else {
-                throw new factory_1.factory.errors.NotImplemented(`${transactionTypeOf} not implemented`);
-            }
-            const deleteAt = new Date();
-            let deleteTransactionTasks;
-            switch (transactionTypeOf) {
-                case factory_1.factory.transactionType.PlaceOrder:
-                    deleteTransactionTasks = transactions.map((transaction) => {
-                        return {
-                            project: transaction.project,
-                            name: factory_1.factory.taskName.DeleteTransaction,
-                            status: factory_1.factory.taskStatus.Ready,
-                            runsAt: deleteAt,
-                            remainingNumberOfTries: 3,
-                            numberOfTried: 0,
-                            executionResults: [],
-                            data: {
-                                object: {
-                                    specifyingMethod: factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id,
-                                    id: transaction.id,
-                                    object: {
-                                        ...(typeof transaction.object.confirmationNumber === 'string')
-                                            ? { confirmationNumber: transaction.object.confirmationNumber }
-                                            : undefined,
-                                        ...(typeof transaction.object.orderNumber === 'string')
-                                            ? { orderNumber: transaction.object.orderNumber }
-                                            : undefined
-                                    },
-                                    project: transaction.project,
-                                    startDate: transaction.startDate,
-                                    typeOf: transaction.typeOf,
-                                    ...(transaction.endDate !== undefined) ? { endDate: transaction.endDate } : undefined
-                                }
-                            }
-                        };
-                    });
-                    break;
-                case factory_1.factory.transactionType.ReturnOrder:
-                    deleteTransactionTasks = transactions.map((transaction) => {
-                        return {
-                            project: transaction.project,
-                            name: factory_1.factory.taskName.DeleteTransaction,
-                            status: factory_1.factory.taskStatus.Ready,
-                            runsAt: deleteAt,
-                            remainingNumberOfTries: 3,
-                            numberOfTried: 0,
-                            executionResults: [],
-                            data: {
-                                object: {
-                                    specifyingMethod: factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id,
-                                    id: transaction.id,
-                                    object: {
-                                        order: transaction.object.order
-                                    },
-                                    project: transaction.project,
-                                    startDate: transaction.startDate,
-                                    typeOf: transaction.typeOf,
-                                    ...(transaction.endDate !== undefined) ? { endDate: transaction.endDate } : undefined
-                                }
-                            }
-                        };
-                    });
-                    break;
-                default:
-                    throw new factory_1.factory.errors.NotImplemented(`${transactionTypeOf} not implemented`);
-            }
-            if (deleteTransactionTasks.length > 0) {
-                await repos.task.saveMany(deleteTransactionTasks, { emitImmediately: true });
-            }
-        }
-    };
-}
 function deleteTransactionById(params) {
     return async (repos) => {
         if (typeof params.object.specifyingMethod === 'string'
@@ -133,7 +30,7 @@ function deleteTransactionById(params) {
         if (typeof deletingTransactionId !== 'string' || deletingTransactionId.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('object.id');
         }
-        let deletingOrderNumberByTask;
+        // let deletingOrderNumberByTask: string | undefined;
         let transaction;
         if (params.object.typeOf === factory_1.factory.transactionType.PlaceOrder) {
             transaction = (await repos.placeOrder.findPlaceOrderTransactions({
@@ -141,7 +38,7 @@ function deleteTransactionById(params) {
                 typeOf: params.object.typeOf,
                 inclusion: ['typeOf', 'project', 'status']
             })).shift();
-            deletingOrderNumberByTask = params.object.object.orderNumber;
+            // deletingOrderNumberByTask = params.object.object.orderNumber;
         }
         else if (params.object.typeOf === factory_1.factory.transactionType.ReturnOrder) {
             transaction = (await repos.returnOrder.findReturnOrderTransactions({
@@ -191,18 +88,15 @@ function deleteTransactionById(params) {
                         case factory_1.factory.transactionStatusType.Expired:
                             break;
                         case factory_1.factory.transactionStatusType.Confirmed: {
-                            // 削除対象の注文番号についてはタスクを参照する(2026-06-15~)
-                            // const deletingOrder = transaction.result?.order;
-                            // if (typeof deletingOrder?.orderNumber === 'string') {
+                            // identifierによる削除に変更(2026-06-28~)
+                            // if (typeof deletingOrderNumberByTask === 'string') {
                             //     await deleteOrder({
-                            //         object: deletingOrder
+                            //         object: { orderNumber: deletingOrderNumberByTask }
                             //     })(repos);
                             // }
-                            if (typeof deletingOrderNumberByTask === 'string') {
-                                await (0, deleteOrder_1.deleteOrder)({
-                                    object: { orderNumber: deletingOrderNumberByTask }
-                                })(repos);
-                            }
+                            await (0, deleteOrder_1.deleteOrder)({
+                                object: { identifier: transaction.id }
+                            })(repos);
                             break;
                         }
                         default:

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

@@ -1,4 +1,9 @@
 import { factory } from '../../../../../factory';
+type IOrderAsResult = Pick<factory.order.IOrder, 'confirmationNumber' | 'orderDate' | 'orderNumber' | 'price' | 'priceCurrency' | 'typeOf'> & {
+    orderStatus: factory.orderStatus.OrderPaymentDue;
+    identifier?: never;
+    url?: never;
+};
 /**
  * 注文取引結果としての注文を生成する
  */
@@ -6,5 +11,5 @@ declare function createOrderAsResult(params: {
     orderNumber: string;
     orderDate: Date;
     price: number;
-}): factory.transaction.placeOrder.IOrderAsResult;
-export { createOrderAsResult };
+}): IOrderAsResult;
+export { createOrderAsResult, IOrderAsResult };

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

@@ -1,7 +1,8 @@
 import { factory } from '../../../../../factory';
 import type { ISetting } from '../../../../../repo/setting';
+import type { IOrderAsResult } from '../factory/result';
 export declare function createSendEmailMessageActions(params: {
-    order: factory.transaction.placeOrder.IOrderAsResult & {
+    order: IOrderAsResult & {
         confirmationNumber: string;
         orderStatus: factory.orderStatus;
         price: number;
@@ -9,10 +10,9 @@ export declare function createSendEmailMessageActions(params: {
         typeOf: factory.order.OrderType;
     };
     customer: factory.order.ICustomer;
-    seller: factory.order.ISeller;
+    seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
     potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
-    emailMessage?: factory.creativeWork.message.email.ICreativeWork;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
     emailMessages: factory.action.transfer.send.message.email.IObjectAsEmailMessage[];
     sendEmailMessageActions: factory.transaction.placeOrder.IPotentialSendEmailMessageAction[];

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

@@ -3,34 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSendEmailMessageActions = createSendEmailMessageActions;
 const emailMessageBuilder_1 = require("../../../../../emailMessageBuilder");
 const factory_1 = require("../../../../../factory");
-async function createSendEmailMessageActions(params, 
-// settings: Settings
-setting) {
+async function createSendEmailMessageActions(params, setting) {
     // 注文配送メール送信設定
     const emailMessages = [];
-    // const sendEmailMessageActions: factory.action.transfer.send.message.email.IAttributes[] = [];
     const sendEmailMessageActions = [];
-    // const sendActionPurpose: factory.action.transfer.send.message.email.IPurpose = {
-    //     typeOf: params.order.typeOf,
-    //     orderNumber: params.order.orderNumber,
-    //     price: params.order.price,
-    //     priceCurrency: params.order.priceCurrency,
-    //     orderDate: params.order.orderDate
-    // };
     const sendEmailMessageOnOrderSentParams = params.potentialActions?.order?.potentialActions?.sendOrder?.potentialActions?.sendEmailMessage;
     if (Array.isArray(sendEmailMessageOnOrderSentParams)) {
+        // pugテンプレートに渡す変数を最小化(2026-06-19~)
         const orderAsCreateEmailParams = {
-            ...params.order,
+            // ...params.order,
+            // paymentMethods: params.paymentMethods
             customer: params.customer,
             seller: params.seller,
-            paymentMethods: params.paymentMethods
+            orderNumber: params.order.orderNumber,
+            confirmationNumber: params.order.confirmationNumber,
+            price: params.order.price
         };
         await Promise.all(sendEmailMessageOnOrderSentParams.map(async (s, index) => {
             const emailMessage = await (0, emailMessageBuilder_1.createSendOrderMessage)({
                 order: orderAsCreateEmailParams,
                 index,
                 ...(s.object !== undefined) ? { email: s.object } : undefined,
-                ...(params.emailMessage !== undefined) ? { emailMessage: params.emailMessage } : undefined
+                // ...(params.emailMessage !== undefined) ? { emailMessage: params.emailMessage } : undefined
             }, setting);
             emailMessages.push(emailMessage);
             // 送信アクション最適化に対応(2024-04-29~)
@@ -40,16 +34,7 @@ setting) {
             };
             // optimize(2024-05-07~)
             sendEmailMessageActions.push({
-                // project: params.order.project,
-                // typeOf: factory.actionType.SendAction,
                 object: sendEmailMessageActionObject
-                // agent: params.order.project,
-                // recipient: {
-                //     typeOf: params.order.customer.typeOf,
-                //     id: params.order.customer.id
-                // },
-                // potentialActions: {},
-                // purpose: sendActionPurpose
             });
         }));
     }

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

@@ -1,10 +1,11 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
+import { IOrderAsResult } from './factory/result';
 /**
  * 取引のポストアクションを作成する
  */
 export declare function createPotentialActions(params: {
-    order: factory.transaction.placeOrder.IOrderAsResult & {
+    order: IOrderAsResult & {
         confirmationNumber: string;
         orderStatus: factory.orderStatus.OrderPaymentDue;
         price: number;
@@ -12,10 +13,9 @@ export declare function createPotentialActions(params: {
         typeOf: factory.order.OrderType;
     };
     customer: factory.order.ICustomer;
-    seller: factory.order.ISeller;
+    seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
     potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
-    emailMessage?: factory.creativeWork.message.email.ICreativeWork;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
     potentialActions: factory.transaction.placeOrder.IPotentialActions;
     emailMessages: factory.creativeWork.message.email.ICreativeWork[];

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

@@ -5,14 +5,9 @@ const sendEmailMessage_1 = require("./potentialActions/sendEmailMessage");
 /**
  * 取引のポストアクションを作成する
  */
-async function createPotentialActions(params, 
-// settings: Settings
-setting) {
+async function createPotentialActions(params, setting) {
     // 注文処理開始メール送信設定
     const { emailMessages, sendEmailMessageActions } = await (0, sendEmailMessage_1.createSendEmailMessageActions)(params, setting);
-    // const sendOrderActionAttributes: factory.transaction.placeOrder.IPotentialSendOrderAction = {
-    //     potentialActions: { sendEmailMessage: sendEmailMessageActions }
-    // };
     return {
         emailMessages,
         potentialActions: {

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

@@ -4,7 +4,6 @@ import type { AuthorizeOfferActionRepo } from '../../../repo/action/authorizeOff
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { AuthorizationRepo } from '../../../repo/authorization';
 import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
-import type { EmailMessageRepo } from '../../../repo/emailMessage';
 import type { MessageRepo } from '../../../repo/message';
 import type { OrderInTransactionRepo } from '../../../repo/orderInTransaction';
 import type { ProjectRepo } from '../../../repo/project';
@@ -12,13 +11,13 @@ import type { SettingRepo } from '../../../repo/setting';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import { factory } from '../../../factory';
 import { PlaceOrderFactory } from '../../../factory/transaction';
+import { IOrderAsResult } from './confirm/factory/result';
 interface IConfirmOperationRepos {
     acceptPayAction: AcceptPayActionRepo;
     authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     authorizeOfferAction: AuthorizeOfferActionRepo;
     assetTransaction: AssetTransactionRepo;
     authorization: AuthorizationRepo;
-    emailMessage?: EmailMessageRepo;
     message: MessageRepo;
     project: ProjectRepo;
     placeOrder: PlaceOrderRepo;
@@ -40,14 +39,10 @@ interface IConfirmOptions {
      * 注文における最大CreditCardIF決済方法数
      */
     maxNumCreditCardPaymentMethod: number;
-    /**
-     * 取引ドキュメントのresult.order,result,numAcceptedOffersを保管しないオプション(2026-06-15~)
-     */
-    disableResultOrder: boolean;
 }
 type IConfirmParams = PlaceOrderFactory.IConfirmParams;
 interface IConfirmResult {
-    order: Pick<factory.transaction.placeOrder.IOrderAsResult, 'confirmationNumber' | 'orderNumber'>;
+    order: Pick<IOrderAsResult, 'confirmationNumber' | 'orderNumber'>;
     customer: factory.order.ICustomer;
     code?: string;
     /**

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

@@ -19,16 +19,17 @@ const debug = (0, debug_1.default)('chevre-domain:service:transaction');
 /**
  * 進行中でない取引を処理する
  */
-function processTransactionNotInProgress(transaction) {
+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: String(transaction.object.orderNumber) }
+            const resultCustomer = await repos.orderInTransaction.findCustomerByOrderIdentifier({
+                identifier: transaction.id
             });
             // if (resultCustomer === undefined) {
             //     throw new factory.errors.Internal('resultCustomer undefined'); // impossible process
             // }
-            const { confirmationNumber, orderNumber } = transaction.object;
+            const { confirmationNumber } = transaction.object;
             // Confirmedの取引であればobjectには必ず存在するはず
             if (typeof confirmationNumber !== 'string' || typeof orderNumber !== 'string'
                 || confirmationNumber === '' || orderNumber === '') {
@@ -62,30 +63,30 @@ function confirm(params, options) {
             object: { orderDate: params.result.order.orderDate }
         })(repos);
         const transaction = await repos.placeOrder.findPlaceOrderById({ typeOf: factory_1.factory.transactionType.PlaceOrder, id: params.id }, ['typeOf', 'project', 'status', 'agent', 'seller', 'object', 'result']);
-        const confirmResult = await processTransactionNotInProgress(transaction)(repos);
+        // 注文ドキュメントから注文番号を参照(取引開始時に発行済の前提)(2026-06-26~)
+        const orderNumber = await repos.orderInTransaction.findOrderNumberByIdentifier({
+            identifier: params.id,
+            project: { id: transaction.project.id }
+        }, { onlyPlaceOrder: false } // すでに取引確定済かもしれないのでfalse
+        );
+        const confirmResult = await processTransactionNotInProgress({ transaction, orderNumber })(repos);
         if (confirmResult !== undefined) {
             return confirmResult;
         }
         if (typeof params.agent?.id === 'string' && transaction.agent.id !== params.agent.id) {
             throw new factory_1.factory.errors.Forbidden('Transaction not yours');
         }
-        // 注文番号は興行オファー承認時に発行済のはず(2026-06-16~)
-        const orderNumber = transaction.object.orderNumber;
-        if (typeof orderNumber !== 'string' || orderNumber === '') {
-            throw new factory_1.factory.errors.Argument('transactionId', 'orderNumber not issued');
-        }
+        // // 注文番号は興行オファー承認時に発行済のはず(2026-06-16~)
+        // const orderNumber = transaction.object.orderNumber;
+        // if (typeof orderNumber !== 'string' || orderNumber === '') {
+        //     throw new factory.errors.Argument('transactionId', 'orderNumber not issued');
+        // }
         // 取引に対する全ての承認アクションをマージ
         const completedAuthorizeActions = await searchAuthorizeActions(params)(repos);
         let acceptPayActions = [];
         if (typeof transaction.object.paymentMethods?.paymentMethodId === 'string') {
             acceptPayActions = await searchAcceptPayActions(params)(repos);
         }
-        // 注文番号は興行オファー承認時に発行済のはずなので、ここは不要(承認オファーなしの注文は存在しえない)(2026-06-16~)
-        // const orderNumber = await issueOrderNumberIfNotExist({
-        //     project: { id: transaction.project.id },
-        //     id: transaction.id,
-        //     object: { orderDate: params.result.order.orderDate }
-        // })(repos);
         // 必要あらば注文コード発行(2024-02-05~)
         let code;
         const publishCodeExpiresInSeconds = options.publishCodeExpiresInSeconds;
@@ -107,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));
@@ -125,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,
@@ -136,17 +138,18 @@ function confirm(params, options) {
             acceptedOffers, payTransactions, customer,
             ...(typeof code === 'string') ? { code } : undefined
         }, options);
-        // デフォルトEメールメッセージを検索
-        let emailMessageOnOrderSent;
-        if (repos.emailMessage !== undefined) {
-            const searchEmailMessagesResult = await repos.emailMessage.search({
-                limit: 1,
-                page: 1,
-                project: { id: { $eq: transaction.project.id } },
-                about: { identifier: { $eq: factory_1.factory.creativeWork.message.email.AboutIdentifier.OnOrderSent } }
-            });
-            emailMessageOnOrderSent = searchEmailMessagesResult.shift();
-        }
+        // discontinue emailMessageRepo
+        // // デフォルトEメールメッセージを検索
+        // let emailMessageOnOrderSent: factory.creativeWork.message.email.ICreativeWork | undefined;
+        // if (repos.emailMessage !== undefined) {
+        //     const searchEmailMessagesResult = await repos.emailMessage.search({
+        //         limit: 1,
+        //         page: 1,
+        //         project: { id: { $eq: transaction.project.id } },
+        //         about: { identifier: { $eq: factory.creativeWork.message.email.AboutIdentifier.OnOrderSent } }
+        //     });
+        //     emailMessageOnOrderSent = searchEmailMessagesResult.shift();
+        // }
         // ポストアクションを作成
         const setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['defaultSenderEmail']);
         if (typeof setting?.defaultSenderEmail !== 'string') {
@@ -160,7 +163,7 @@ function confirm(params, options) {
             // order: orderWithAcceptedOffers, // 現時点でcreateEmailMessageでorder.acceptedOffersを使用している(2024-02-06~)
             // transaction: transaction,
             ...(params.potentialActions !== undefined) ? { potentialActions: params.potentialActions } : undefined,
-            ...(emailMessageOnOrderSent !== undefined) ? { emailMessage: emailMessageOnOrderSent } : undefined
+            // ...(emailMessageOnOrderSent !== undefined) ? { emailMessage: emailMessageOnOrderSent } : undefined
         }, 
         // settings
         setting);
@@ -174,7 +177,10 @@ function confirm(params, options) {
             await repos.placeOrder.confirmPlaceOrder({
                 typeOf: transaction.typeOf,
                 id: transaction.id,
-                object: { orderDate: params.result.order.orderDate },
+                object: {
+                    orderDate: params.result.order.orderDate,
+                    orderNumber
+                },
                 result: result,
                 potentialActions: potentialActions
             });
@@ -373,10 +379,10 @@ function createResult(params, options) {
         result: {
             authorizeActions, // 追加(2024-01-17~)
             ...(typeof params.code === 'string') ? { code: params.code } : undefined,
-            ...((!options.disableResultOrder) && { order: orderAsResult }), // support disableResultOrder(2026-06-15~)
-            ...((!options.disableResultOrder) && {
-                numAcceptedOffers: params.acceptedOffers.length, // 追加(2024-01-17~)
-            }) // support disableResultOrder(2026-06-17~)
+            // ...((!options.disableResultOrder) && { order: orderAsResult }), // 完全廃止(2026-06-26~)
+            // ...((!options.disableResultOrder) && {
+            //     numAcceptedOffers: params.acceptedOffers.length,
+            // }) // 完全廃止(2026-06-26~)
         },
         ...(typeof eventId === 'string') ? { eventId } : undefined,
         ...(Array.isArray(reservationIds)) ? { reservationIds } : undefined

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

@@ -1,3 +1,4 @@
+import type { OrderInTransactionRepo, IOrderInTransaction } from '../../../repo/orderInTransaction';
 import type { OrderNumberRepo } from '../../../repo/orderNumber';
 import type { ProjectRepo } from '../../../repo/project';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
@@ -15,9 +16,13 @@ declare function issueOrderNumberIfNotExist(params: {
     object: {
         orderDate: Date;
     };
+    creatingOrderInTransaction: Pick<IOrderInTransaction, 'broker' | 'seller' | 'customer'>;
+}, options: {
+    saveOrderNumberInPlaceOrderInProgress: boolean;
 }): (repos: {
     project: ProjectRepo;
     placeOrder: PlaceOrderRepo;
+    orderInTransaction: OrderInTransactionRepo;
     orderNumber: OrderNumberRepo;
 }) => Promise<string>;
 export { issueOrderNumberIfNotExist };

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

@@ -5,40 +5,54 @@ const factory_1 = require("../../../factory");
 /**
  * 未発行であれば、注文番号を発行して取引に保管する
  */
-function issueOrderNumberIfNotExist(params) {
+function issueOrderNumberIfNotExist(params, options) {
     return async (repos) => {
-        // 1. 最初のチェック
-        let orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.id });
-        // すでに発行済であれば何もしない
-        if (typeof orderNumber === 'string') {
-            return orderNumber;
-        }
-        // 2. 発行準備
+        const { saveOrderNumberInPlaceOrderInProgress } = options;
+        // // 1. 最初のチェック
+        // let orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.id });
+        // // すでに発行済であれば何もしない
+        // if (typeof orderNumber === 'string') {
+        //     return orderNumber;
+        // }
+        // 新注文番号発行
         const { alternateName } = await repos.project.findAlternateNameById({ id: params.project.id });
         if (typeof alternateName !== 'string') {
             throw new factory_1.factory.errors.NotFound('project.alternateName');
         }
-        // 3. 番号発行
         const issuedOrderNumber = await repos.orderNumber.issueOrderNumber({
             project: { alternateName },
             orderDate: params.object.orderDate
         });
-        // 4. 保管を試みる
-        const { modifiedCount } = await repos.placeOrder.saveOrderNumberIfNotExist({
-            id: params.id,
-            orderNumber: issuedOrderNumber
+        // 注文ドキュメント作成
+        await repos.orderInTransaction.createPlaceOrderIfNotExists({
+            ...params.creatingOrderInTransaction,
+            orderNumber: issuedOrderNumber,
+            project: { id: params.project.id, typeOf: factory_1.factory.organizationType.Project },
+            identifier: params.id,
         });
-        // 5. 書き込めたなら、自分が発行した番号が「真実」
-        if (modifiedCount === 1) {
-            return issuedOrderNumber;
-        }
-        // 6. 競合が発生した場合（他者が先に書き込んだ場合）
-        // DBにある「正解」を再取得して返す
-        orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.id });
-        if (typeof orderNumber !== 'string') {
-            // ここを通るのは、他者が保存した直後に取引がキャンセル/削除された等の極めて稀なケース
-            throw new factory_1.factory.errors.Internal('OrderNumber conflict: failed to retrieve existing number');
+        // 注文ドキュメント(存在するはず)から注文番号を参照
+        const orderNumber = await repos.orderInTransaction.findOrderNumberByIdentifier({
+            identifier: params.id,
+            project: { id: params.project.id }
+        }, { onlyPlaceOrder: true });
+        if (saveOrderNumberInPlaceOrderInProgress) {
+            // 取引に保管を試みる
+            await repos.placeOrder.saveOrderNumberIfNotExist({
+                id: params.id,
+                orderNumber
+            });
         }
+        // // 5. 書き込めたなら、自分が発行した番号が「真実」
+        // if (modifiedCount === 1) {
+        //     return issuedOrderNumber;
+        // }
+        // // 6. 競合が発生した場合（他者が先に書き込んだ場合）
+        // // DBにある「正解」を再取得して返す
+        // const orderNumber = await repos.placeOrder.findInProgressOrderNumberById({ id: params.id });
+        // if (typeof orderNumber !== 'string') {
+        //     // ここを通るのは、他者が保存した直後に取引がキャンセル/削除された等の極めて稀なケース
+        //     throw new factory.errors.Internal('OrderNumber conflict: failed to retrieve existing number');
+        // }
         return orderNumber;
     };
 }