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

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

@@ -22,18 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processing2inTransit = exports.paymentDue2Processing = void 0;
 exports.onAssetTransactionStatusChanged = onAssetTransactionStatusChanged;
-exports.paymentDue2Processing = paymentDue2Processing;
-exports.processing2inTransit = processing2inTransit;
-const debug_1 = __importDefault(require("debug"));
-const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
-const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
+const isDeliverable_1 = require("./onAssetTransactionStatusChanged/isDeliverable");
+const onPayTransactionCanceled_1 = require("./onAssetTransactionStatusChanged/onPayTransactionCanceled");
+const onPayTransactionConfirmed_1 = require("./onAssetTransactionStatusChanged/onPayTransactionConfirmed");
+const onReserveTransactionConfirmed_1 = require("./onAssetTransactionStatusChanged/onReserveTransactionConfirmed");
+const paymentDue2Processing_1 = require("./onAssetTransactionStatusChanged/paymentDue2Processing");
+Object.defineProperty(exports, "paymentDue2Processing", { enumerable: true, get: function () { return paymentDue2Processing_1.paymentDue2Processing; } });
+const processing2inTransit_1 = require("./onAssetTransactionStatusChanged/processing2inTransit");
+Object.defineProperty(exports, "processing2inTransit", { enumerable: true, get: function () { return processing2inTransit_1.processing2inTransit; } });
 const factory = __importStar(require("../../factory"));
