@chevre/domain 24.0.0-alpha.13 → 24.0.0-alpha.15

package/lib/chevre/repo/transaction/returnOrder.d.ts

@@ -1,6 +1,8 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../../factory';
 type IKeyOfProjection = keyof Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf'> | Exclude<keyof factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, 'id'>;
+type IStartedTransactionFields = 'expires' | 'id' | 'startDate' | 'status';
+export type IStartedTransaction = Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, IStartedTransactionFields>;
 /**
  * 返品取引リポジトリ
  */
@@ -19,5 +21,25 @@ export declare class ReturnOrderRepo {
     }): Promise<(Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, IKeyOfProjection> & {
         id: string;
     })[]>;
+    /**
+     * 取引を開始する
+     */
+    startReturnOrder(params: factory.transaction.IStartParams<factory.transactionType.ReturnOrder>): Promise<IStartedTransaction>;
+    /**
+     * 特定取引検索
+     */
+    findReturnOrderById(params: {
+        typeOf: factory.transactionType.ReturnOrder;
+        id: string;
+    }, inclusion: IKeyOfProjection[]): Promise<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>>;
+    /**
+     * 取引を確定する
+     */
+    confirmReturnOrder(params: {
+        typeOf: factory.transactionType.ReturnOrder;
+        id: string;
+        result: factory.transaction.IResult<factory.transactionType.ReturnOrder>;
+        potentialActions: factory.transaction.IPotentialActions<factory.transactionType.ReturnOrder>;
+    }): Promise<void>;
 }
 export {};

package/lib/chevre/repo/transaction/returnOrder.js

@@ -22,12 +22,16 @@ 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.ReturnOrderRepo = void 0;
-// import { transactionEventEmitter } from '../../eventEmitter/transaction';
+const moment_1 = __importDefault(require("moment"));
+const transaction_1 = require("../../eventEmitter/transaction");
 const factory = __importStar(require("../../factory"));
 const settings_1 = require("../../settings");