-const debug = (0, debug_1.default)('chevre-domain:service:order');
 function onAssetTransactionStatusChanged(params) {
     return async (repos, settings) => {
         if (typeof params.useOnOrderStatusChanged !== 'boolean') {
@@ -45,70 +45,41 @@ function onAssetTransactionStatusChanged(params) {
                 const confirmationNumber = params.purpose?.confirmationNumber;
                 switch (params.object.typeOf) {
                     case factory.assetTransactionType.Pay:
-                        // 確定時の決済方法区分指定(2023-08-29~)
-                        const specifiedPaymentMethodIdentifire = params.object?.object?.paymentMethod?.identifier;
-                        if (typeof specifiedPaymentMethodIdentifire === 'string' && specifiedPaymentMethodIdentifire.length > 0) {
-                            await fixPaymentMethodIdentifierIfPossible({
-                                project: { id: params.project.id },
-                                paymentMethodId: params.object.transactionNumber,
-                                paymentMethod: { identifier: specifiedPaymentMethodIdentifire },
-                                referencesOrder: { orderNumber }
-                            })(repos);
-                        }
-                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            // PayTransactionのステータス検証
-                            const processable = await isProcessable({ project: { id: params.project.id }, orderNumber })(repos);
-                            if (processable) {
-                                await paymentDue2Processing({
-                                    project: { id: params.project.id },
-                                    confirmationNumber,
-                                    orderNumber,
-                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
-                                })(repos, settings);
+                        await (0, onPayTransactionConfirmed_1.onPayTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.COAReserveTransaction:
-                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            // 基本的に1注文に1予約番号なのでdeliverable = true
-                            const deliverable = true;
-                            if (deliverable) {
-                                await processing2inTransit({
-                                    project: { id: params.project.id },
-                                    // confirmationNumber,
-                                    orderNumber,
-                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
-                                })(repos, settings);
+                        await (0, onReserveTransactionConfirmed_1.onReserveTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.Reserve:
-                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            // ReserveTransactionのステータス検証
-                            const deliverable = await isDeliverable({
-                                project: { id: params.project.id },
-                                orderNumber,
-                                assetTransactionType: params.object.typeOf
-                            })(repos);
-                            if (deliverable) {
-                                await processing2inTransit({
-                                    project: { id: params.project.id },
-                                    // confirmationNumber,
-                                    orderNumber,
-                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
-                                })(repos, settings);
+                        await (0, onReserveTransactionConfirmed_1.onReserveTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.MoneyTransfer:
                         if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            const deliverable = await isDeliverable({
+                            const deliverable = await (0, isDeliverable_1.isDeliverable)({
                                 project: { id: params.project.id },
                                 orderNumber,
                                 assetTransactionType: params.object.typeOf
                             })(repos);
                             if (deliverable) {
-                                await processing2inTransit({
+                                await (0, processing2inTransit_1.processing2inTransit)({
                                     project: { id: params.project.id },
                                     // confirmationNumber,
                                     orderNumber,
@@ -119,13 +90,13 @@ function onAssetTransactionStatusChanged(params) {
                         break;
                     case factory.assetTransactionType.RegisterService:
                         if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            const deliverable = await isDeliverable({
+                            const deliverable = await (0, isDeliverable_1.isDeliverable)({
                                 project: { id: params.project.id },
                                 orderNumber,
                                 assetTransactionType: params.object.typeOf
                             })(repos);
                             if (deliverable) {
-                                await processing2inTransit({
+                                await (0, processing2inTransit_1.processing2inTransit)({
                                     project: { id: params.project.id },
                                     // confirmationNumber,
                                     orderNumber,
@@ -142,11 +113,12 @@ function onAssetTransactionStatusChanged(params) {
             case factory.transactionStatusType.Expired:
                 switch (params.object.typeOf) {
                     case factory.assetTransactionType.Pay:
-                        // 注文が存在すればキャンセル(2023-08-30~)
-                        await cancelOrderIfExist({
-                            project: { id: params.project.id },
-                            paymentMethodId: params.object.transactionNumber,
-                            useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                        await (0, onPayTransactionCanceled_1.onPayTransactionCanceled)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
+                            }
                         })(repos);
                         break;
                     default:
@@ -158,286 +130,3 @@ function onAssetTransactionStatusChanged(params) {
         }
     };
 }
-function fixPaymentMethodIdentifierIfPossible(params) {
-    return async (repos) => {
-        const referencedPayTransactions = await repos.assetTransaction.search({
-            project: { id: { $eq: params.project.id } },
-            typeOf: factory.assetTransactionType.Pay,
-            statuses: [factory.transactionStatusType.Confirmed],
-            transactionNumber: { $in: [params.paymentMethodId] }
-        }, ['object']);
-        const referencedPayTransaction = referencedPayTransactions.shift();
-        if (referencedPayTransaction === undefined) {
-            throw new factory.errors.NotFound(factory.assetTransactionType.Pay);
-        }
-        // 対面決済かつ決済取引上の決済方法区分と一致すれば、注文を変更
-        if (referencedPayTransaction.object.typeOf === factory.service.paymentService.PaymentServiceType.FaceToFace
-            && referencedPayTransaction.object.paymentMethod.identifier === params.paymentMethod.identifier) {
-            await repos.order.fixPaymentMethodIdentifier({
-                project: { id: params.project.id },
-                orderNumber: params.referencesOrder.orderNumber,
-                invoice: {
-                    paymentMethodId: params.paymentMethodId,
-                    paymentMethod: { identifier: params.paymentMethod.identifier }
-                }
-            });
-        }
-    };
-}
-function isProcessable(params) {
-    return async (repos) => {
-        // 注文のpaymentMethodIdを取得
-        const order = await repos.order.projectFieldsByOrderNumber({
-            orderNumber: params.orderNumber,
-            project: { id: params.project.id },
-            inclusion: ['paymentMethods']
-        });
-        // PayTransactionのステータス検証
-        let allPayTransactionConfirmed;
-        const paymentMethodIds = order.paymentMethods.filter((invoice) => typeof invoice.paymentMethodId === 'string' && invoice.paymentMethodId.length > 0)
-            .map((invoice) => invoice.paymentMethodId);
-        if (paymentMethodIds.length > 0) {
-            const referencedPayTransactions = await repos.assetTransaction.search({
-                project: { id: { $eq: params.project.id } },
-                typeOf: factory.assetTransactionType.Pay,
-                transactionNumber: { $in: paymentMethodIds }
-            }, ['status']);
-            allPayTransactionConfirmed =
-                referencedPayTransactions.every((payTransation) => payTransation.status === factory.transactionStatusType.Confirmed);
-        }
-        else {
-            allPayTransactionConfirmed = true;
-        }
-        return allPayTransactionConfirmed;
-    };
-}
-function paymentDue2Processing(params) {
-    return async (repos, settings) => {
-        const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-            project: { id: params.project.id },
-            confirmationNumber: params.confirmationNumber,
-            orderNumber: params.orderNumber
-        })({ transaction: repos.transaction });
-        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
-        //     orderNumber: params.orderNumber,
-        //     project: { id: params.project.id },
-        //     inclusion: ['project']
-        // });
-        let order;
-        try {
-            order = await repos.order.changeStatus({
-                project: { id: params.project.id },
-                orderNumber: params.orderNumber,
-                orderStatus: factory.orderStatus.OrderProcessing,
-                previousOrderStatus: factory.orderStatus.OrderPaymentDue
-            });
-        }
-        catch (error) {
-            let throwsError = true;
-            // すでにステータスが進行していた場合、OrderPaymentDue->OrderProcessingの処理自体は成功しているので、後処理を続行する
-            order = await repos.order.projectFieldsByOrderNumber({
-                orderNumber: params.orderNumber,
-                project: { id: params.project.id },
-                inclusion: [
-                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
-                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
-                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
-                ] // explicit projection(2024-07-25~)
-            });
-            if (order.orderStatus === factory.orderStatus.OrderInTransit
-                || order.orderStatus === factory.orderStatus.OrderDelivered
-                || order.orderStatus === factory.orderStatus.OrderReturned) {
-                throwsError = false;
-            }
-            if (throwsError) {
-                throw error;
-            }
-        }
-        if (params.useOnOrderStatusChanged) {
-            // 全acceptedOffersを検索(2023-12-08~)
-            // const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber(
-            //     {
-            //         orderNumber: { $eq: order.orderNumber },
-            //         project: { id: { $eq: params.project.id } }
-            //     },
-            //     ['itemOffered', 'offeredThrough']
-            // );
-            const { numAcceptedOffers } = await repos.acceptedOffer.countByOrderNumber({
-                orderNumber: { $eq: order.orderNumber },
-                project: { id: { $eq: params.project.id } }
-            });
-            const itemOfferedTypeOfs = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.typeOf');
-            const serialNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
-            const offeredThroughIdentifier = (await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.offeredThrough.identifier')).shift();
-            debug('onAssetTransactionStatusChanged paymentDue2Processing: calling onOrderProcessing...', 'numAcceptedOffers:', numAcceptedOffers, 'itemOfferedTypeOfs:', itemOfferedTypeOfs, 'serialNumbers:', serialNumbers, 'offeredThroughIdentifier:', offeredThroughIdentifier);
-            await (0, onOrderStatusChanged_1.onOrderProcessing)({
-                order: {
-                    ...order,
-                    // acceptedOffers,
-                    numAcceptedOffers,
-                    itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
-                    serialNumbers,
-                    offeredThroughIdentifier,
-                    orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
-                },
-                placeOrderTransaction
-            })(repos, settings);
-        }
-    };
-}
-function cancelOrderIfExist(params) {
-    return async (repos) => {
-        if (params.paymentMethodId.length === 0) {
-            return;
-        }
-        // 注文のpaymentMethodIdを取得
-        const ordersByPaymentMethodId = await repos.order.projectFields({
-            limit: 1,
-            page: 1,
-            paymentMethods: {
-                paymentMethodIds: [params.paymentMethodId]
-            },
-            project: { id: { $eq: params.project.id } }
-        }, { inclusion: ['confirmationNumber', 'orderNumber'] });
-        const orderByPaymentMethodId = ordersByPaymentMethodId.shift();
-        if (orderByPaymentMethodId !== undefined) {
-            const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-                project: { id: params.project.id },
-                confirmationNumber: orderByPaymentMethodId.confirmationNumber,
-                orderNumber: orderByPaymentMethodId.orderNumber
-            })({ transaction: repos.transaction });
-            const order = await repos.order.changeStatus({
-                project: { id: params.project.id },
-                orderNumber: orderByPaymentMethodId.orderNumber,
-                orderStatus: factory.orderStatus.OrderCancelled,
-                previousOrderStatus: factory.orderStatus.OrderPaymentDue
-            });
-            if (params.useOnOrderStatusChanged) {
-                await (0, onOrderStatusChanged_1.onOrderCancelled)({
-                    order: {
-                        orderDate: order.orderDate,
-                        orderNumber: order.orderNumber,
-                        orderStatus: factory.orderStatus.OrderCancelled // 強制的にOrderCancelledとして処理する
-                    },
-                    placeOrderTransaction
-                })({
-                    task: repos.task
-                });
-            }
-        }
-    };
-}
-function isDeliverable(params) {
-    return async (repos) => {
-        let allReserveTransactionConfirmed = false;
-        let allMoneyTransferTransactionConfirmed = false;
-        let allRegisterServiceTransactionConfirmed = false;
-        if (params.assetTransactionType === factory.assetTransactionType.Reserve) {
-            allMoneyTransferTransactionConfirmed = true;
-            allRegisterServiceTransactionConfirmed = true;
-            // 注文のreservationNumberを取得
-            const reservationNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.reservationNumber');
-            if (reservationNumbers.length > 0) {
-                const referencedReserveTransactions = await repos.assetTransaction.search({
-                    project: { id: { $eq: params.project.id } },
-                    typeOf: factory.assetTransactionType.Reserve,
-                    transactionNumber: { $in: reservationNumbers }
-                }, ['status']);
-                allReserveTransactionConfirmed =
-                    referencedReserveTransactions.length === reservationNumbers.length
-                        && referencedReserveTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
-            }
-            else {
-                allReserveTransactionConfirmed = true;
-            }
-        }
-        else if (params.assetTransactionType === factory.assetTransactionType.MoneyTransfer) {
-            allReserveTransactionConfirmed = true;
-            allRegisterServiceTransactionConfirmed = true;
-            // 注文のMoneyTransferTransaction.transactionNumberを取得
-            const moneyTransferTransactionNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
-            if (moneyTransferTransactionNumbers.length > 0) {
-                debug('is deliverable?...', params.orderNumber, 'moneyTransferTransactionNumbers:', moneyTransferTransactionNumbers);
-                const referencedMoneyTransferTransactions = await repos.assetTransaction.search({
-                    project: { id: { $eq: params.project.id } },
-                    typeOf: factory.assetTransactionType.MoneyTransfer,
-                    transactionNumber: { $in: moneyTransferTransactionNumbers }
-                }, ['status']);
-                allMoneyTransferTransactionConfirmed =
-                    referencedMoneyTransferTransactions.length === moneyTransferTransactionNumbers.length
-                        && referencedMoneyTransferTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
-            }
-            else {
-                allMoneyTransferTransactionConfirmed = true;
-            }
-        }
-        else if (params.assetTransactionType === factory.assetTransactionType.RegisterService) {
-            allReserveTransactionConfirmed = true;
-            allMoneyTransferTransactionConfirmed = true;
-            const registerServiceTransactionNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
-            if (registerServiceTransactionNumbers.length > 0) {
-                const referencedRegisterServiceTransactions = await repos.assetTransaction.search({
-                    project: { id: { $eq: params.project.id } },
-                    typeOf: factory.assetTransactionType.RegisterService,
-                    transactionNumber: { $in: registerServiceTransactionNumbers }
-                }, ['status']);
-                allRegisterServiceTransactionConfirmed =
-                    referencedRegisterServiceTransactions.length === registerServiceTransactionNumbers.length
-                        && referencedRegisterServiceTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
-            }
-            else {
-                allRegisterServiceTransactionConfirmed = true;
-            }
-        }
-        return allReserveTransactionConfirmed && allMoneyTransferTransactionConfirmed && allRegisterServiceTransactionConfirmed;
-    };
-}
-function processing2inTransit(params) {
-    return async (repos, settings) => {
-        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
-        //     orderNumber: params.orderNumber,
-        //     project: { id: params.project.id },
-        //     inclusion: ['project']
-        // });
-        let order;
-        try {
-            order = await repos.order.changeStatus({
-                project: { id: params.project.id },
-                orderNumber: params.orderNumber,
-                orderStatus: factory.orderStatus.OrderInTransit,
-                previousOrderStatus: factory.orderStatus.OrderProcessing
-            });
-        }
-        catch (error) {
-            let throwsError = true;
-            // すでにステータスが進行していた場合、OrderProcessing->OrderInTransitの処理自体は成功しているので、後処理を続行する
-            order = await repos.order.projectFieldsByOrderNumber({
-                orderNumber: params.orderNumber,
-                project: { id: params.project.id },
-                inclusion: [
-                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
-                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
-                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
-                ] // explicit projection(2024-07-25~)
-            });
-            if (order.orderStatus === factory.orderStatus.OrderDelivered
-                || order.orderStatus === factory.orderStatus.OrderReturned) {
-                throwsError = false;
-            }
-            if (throwsError) {
-                throw error;
-            }
-        }
-        if (params.useOnOrderStatusChanged) {
-            await (0, onOrderStatusChanged_1.onOrderInTransit)({
-                order: {
-                    ...order,
-                    orderStatus: factory.orderStatus.OrderInTransit
-                }
-            })({
-                task: repos.task,
-                transaction: repos.transaction
-            }, settings);
-        }
-    };
-}

package/lib/chevre/service/order/onOrderStatusChanged/onOrderDelivered.d.ts

@@ -1,14 +1,13 @@
 import * as factory from '../../../factory';
 import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
-type IPlaceOrderTransaction = Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'project' | 'typeOf' | 'potentialActions'>;
+interface IOnOrderDeliveredRepos {
+    setting: SettingRepo;
+    task: TaskRepo;
+}
 declare function onOrderDelivered(params: {
     order: Pick<factory.order.IOrder, 'id' | 'customer' | 'orderDate' | 'orderNumber' | 'project' | 'typeOf' | 'price' | 'priceCurrency'> & {
         orderStatus: factory.orderStatus.OrderDelivered;
     };
-    placeOrderTransaction?: IPlaceOrderTransaction;
-}): (repos: {
-    setting: SettingRepo;
-    task: TaskRepo;
-}) => Promise<void>;
-export { onOrderDelivered };
+}): (repos: IOnOrderDeliveredRepos) => Promise<void>;
+export { IOnOrderDeliveredRepos, onOrderDelivered };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderDeliveredPartially.d.ts

@@ -1,10 +1,11 @@
 import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
 import { IInTransitOrder } from './onOrderDeliveredPartially/factory';
-declare function onOrderDeliveredPartially(params: {
-    order: IInTransitOrder;
-}): (repos: {
+interface IOnOrderDeliveredPartiallyRepos {
     setting: SettingRepo;
     task: TaskRepo;
-}) => Promise<void>;
-export { onOrderDeliveredPartially };
+}
+declare function onOrderDeliveredPartially(params: {
+    order: IInTransitOrder;
+}): (repos: IOnOrderDeliveredPartiallyRepos) => Promise<void>;
+export { IOnOrderDeliveredPartiallyRepos, onOrderDeliveredPartially };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderInTransit.d.ts

@@ -1,13 +1,14 @@
 import type { TaskRepo } from '../../../repo/task';
-import type { TransactionRepo } from '../../../repo/transaction';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
+interface IOnOrderInTransitRepos {
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
 declare function onOrderInTransit(params: {
     order: Pick<factory.order.IOrder, 'id' | 'orderNumber' | 'broker' | 'confirmationNumber' | 'customer' | 'dateReturned' | 'name' | 'orderDate' | 'orderedItem' | 'paymentMethods' | 'previousOrderStatus' | 'price' | 'priceCurrency' | 'project' | 'returner' | 'seller' | 'typeOf'> & {
         orderStatus: factory.orderStatus.OrderInTransit;
     };
-}): (repos: {
-    task: TaskRepo;
-    transaction: TransactionRepo;
-}, settings: Settings) => Promise<void>;
-export { onOrderInTransit };
+}): (repos: IOnOrderInTransitRepos, settings: Settings) => Promise<void>;
+export { IOnOrderInTransitRepos, onOrderInTransit };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderInTransit.js

@@ -103,7 +103,7 @@ function createSendOrderTaskIfNotExist(params) {
 }
 function createOnAuthorizationCreatedTask(order) {
     return async (repos) => {
-        const placeOrderTransaction = (await repos.transaction.projectFields({
+        const placeOrderTransaction = (await repos.placeOrder.findPlaceOrderTransactions({
             limit: 1,
             page: 1,
             typeOf: factory.transactionType.PlaceOrder,

package/lib/chevre/service/order/payOrder.d.ts

@@ -2,7 +2,7 @@ import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
 import type { OrderRepo } from '../../repo/order';
 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 * as factory from '../../factory';
 import { Settings } from '../../settings';
 /**
@@ -13,6 +13,6 @@ declare function payOrder(params: factory.task.IData<factory.taskName.OnOrderPay
     order: OrderRepo;
     setting: SettingRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }, settings: Settings) => Promise<void>;
 export { payOrder };

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

@@ -1,6 +1,6 @@
 import type { ActionRepo } from '../../../repo/action';
 import type { IPlacingOrder, OrderInTransactionRepo } from '../../../repo/orderInTransaction';
-import type { TransactionRepo } from '../../../repo/transaction';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import * as factory from '../../../factory';
 type IPlaceOrderTransaction = Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'project' | 'typeOf' | 'result' | 'object' | 'seller'>;
 declare function createPlacingOrderFromExistingTransaction(params: {
@@ -12,7 +12,7 @@ declare function createPlacingOrderFromExistingTransaction(params: {
 }): (repos: {
     action: ActionRepo;
     orderInTransaction: OrderInTransactionRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }) => Promise<{
     order: IPlacingOrder;
     placeOrderTransaction: IPlaceOrderTransaction;

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

@@ -30,7 +30,7 @@ function createPlacingOrderFromExistingTransaction(params) {
     return async (repos) => {
         const confirmationNumber = String(params.confirmationNumber);
         const orderNumber = params.orderNumber;
-        const placeOrderTransactions = await repos.transaction.projectFields({
+        const placeOrderTransactions = await repos.placeOrder.findPlaceOrderTransactions({
             limit: 1,
             page: 1,
             project: { id: { $eq: params.project.id } },

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

@@ -5,9 +5,19 @@ import type { OrderRepo } from '../../repo/order';
 import type { OrderInTransactionRepo } from '../../repo/orderInTransaction';
 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 * as factory from '../../factory';
 import { Settings } from '../../settings';
+interface IPlaceOrderRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    order: OrderRepo;
+    orderInTransaction: OrderInTransactionRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
 /**
  * 注文を作成する
  */
@@ -21,16 +31,7 @@ declare function placeOrder(params: {
         orderNumber: string;
     };
     useOnOrderStatusChanged: boolean;
-}): (repos: {
-    acceptedOffer: AcceptedOfferRepo;
-    accountingReport: AccountingReportRepo;
-    action: ActionRepo;
-    order: OrderRepo;
-    orderInTransaction: OrderInTransactionRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
-    transaction: TransactionRepo;
-}, settings: Settings) => Promise<{
+}): (repos: IPlaceOrderRepos, settings: Settings) => Promise<{
     order: factory.transaction.placeOrder.IOrderAsResult;
 }>;
-export { placeOrder };
+export { IPlaceOrderRepos, placeOrder };

package/lib/chevre/service/order/returnOrder.d.ts

@@ -4,7 +4,7 @@ import type { OrderRepo } from '../../repo/order';
 import type { OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
-import type { TransactionRepo } from '../../repo/transaction';
+import type { ReturnOrderRepo } from '../../repo/transaction/returnOrder';
 import * as factory from '../../factory';
 declare function returnOrder(params: {
     agent: factory.action.transfer.returnAction.order.IAgent;
@@ -23,6 +23,6 @@ declare function returnOrder(params: {
     ownershipInfo: OwnershipInfoRepo;
     setting: SettingRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
+    returnOrder: ReturnOrderRepo;
 }) => Promise<void>;
 export { returnOrder };

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

@@ -72,7 +72,7 @@ function returnOrder(params) {
                 throw new factory.errors.Argument('object.orderNumber', `orderStatus not returnable: ${order.orderStatus}`);
         }
         // 返品取引検索
-        const returnOrderTransactions = await repos.transaction.projectFields({
+        const returnOrderTransactions = await repos.returnOrder.findReturnOrderTransactions({
             limit: 1,
             page: 1,
             project: { id: { $eq: order.project.id } },