-const transaction_1 = require("../mongoose/schemas/transaction");
+const transaction_2 = require("../mongoose/schemas/transaction");
 const AVAILABLE_PROJECT_FIELDS = [
     'project',
     'status',
@@ -45,17 +49,13 @@ const AVAILABLE_PROJECT_FIELDS = [
     'potentialActions',
     // 'instrument'
 ];
-// type IOmittedFieldsInProgress = 'tasksExportAction' | 'tasksExportedAt' | 'tasksExportationStatus';
-// export type IMoneyTransferTransactionInProgress = Omit<factory.transaction.moneyTransfer.ITransaction, IOmittedFieldsInProgress>;
-// type IStartedTransactionFields = 'expires' | 'id' | 'startDate' | 'status';
-// export type IStartedTransaction = Pick<factory.transaction.ITransaction<factory.transactionType>, IStartedTransactionFields>;
 /**
  * 返品取引リポジトリ
  */
 class ReturnOrderRepo {
     transactionModel;
     constructor(connection) {
-        this.transactionModel = connection.model(transaction_1.modelName, (0, transaction_1.createSchema)());
+        this.transactionModel = connection.model(transaction_2.modelName, (0, transaction_2.createSchema)());
     }
     static CREATE_MONGO_CONDITIONS(params) {
         if (params.typeOf !== factory.transactionType.ReturnOrder) {
@@ -209,5 +209,133 @@ class ReturnOrderRepo {
             .lean()
             .exec();
     }
+    /**
+     * 取引を開始する
+     */
+    async startReturnOrder(params) {
+        const status = factory.transactionStatusType.InProgress;
+        const tasksExportAction = { actionStatus: factory.actionStatusType.PotentialActionStatus };
+        // const tasksExportationStatus = factory.transactionTasksExportationStatus.Unexported; // discontinue(2024-06-20~)
+        const startDate = new Date();
+        let expires;
+        const { typeOf } = params;
+        // expiresInSecondsの指定があれば優先して適用する(2022-11-25~)
+        if (typeof params.expiresInSeconds === 'number' && params.expiresInSeconds > 0) {
+            expires = (0, moment_1.default)(startDate)
+                .add(params.expiresInSeconds, 'seconds')
+                .toDate();
+        }
+        else {
+            throw new factory.errors.ArgumentNull('expiresInSeconds');
+        }
+        let creatingTransaction;
+        if (typeOf === factory.transactionType.ReturnOrder) {
+            const { agent, project, object, seller } = params;
+            creatingTransaction = {
+                status, startDate, expires, typeOf, tasksExportAction,
+                agent, project, seller, object
+            };
+        }
+        else {
+            throw new factory.errors.NotImplemented(`${typeOf} not implemented`);
+        }
+        // reimplemnt with insertMany(2024-05-30~)
+        const result = await this.transactionModel.insertMany(creatingTransaction, { rawResult: true });
+        const id = result.insertedIds?.[0]?.toHexString();
+        if (typeof id !== 'string') {
+            throw new factory.errors.Internal('transaction not saved');
+        }
+        // 取引開始時にも取引イベントエミッター連携(2024-03-21~)
+        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({ id, typeOf, status });
+        return { expires, id, startDate, status }; // minimize response(2024-05-30~)
+    }
+    /**
+     * 特定取引検索
+     */
+    async findReturnOrderById(params, inclusion // make required(2024-05-31~)
+    ) {
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = positiveProjectionFields.filter((key) => inclusion.includes(key));
+        }
+        else {
+            throw new factory.errors.NotImplemented('inclusion must be specified'); // 2024-08-26~
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        // let projection: { [key in (IKeyOfProjection<T> | '__v' | 'createdAt' | 'updatedAt')]?: AnyExpression } = {};
+        // if (Array.isArray(inclusion) && inclusion.length > 0) {
+        //     inclusion.forEach((field) => {
+        //         projection[field] = 1;
+        //     });
+        // } else {
+        //     projection = {
+        //         __v: 0,
+        //         createdAt: 0,
+        //         updatedAt: 0
+        //     };
+        // }
+        const doc = await this.transactionModel.findOne({
+            _id: { $eq: params.id },
+            typeOf: { $eq: params.typeOf }
+        }, projection)
+            .lean() // 2024-08-26~
+            .exec();
+        if (doc === null) {
+            throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} not found`);
+        }
+        return doc;
+    }
+    /**
+     * 取引を確定する
+     */
+    async confirmReturnOrder(params) {
+        const endDate = new Date();
+        const doc = await this.transactionModel.findOneAndUpdate({
+            _id: { $eq: params.id },
+            typeOf: { $eq: params.typeOf },
+            status: { $eq: factory.transactionStatusType.InProgress },
+            expires: { $gt: endDate } // add expires(2025-02-27~)
+        }, {
+            status: factory.transactionStatusType.Confirmed, // ステータス変更
+            endDate,
+            // 'object.authorizeActions': params.authorizeActions,
+            result: params.result, // resultを更新
+            potentialActions: params.potentialActions // resultを更新
+        }, {
+            new: true,
+            projection: { _id: 1 }
+        })
+            .lean()
+            .exec();
+        // NotFoundであれば取引状態確認
+        if (doc === null) {
+            const { expires, status } = await this.findReturnOrderById({ typeOf: params.typeOf, id: params.id }, ['expires', 'status']);
+            if (status === factory.transactionStatusType.Confirmed) {
+                // すでに確定済の場合スルー
+            }
+            else if (status === factory.transactionStatusType.Expired) {
+                throw new factory.errors.Argument('Transaction id', 'Already expired');
+            }
+            else if (status === factory.transactionStatusType.Canceled) {
+                throw new factory.errors.Argument('Transaction id', 'Already canceled');
+            }
+            else {
+                if ((0, moment_1.default)(expires)
+                    .isSameOrBefore((0, moment_1.default)(endDate))) {
+                    throw new factory.errors.Argument('Transaction id', 'potentially expired');
+                }
+                throw new factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} ${factory.transactionStatusType.InProgress} not found`);
+            }
+        }
+        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+            id: params.id,
+            typeOf: params.typeOf,
+            status: factory.transactionStatusType.Confirmed
+        });
+    }
 }
 exports.ReturnOrderRepo = ReturnOrderRepo;

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

@@ -1,6 +1,6 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
-type IKeyOfProjection<T extends factory.transactionType> = keyof Pick<factory.transaction.ITransaction<factory.transactionType>, 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf'> | Exclude<keyof factory.transaction.ITransaction<T>, 'id'>;
+type IKeyOfProjection = keyof Pick<factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>, 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf'> | Exclude<keyof factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>, 'id'>;
 interface IAggregationByStatus {
     transactionCount: number;
     avgDuration: number;
@@ -32,29 +32,29 @@ export declare class TransactionRepo {
     /**
      * 取引を開始する
      */
-    startNoPlaceOrder<T extends factory.transactionType.MoneyTransfer | factory.transactionType.ReturnOrder>(params: factory.transaction.IStartParams<T>): Promise<IStartedTransaction>;
+    startMoneyTransfer(params: factory.transaction.IStartParams<factory.transactionType.MoneyTransfer>): Promise<IStartedTransaction>;
     /**
      * 特定取引検索
      */
-    projectFieldsByIdNoPlaceOrder<T extends factory.transactionType.MoneyTransfer | factory.transactionType.ReturnOrder>(params: {
-        typeOf: T;
+    findMoneyTransferById(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
         id: string;
-    }, inclusion: IKeyOfProjection<T>[]): Promise<factory.transaction.ITransaction<T>>;
+    }, inclusion: IKeyOfProjection[]): Promise<factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>>;
     /**
      * 進行中の取引を取得する
      */
     findMoneyTransferInProgressById(params: {
         typeOf: factory.transactionType.MoneyTransfer;
         id: string;
-    }, inclusion: IKeyOfProjection<factory.transactionType.MoneyTransfer>[]): Promise<IMoneyTransferTransactionInProgress>;
+    }, inclusion: IKeyOfProjection[]): Promise<IMoneyTransferTransactionInProgress>;
     /**
      * 取引を確定する
      */
-    confirmNoPlaceOrder<T extends factory.transactionType.MoneyTransfer | factory.transactionType.ReturnOrder>(params: {
-        typeOf: T;
+    confirmMoneyTransfer(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
         id: string;
-        result: factory.transaction.IResult<T>;
-        potentialActions: factory.transaction.IPotentialActions<T>;
+        result: factory.transaction.IResult<factory.transactionType.MoneyTransfer>;
+        potentialActions: factory.transaction.IPotentialActions<factory.transactionType.MoneyTransfer>;
     }): Promise<void>;
     countPotentiallyExportTasks(params: {
         endDate: {
@@ -144,8 +144,8 @@ export declare class TransactionRepo {
     /**
      * 取引を中止する
      */
-    cancelNoPlaceOrder<T extends factory.transactionType.MoneyTransfer | factory.transactionType.ReturnOrder>(params: {
-        typeOf: T;
+    cancelMoneyTransfer(params: {
+        typeOf: factory.transactionType.MoneyTransfer;
         id: string;
     }): Promise<void>;
     countMoneyTransfer<T extends factory.transactionType.MoneyTransfer>(params: factory.transaction.ISearchConditions<T>): Promise<{
@@ -154,7 +154,7 @@ export declare class TransactionRepo {
     /**
      * 取引を検索する
      */
-    findMoneyTransferTransactions<T extends factory.transactionType.MoneyTransfer, F extends IKeyOfProjection<T>>(params: factory.transaction.ISearchConditions<T> & {
+    findMoneyTransferTransactions<T extends factory.transactionType.MoneyTransfer, F extends IKeyOfProjection>(params: factory.transaction.ISearchConditions<T> & {
         inclusion: F[];
     }): Promise<(Pick<factory.transaction.ITransaction<T>, F> & {
         id: string;

package/lib/chevre/repo/transaction.js

@@ -47,7 +47,7 @@ const AVAILABLE_PROJECT_FIELDS = [
     'endDate',
     'tasksExportAction',
     'potentialActions',
-    'instrument'
+    // 'instrument'
 ];
 /**
  * 取引リポジトリ
@@ -185,27 +185,27 @@ class TransactionRepo {
     /**
      * 取引を開始する
      */
-    async startNoPlaceOrder(params) {
+    // public async startNoPlaceOrder<
+    async startMoneyTransfer(params) {
         const status = factory.transactionStatusType.InProgress;
         const tasksExportAction = { actionStatus: factory.actionStatusType.PotentialActionStatus };
         // const tasksExportationStatus = factory.transactionTasksExportationStatus.Unexported; // discontinue(2024-06-20~)
         const startDate = new Date();
-        let expires;
+        // let expires: Date;
         const { typeOf } = params;
-        if (typeOf === factory.transactionType.ReturnOrder) {
-            // expiresInSecondsの指定があれば優先して適用する(2022-11-25~)
-            if (typeof params.expiresInSeconds === 'number' && params.expiresInSeconds > 0) {
-                expires = (0, moment_1.default)(startDate)
-                    .add(params.expiresInSeconds, 'seconds')
-                    .toDate();
-            }
-            else {
-                throw new factory.errors.ArgumentNull('expiresInSeconds');
-            }
-        }
-        else {
-            expires = params.expires;
-        }
+        // if (typeOf === factory.transactionType.ReturnOrder) {
+        //     // expiresInSecondsの指定があれば優先して適用する(2022-11-25~)
+        //     if (typeof params.expiresInSeconds === 'number' && params.expiresInSeconds > 0) {
+        //         expires = moment(startDate)
+        //             .add(params.expiresInSeconds, 'seconds')
+        //             .toDate();
+        //     } else {
+        //         throw new factory.errors.ArgumentNull('expiresInSeconds');
+        //     }
+        // } else {
+        //     expires = params.expires;
+        // }
+        const expires = params.expires;
         let creatingTransaction;
         if (typeOf === factory.transactionType.MoneyTransfer) {
             const { agent, project, object, seller, recipient } = params;
@@ -213,13 +213,12 @@ class TransactionRepo {
                 status, startDate, expires, typeOf, tasksExportAction,
                 agent, project, seller, object, recipient
             };
-        }
-        else if (typeOf === factory.transactionType.ReturnOrder) {
-            const { agent, project, object, seller } = params;
-            creatingTransaction = {
-                status, startDate, expires, typeOf, tasksExportAction,
-                agent, project, seller, object
-            };
+            // } else if (typeOf === factory.transactionType.ReturnOrder) {
+            //     const { agent, project, object, seller } = params;
+            //     creatingTransaction = {
+            //         status, startDate, expires, typeOf, tasksExportAction,
+            //         agent, project, seller, object
+            //     };
         }
         else {
             throw new factory.errors.NotImplemented(`${typeOf} not implemented`);
@@ -237,7 +236,7 @@ class TransactionRepo {
     /**
      * 特定取引検索
      */
-    async projectFieldsByIdNoPlaceOrder(params, inclusion // make required(2024-05-31~)
+    async findMoneyTransferById(params, inclusion // make required(2024-05-31~)
     ) {
         let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
         if (Array.isArray(inclusion) && inclusion.length > 0) {
@@ -528,7 +527,8 @@ class TransactionRepo {
     /**
      * 取引を確定する
      */
-    async confirmNoPlaceOrder(params) {
+    // public async confirmNoPlaceOrder<
+    async confirmMoneyTransfer(params) {
         const endDate = new Date();
         const doc = await this.transactionModel.findOneAndUpdate({
             _id: { $eq: params.id },
@@ -549,7 +549,7 @@ class TransactionRepo {
             .exec();
         // NotFoundであれば取引状態確認
         if (doc === null) {
-            const { expires, status } = await this.projectFieldsByIdNoPlaceOrder({ typeOf: params.typeOf, id: params.id }, ['expires', 'status']);
+            const { expires, status } = await this.findMoneyTransferById({ typeOf: params.typeOf, id: params.id }, ['expires', 'status']);
             if (status === factory.transactionStatusType.Confirmed) {
                 // すでに確定済の場合スルー
             }
@@ -897,7 +897,7 @@ class TransactionRepo {
     /**
      * 取引を中止する
      */
-    async cancelNoPlaceOrder(params) {
+    async cancelMoneyTransfer(params) {
         const endDate = new Date();
         // 進行中ステータスの取引を中止する
         const doc = await this.transactionModel.findOneAndUpdate({
@@ -915,7 +915,7 @@ class TransactionRepo {
             .exec();
         // NotFoundであれば取引状態確認
         if (doc === null) {
-            const { status } = await this.projectFieldsByIdNoPlaceOrder(params, ['status']);
+            const { status } = await this.findMoneyTransferById(params, ['status']);
             if (status === factory.transactionStatusType.Canceled) {
                 // すでに中止済の場合スルー
             }

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

@@ -2,13 +2,14 @@ import * as factory from '../../factory';
 import type { ActionRepo } from '../../repo/action';
 import type { PotentialActionRepo } from '../../repo/potentialAction';
 import type { SettingRepo } from '../../repo/setting';
+interface ITriggerWebhookRepos {
+    action: ActionRepo;
+    potentialAction: PotentialActionRepo;
+    setting: SettingRepo;
+}
 declare function triggerWebhook(params: factory.task.IData<factory.taskName.TriggerWebhook> & {
     project: {
         id: string;
     };
-}): (repos: {
-    action: ActionRepo;
-    potentialAction: PotentialActionRepo;
-    setting: SettingRepo;
-}) => Promise<void>;
-export { triggerWebhook };
+}): (repos: ITriggerWebhookRepos) => Promise<void>;
+export { ITriggerWebhookRepos, triggerWebhook };

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

@@ -40,4 +40,4 @@ declare function voidTransactionByActionId(params: factory.task.IData<factory.ta
         id: string;
     };
 }): (repos: IVoidTransactionByActionIdRepos, settings: Settings) => Promise<void>;
-export { voidTransactionByActionId };
+export { IVoidTransactionByActionIdRepos, voidTransactionByActionId };

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/sendOrder.js

@@ -30,7 +30,7 @@ exports.sendOrder = sendOrder;
 const debug_1 = __importDefault(require("debug"));
 // import { createMaskedCustomer } from '../../factory/order';
 const factory_1 = require("../delivery/factory");
-const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
+// import { findPlaceOrderTransaction } from './findPlaceOrderTransaction';
 const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
 const factory = __importStar(require("../../factory"));
 // import { Settings } from '../../settings';
@@ -60,11 +60,11 @@ function sendOrder(params) {
         try {
             const orderNumber = params.object.orderNumber;
             const confirmationNumber = params.object.confirmationNumber;
-            const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-                project: { id: params.project.id },
-                confirmationNumber,
-                orderNumber
-            })(repos);
+            // const placeOrderTransaction = await findPlaceOrderTransaction({
+            //     project: { id: params.project.id },
+            //     confirmationNumber,
+            //     orderNumber
+            // })(repos);
             // 注文取得
             let order = await repos.order.projectFieldsByOrderNumber({
                 orderNumber,
@@ -182,8 +182,8 @@ function sendOrder(params) {
                             orderStatus: factory.orderStatus.OrderDelivered,
                             price: order.price,
                             priceCurrency: order.priceCurrency
-                        },
-                        placeOrderTransaction
+                        }
+                        // placeOrderTransaction
                     })(repos);
                 }
                 else {

package/lib/chevre/service/payment/any/onPayActionCompleted.d.ts

@@ -5,9 +5,13 @@ import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
 import type { ActionRepo } from '../../../repo/action';
 import type { TaskRepo } from '../../../repo/task';
-declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: {
+interface IOnPayActionCompletedRepos {
     action: ActionRepo;
     accountingReport: AccountingReportRepo;
     task: TaskRepo;
-}) => Promise<void>;
-export { onPayActionCompleted };
+}
+/**
+ * 決済アクション完了時処理
+ */
+declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: IOnPayActionCompletedRepos) => Promise<void>;
+export { IOnPayActionCompletedRepos, onPayActionCompleted };

package/lib/chevre/service/payment/any/onPayActionCompleted.js

@@ -30,6 +30,9 @@ exports.onPayActionCompleted = onPayActionCompleted;
 const factory = __importStar(require("../../../factory"));
 const factory_1 = require("./factory");
 const onPaymentStatusChanged_1 = require("./onPaymentStatusChanged");
+/**
+ * 決済アクション完了時処理
+ */
 function onPayActionCompleted(payAction) {
     return async (repos) => {
         const aciton4inform = (0, factory_1.optimizeAction4inform)(payAction);

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

@@ -72,7 +72,7 @@ function start(params) {
         const { transactionNumber } = await repos.transactionNumber.publishByTimestamp({ startDate: new Date() });
         // 取引開始
         const startParams = (0, factory_2.createStartParams)(params, passport, seller, amount, fromLocation, toLocation, transactionNumber);
-        const transaction = await repos.transaction.startNoPlaceOrder(startParams);
+        const transaction = await repos.transaction.startMoneyTransfer(startParams);
         await authorizePaymentCard({
             transaction: {
                 ...transaction,
@@ -566,7 +566,7 @@ function validateToLocation(project, toLocationBeforeStart, issuedThrough) {
 function confirm(params) {
     return async (repos) => {
         const now = new Date();
-        const transaction = await repos.transaction.projectFieldsByIdNoPlaceOrder({
+        const transaction = await repos.transaction.findMoneyTransferById({
             typeOf: factory.transactionType.MoneyTransfer,
             id: params.id
         }, ['typeOf', 'status', 'project']);
@@ -591,7 +591,7 @@ function confirm(params) {
         // ポストアクションを作成
         const potentialActions = await (0, potentialActions_1.createPotentialActions)({ authorizeActions, transaction });
         // 取引確定
-        await repos.transaction.confirmNoPlaceOrder({
+        await repos.transaction.confirmMoneyTransfer({
             typeOf: factory.transactionType.MoneyTransfer,
             id: transaction.id,
             result: {},
@@ -625,7 +625,7 @@ function exportTasksById(params) {
     return async (repos
     // settings: Settings
     ) => {
-        const transaction = await repos.transaction.projectFieldsByIdNoPlaceOrder({
+        const transaction = await repos.transaction.findMoneyTransferById({
             typeOf: factory.transactionType.MoneyTransfer,
             id: params.id
         }, ['endDate', 'status', 'project', 'startDate', 'typeOf', 'object', 'potentialActions']);

package/lib/chevre/service/transaction/returnOrder/preStart.d.ts

@@ -31,4 +31,4 @@ declare function preStart(params: factory.transaction.returnOrder.IStartParamsWi
     seller: IFixedSeller;
     expiresInSeconds: number;
 }>;
-export { preStart };
+export { IPreStartOperationRepos, preStart };

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

@@ -13,7 +13,7 @@ import type { SellerRepo } from '../../repo/seller';
 import type { SellerReturnPolicyRepo } from '../../repo/sellerReturnPolicy';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
-import type { IStartedTransaction, TransactionRepo } from '../../repo/transaction';
+import type { IStartedTransaction, ReturnOrderRepo } from '../../repo/transaction/returnOrder';
 import { preStart } from './returnOrder/preStart';
 interface IStartOperationRepos {
     acceptedOffer: AcceptedOfferRepo;
@@ -26,18 +26,27 @@ interface IStartOperationRepos {
     reservation: ReservationRepo;
     seller: SellerRepo;
     sellerReturnPolicy: SellerReturnPolicyRepo;
-    transaction: TransactionRepo;
+    returnOrder: ReturnOrderRepo;
 }
 type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
-type ITaskAndTransactionOperation<T> = (repos: {
+interface IExportTasksByIdRepos {
     setting: SettingRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
-}) => Promise<T>;
+    returnOrder: ReturnOrderRepo;
+}
+type ITaskAndTransactionOperation<T> = (repos: IExportTasksByIdRepos) => Promise<T>;
 /**
  * 返品取引開始
  */
 declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail): IStartOperation<IStartedTransaction>;
+interface IConfirmRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    emailMessage?: EmailMessageRepo;
+    message: MessageRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    returnOrder: ReturnOrderRepo;
+}
 /**
  * 取引確定
  */
@@ -47,14 +56,7 @@ declare function confirm(params: factory.transaction.returnOrder.IConfirmParams
             dateReturned: Date;
         };
     };
-}): (repos: {
-    acceptedOffer: AcceptedOfferRepo;
-    emailMessage?: EmailMessageRepo;
-    message: MessageRepo;
-    order: OrderRepo;
-    setting: SettingRepo;
-    transaction: TransactionRepo;
-}) => Promise<import("@chevre/factory/lib/transaction/returnOrder").IResult | undefined>;
+}): (repos: IConfirmRepos) => Promise<import("@chevre/factory/lib/transaction/returnOrder").IResult | undefined>;
 /**
  * 取引のタスクを出力します
  * 複数タスクが生成されます
@@ -67,4 +69,4 @@ declare function exportTasksById(params: {
      */
     runsTasksAfterInSeconds?: number;
 }): ITaskAndTransactionOperation<void>;
-export { preStart, start, confirm, exportTasksById };
+export { IStartOperationRepos, IConfirmRepos, IExportTasksByIdRepos, preStart, start, confirm, exportTasksById };

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

@@ -60,7 +60,7 @@ function start(params) {
         };
         let returnOrderTransaction;
         try {
-            returnOrderTransaction = await repos.transaction.startNoPlaceOrder(returnOrderAttributes);
+            returnOrderTransaction = await repos.returnOrder.startReturnOrder(returnOrderAttributes);
         }
         catch (error) {
             if (await (0, errorHandler_1.isMongoError)(error)) {
@@ -108,7 +108,7 @@ function confirm(params) {
     return async (repos
     // settings: Settings
     ) => {
-        const transaction = await repos.transaction.projectFieldsByIdNoPlaceOrder({ typeOf: factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'agent', 'object', 'result']);
+        const transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'agent', 'object', 'result']);
         if (transaction.status === factory.transactionStatusType.Confirmed) {
             // すでに確定済の場合
             return transaction.result;
@@ -169,7 +169,7 @@ function confirm(params) {
             order: { orderNumber: returningOrders[0].orderNumber }, seller: { id: returningOrders[0].seller.id }, emailMessages
         })(repos);
         // ステータス変更
-        await repos.transaction.confirmNoPlaceOrder({
+        await repos.returnOrder.confirmReturnOrder({
             typeOf: transaction.typeOf,
             id: transaction.id,
             result, potentialActions
@@ -186,7 +186,7 @@ function exportTasksById(params) {
     return async (repos
     // settings: Settings
     ) => {
-        const transaction = await repos.transaction.projectFieldsByIdNoPlaceOrder({ typeOf: factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'endDate', 'startDate', 'object', 'potentialActions']);
+        const transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'endDate', 'startDate', 'object', 'potentialActions']);
         // タスク実行日時バッファの指定があれば調整
         let taskRunsAt = new Date();
         if (typeof params.runsTasksAfterInSeconds === 'number') {

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

@@ -6,6 +6,7 @@ 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';
 import { deleteTransaction } from './transaction/deleteTransaction';
 import * as MoneyTransferTransactionService from './transaction/moneyTransfer';
 import * as PlaceOrderTransactionService from './transaction/placeOrder';
@@ -21,6 +22,7 @@ export type IExportTasksOperation<T> = (repos: {
     setting: SettingRepo;
     task: TaskRepo;
     placeOrder: PlaceOrderRepo;
+    returnOrder: ReturnOrderRepo;
     transaction: TransactionRepo;
 }) => Promise<T>;
 export declare function exportOneTransactionTasksIfExists(params: {

package/package.json

@@ -99,5 +99,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "24.0.0-alpha.13"
+  "version": "24.0.0-alpha.15"
 }