@chevre/domain 27.1.0-alpha.9 → 28.0.0-alpha.0

package/lib/chevre/repo/mongoose/schemas/transaction.js

@@ -97,15 +97,6 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'object.order.orderNumber': 1, startDate: -1 },
-        {
-            name: 'searchByObjectOrderNumberAndStartDate',
-            partialFilterExpression: {
-                'object.order.orderNumber': { $exists: true }
-            }
-        }
-    ],
     [
         // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
         {
@@ -121,19 +112,6 @@ const indexes = [
             }
         }
     ],
-    [
-        // ひとつの注文取引に対する確定返品取引はユニークなはず
-        { 'object.order.orderNumber': 1 },
-        {
-            name: 'object.order.orderNumber_1',
-            unique: true,
-            partialFilterExpression: {
-                typeOf: factory_1.factory.transactionType.ReturnOrder, // 返品取引
-                status: factory_1.factory.transactionStatusType.Confirmed, // 確定ステータス
-                'object.order.orderNumber': { $exists: true }
-            }
-        }
-    ],
     [
         { 'agent.typeOf': 1, startDate: -1 },
         {
@@ -210,55 +188,27 @@ const indexes = [
                 'tasksExportAction.startDate': { $exists: true }
             }
         }
-    ]
-    // result.order廃止につきインデックス廃止(2026-06-28~)
-    // [
-    //     { 'result.order.confirmationNumber': 1, startDate: -1 },
-    //     {
-    //         name: 'searchByResultOrderConfirmationNumber',
-    //         partialFilterExpression: {
-    //             'result.order.confirmationNumber': { $exists: true }
-    //         }
-    //     }
-    // ],
-    // [
-    //     { 'result.order.orderNumber': 1, startDate: -1 },
-    //     {
-    //         name: 'searchByResultOrderNumberAndStartDate',
-    //         partialFilterExpression: {
-    //             'result.order.orderNumber': { $exists: true }
-    //         }
-    //     }
-    // ],
-    // result.order廃止につきインデックス廃止(2026-06-28~)
+    ],
+    // typeOf: ReturnOrder廃止につき以下廃止(2026-09-08~)
     // [
-    //     // 結果の注文番号はユニークなはず
+    //     { 'object.order.orderNumber': 1, startDate: -1 },
     //     {
-    //         typeOf: 1,
-    //         'result.order.orderNumber': 1
-    //     },
-    //     {
-    //         name: 'searchPlaceOrderByOrderNumber',
-    //         unique: true,
+    //         name: 'searchByObjectOrderNumberAndStartDate',
     //         partialFilterExpression: {
-    //             'result.order.orderNumber': { $exists: true }
+    //             'object.order.orderNumber': { $exists: true }
     //         }
     //     }
     // ],
-    // uniquePlacingOrderNumberと重複しているので廃止(2026-06-28~)
     // [
-    //     // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
-    //     {
-    //         typeOf: 1,
-    //         'object.orderNumber': 1
-    //     },
+    //     // ひとつの注文取引に対する確定返品取引はユニークなはず
+    //     { 'object.order.orderNumber': 1 },
     //     {
-    //         name: 'uniquePlacingOrderNumber20260221',
+    //         name: 'object.order.orderNumber_1',
     //         unique: true,
     //         partialFilterExpression: {
-    //             typeOf: factory.transactionType.PlaceOrder,
-    //             'object.orderNumber': { $exists: true },
-    //             startDate: { $gte: new Date('2026-02-21T11:00:00Z') }
+    //             typeOf: factory.transactionType.ReturnOrder, // 返品取引
+    //             status: factory.transactionStatusType.Confirmed, // 確定ステータス
+    //             'object.order.orderNumber': { $exists: true }
     //         }
     //     }
     // ],

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

@@ -1,6 +1,7 @@
 import type { RedisClientType } from '@redis/client';
 import { factory } from '../../factory';
-import type { IStartedTransaction } from './returnOrder';
+type IStartedTransactionFields = 'expires' | 'id' | 'startDate' | 'status';
+export type IStartedTransaction = Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, IStartedTransactionFields>;
 /**
  * 返品取引リポジトリ
  */
@@ -17,3 +18,4 @@ export declare class ReturnOrderInProgressRepo {
         id: string;
     }): Promise<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>>;
 }
+export {};

package/lib/chevre/repository.d.ts

@@ -113,7 +113,6 @@ import type { TaskDelayedRepo } from './repo/taskDelayed';
 import type { TicketRepo } from './repo/ticket';
 import type { TransactionRepo } from './repo/transaction';
 import type { PlaceOrderRepo } from './repo/transaction/placeOrder';
-import type { ReturnOrderRepo } from './repo/transaction/returnOrder';
 import type { ReturnOrderInProgressRepo } from './repo/transaction/returnOrderInProgress';
 import type { TransactionNumberRepo } from './repo/transactionNumber';
 import type { TransactionProcessRepo } from './repo/transactionProcess';
@@ -604,10 +603,6 @@ export declare namespace transaction {
     namespace PlaceOrder {
         function createInstance(...params: ConstructorParameters<typeof PlaceOrderRepo>): Promise<PlaceOrderRepo>;
     }
-    type ReturnOrder = ReturnOrderRepo;
-    namespace ReturnOrder {
-        function createInstance(...params: ConstructorParameters<typeof ReturnOrderRepo>): Promise<ReturnOrderRepo>;
-    }
     type ReturnOrderInProgress = ReturnOrderInProgressRepo;
     namespace ReturnOrderInProgress {
         function createInstance(...params: ConstructorParameters<typeof ReturnOrderInProgressRepo>): Promise<ReturnOrderInProgressRepo>;

package/lib/chevre/repository.js

@@ -1288,17 +1288,6 @@ var transaction;
         }
         PlaceOrder.createInstance = createInstance;
     })(PlaceOrder = transaction.PlaceOrder || (transaction.PlaceOrder = {}));
-    let ReturnOrder;
-    (function (ReturnOrder) {
-        let repo;
-        async function createInstance(...params) {
-            if (repo === undefined) {
-                repo = (await import('./repo/transaction/returnOrder.js')).ReturnOrderRepo;
-            }
-            return new repo(...params);
-        }
-        ReturnOrder.createInstance = createInstance;
-    })(ReturnOrder = transaction.ReturnOrder || (transaction.ReturnOrder = {}));
     let ReturnOrderInProgress;
     (function (ReturnOrderInProgress) {
         let repo;

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

@@ -11,7 +11,6 @@ const note_1 = require("../../repo/note");
 const order_1 = require("../../repo/order");
 const reservation_1 = require("../../repo/reservation");
 const placeOrder_1 = require("../../repo/transaction/placeOrder");
-const returnOrder_1 = require("../../repo/transaction/returnOrder");
 const transaction_1 = require("../transaction");
 /**
  * タスク実行関数
@@ -32,7 +31,6 @@ function call(params) {
             order: new order_1.OrderRepo(connection),
             reservation: new reservation_1.ReservationRepo(connection),
             placeOrder: new placeOrder_1.PlaceOrderRepo(connection),
-            returnOrder: new returnOrder_1.ReturnOrderRepo(connection),
         });
     };
 }

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

@@ -9,7 +9,6 @@ import type { NoteRepo } from '../../repo/note';
 import type { OrderRepo } from '../../repo/order';
 import type { ReservationRepo } from '../../repo/reservation';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
-import type { ReturnOrderRepo } from '../../repo/transaction/returnOrder';
 interface IDeleteTransactionRepos {
     acceptedOffer: AcceptedOfferRepo;
     adminAccountingReport: AdminAccountingReportRepo;
@@ -23,7 +22,6 @@ interface IDeleteTransactionRepos {
     order: OrderRepo;
     reservation: ReservationRepo;
     placeOrder: PlaceOrderRepo;
-    returnOrder: ReturnOrderRepo;
 }
 /**
  * 取引に関わるリソースを削除する

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

@@ -41,11 +41,12 @@ function deleteTransactionById(params) {
             })).shift();
         }
         else if (params.object.typeOf === factory_1.factory.transactionType.ReturnOrder) {
-            transaction = (await repos.returnOrder.findReturnOrderTransactions({
-                ids: [deletingTransactionId],
-                typeOf: params.object.typeOf,
-                inclusion: ['typeOf', 'project', 'status']
-            })).shift();
+            // 廃止済(ドキュメントはマニュアルで削除済)につき何もしない(2026-09-08~)
+            // transaction = (await repos.returnOrder.findReturnOrderTransactions({
+            //     ids: [deletingTransactionId],
+            //     typeOf: params.object.typeOf,
+            //     inclusion: ['typeOf', 'project', 'status']
+            // })).shift();
         }
         else {
             throw new factory_1.factory.errors.NotImplemented(`object not implemented. typeOf:${params.object.typeOf}`);

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

@@ -1,7 +1,7 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
 export declare function createReturnPaymentMethodActions(params: {
-    order: Pick<factory.order.IOrder, 'confirmationNumber' | 'customer' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'price' | 'priceCurrency' | 'seller' | 'typeOf'>;
+    order: Pick<factory.order.IOrder, 'confirmationNumber' | 'customer' | 'orderDate' | 'orderNumber' | 'orderedItem' | 'paymentMethods' | 'price' | 'priceCurrency' | 'seller' | 'typeOf'>;
     returnOrderActionParams?: factory.transaction.returnOrder.IReturnOrderActionParams;
     transaction: Pick<factory.transaction.returnOrder.ITransaction, 'object'>;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{

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

@@ -11,10 +11,8 @@ import type { ReservationRepo } from '../../repo/reservation';
 import type { SellerRepo } from '../../repo/seller';
 import type { SellerReturnPolicyRepo } from '../../repo/sellerReturnPolicy';
 import type { SettingRepo } from '../../repo/setting';
-import type { ScheduledTaskRepo } from '../../repo/scheduledTask';
 import type { TaskRepo } from '../../repo/task';
-import type { IStartedTransaction, ReturnOrderRepo } from '../../repo/transaction/returnOrder';
-import type { ReturnOrderInProgressRepo } from '../../repo/transaction/returnOrderInProgress';
+import type { IStartedTransaction, ReturnOrderInProgressRepo } from '../../repo/transaction/returnOrderInProgress';
 import { preStart } from './returnOrder/preStart';
 interface IStartOperationRepos {
     acceptedOffer: AcceptedOfferRepo;
@@ -27,29 +25,18 @@ interface IStartOperationRepos {
     reservation: ReservationRepo;
     seller: SellerRepo;
     sellerReturnPolicy: SellerReturnPolicyRepo;
-    returnOrder: ReturnOrderRepo;
     returnOrderInProgress: ReturnOrderInProgressRepo;
 }
 type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
-interface IExportTasksByIdRepos {
-    setting: SettingRepo;
-    scheduledTask: ScheduledTaskRepo;
-    task: TaskRepo;
-    returnOrder: ReturnOrderRepo;
-}
-type ITaskAndTransactionOperation<T> = (repos: IExportTasksByIdRepos) => Promise<T>;
 /**
  * 返品取引開始
  */
-declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail, options: {
-    useConfirmReturnOrderTask: boolean;
-}): IStartOperation<IStartedTransaction>;
+declare function start(params: factory.transaction.returnOrder.IStartParamsWithoutDetail): IStartOperation<IStartedTransaction>;
 interface IConfirmRepos {
     acceptedOffer: AcceptedOfferRepo;
     message: MessageRepo;
     order: OrderRepo;
     setting: SettingRepo;
-    returnOrder: ReturnOrderRepo;
     returnOrderInProgress: ReturnOrderInProgressRepo;
     task: TaskRepo;
 }
@@ -62,19 +49,5 @@ declare function confirm(params: factory.transaction.returnOrder.IConfirmParams
             dateReturned: Date;
         };
     };
-}, options: {
-    useConfirmReturnOrderTask: boolean;
-}): (repos: IConfirmRepos) => Promise<import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined>;
-/**
- * 取引のタスクを出力します
- * 複数タスクが生成されます
- * この関数では、取引のタスクエクスポートステータスは見ません
- */
-declare function exportTasksById(params: {
-    id: string;
-    /**
-     * タスク実行日時バッファ
-     */
-    runsTasksAfterInSeconds?: number;
-}): ITaskAndTransactionOperation<void>;
-export { IStartOperationRepos, IConfirmRepos, IExportTasksByIdRepos, preStart, start, confirm, exportTasksById };
+}): (repos: IConfirmRepos) => Promise<import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult>;
+export { IStartOperationRepos, IConfirmRepos, preStart, start, confirm, };

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

@@ -1,29 +1,21 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preStart = void 0;
 exports.start = start;
 exports.confirm = confirm;
-exports.exportTasksById = exportTasksById;
 /**
  * 返品取引サービス
  */
-const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const util_1 = require("util");
 const factory_1 = require("../../factory");
-const factory_2 = require("./returnOrder/exportTasks/factory");
 const potentialActions_1 = require("./returnOrder/potentialActions");
 const preStart_1 = require("./returnOrder/preStart");
 Object.defineProperty(exports, "preStart", { enumerable: true, get: function () { return preStart_1.preStart; } });
-const errorHandler_1 = require("../../errorHandler");
 /**
  * 返品取引開始
  */
-function start(params, options) {
+function start(params) {
     return async (repos) => {
-        const { useConfirmReturnOrderTask } = options;
         const { transactionObject, expiresInSeconds, seller } = await (0, preStart_1.preStart)(params)(repos);
         const returnOrderAttributes = {
             project: params.project,
@@ -37,23 +29,7 @@ function start(params, options) {
             object: transactionObject,
             expiresInSeconds
         };
-        let returnOrderTransaction;
-        if (useConfirmReturnOrderTask) {
-            returnOrderTransaction = await repos.returnOrderInProgress.startReturnOrder(returnOrderAttributes);
-        }
-        else {
-            try {
-                returnOrderTransaction = await repos.returnOrder.startReturnOrder(returnOrderAttributes);
-            }
-            catch (error) {
-                if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
-                    // 同一取引に対して返品取引を作成しようとすると、MongoDBでE11000 duplicate key errorが発生する
-                    throw new factory_1.factory.errors.Argument('orderNumber', 'Already returned');
-                }
-                throw error;
-            }
-        }
-        return returnOrderTransaction;
+        return repos.returnOrderInProgress.startReturnOrder(returnOrderAttributes);
     };
 }
 function saveMessagesIfNeeded(params) {
@@ -85,26 +61,9 @@ function saveMessagesIfNeeded(params) {
 /**
  * 取引確定
  */
-function confirm(params, options) {
+function confirm(params) {
     return async (repos) => {
-        const { useConfirmReturnOrderTask } = options;
-        let transaction;
-        if (useConfirmReturnOrderTask) {
-            transaction = await repos.returnOrderInProgress.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id });
-        }
-        else {
-            transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'agent', 'object', 'result', 'startDate']);
-            if (transaction.status === factory_1.factory.transactionStatusType.Confirmed) {
-                // すでに確定済の場合
-                return transaction.result;
-            }
-            else if (transaction.status === factory_1.factory.transactionStatusType.Expired) {
-                throw new factory_1.factory.errors.Argument('transaction', 'Transaction already expired');
-            }
-            else if (transaction.status === factory_1.factory.transactionStatusType.Canceled) {
-                throw new factory_1.factory.errors.Argument('transaction', 'Transaction already canceled');
-            }
-        }
+        const transaction = await repos.returnOrderInProgress.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id });
         if (typeof params.agent?.id === 'string' && transaction.agent.id !== params.agent.id) {
             throw new factory_1.factory.errors.Forbidden('Transaction not yours');
         }
@@ -113,7 +72,7 @@ function confirm(params, options) {
             throw new factory_1.factory.errors.Argument('object.order', 'number of orders must be 1');
         }
         const returningOrders = await repos.order.projectFields({
-            limit: 1,
+            limit: 1, // 1に限定なので1で十分
             page: 1,
             project: { id: { $eq: transaction.project.id } },
             confirmationNumbers: [transaction.object.order[0].confirmationNumber],
@@ -124,6 +83,14 @@ function confirm(params, options) {
                 'orderedItem', 'paymentMethods', 'price', 'priceCurrency', 'project', 'seller', 'typeOf'
             ]
         });
+        if (returningOrders.length === 0) {
+            throw new factory_1.factory.errors.NotFound(factory_1.factory.order.OrderType.Order);
+        }
+        // 既に返品済であれば400(2026-09-08~)
+        const orderStatus = returningOrders[0].orderStatus;
+        if (orderStatus === factory_1.factory.orderStatus.OrderReturned) {
+            throw new factory_1.factory.errors.Argument('orderNumber', `invalid orderStatus: ${orderStatus}`);
+        }
         const setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['defaultSenderEmail']);
         if (typeof setting?.defaultSenderEmail !== 'string') {
             throw new factory_1.factory.errors.NotFound('setting.defaultSenderEmail');
@@ -143,72 +110,30 @@ function confirm(params, options) {
             project: { id: transaction.project.id },
             order: { orderNumber: returningOrders[0].orderNumber }, seller: { id: returningOrders[0].seller.id }, emailMessages
         })(repos);
-        if (useConfirmReturnOrderTask) {
-            // タスク作成(注文番号でユニークネス保証)
-            const taskIdentifier = (0, util_1.format)('%s:%s:%s', transaction.project.id, factory_1.factory.taskName.ConfirmReturnOrder, returningOrders[0].orderNumber);
-            const endDate = new Date();
-            const confirmReturnOrderTask = {
-                identifier: taskIdentifier,
-                project: transaction.project,
-                name: factory_1.factory.taskName.ConfirmReturnOrder,
-                status: factory_1.factory.taskStatus.Ready,
-                runsAt: endDate,
-                remainingNumberOfTries: 10,
-                numberOfTried: 0,
-                executionResults: [],
-                data: {
-                    typeOf: transaction.typeOf,
-                    id: transaction.id,
-                    agent: transaction.agent,
-                    startDate: transaction.startDate,
-                    object: transaction.object,
-                    project: transaction.project,
-                    potentialActions,
-                    endDate
-                }
-            };
-            await repos.task.runTaskByIdentifier(confirmReturnOrderTask);
-        }
-        else {
-            // ステータス変更
-            await repos.returnOrder.confirmReturnOrder({
+        // タスク作成(注文番号でユニークネス保証)
+        const taskIdentifier = (0, util_1.format)('%s:%s:%s', transaction.project.id, factory_1.factory.taskName.ConfirmReturnOrder, returningOrders[0].orderNumber);
+        const endDate = new Date();
+        const confirmReturnOrderTask = {
+            identifier: taskIdentifier,
+            project: transaction.project,
+            name: factory_1.factory.taskName.ConfirmReturnOrder,
+            status: factory_1.factory.taskStatus.Ready,
+            runsAt: endDate,
+            remainingNumberOfTries: 10,
+            numberOfTried: 0,
+            executionResults: [],
+            data: {
                 typeOf: transaction.typeOf,
                 id: transaction.id,
-                result, potentialActions
-            });
-        }
+                agent: transaction.agent,
+                startDate: transaction.startDate,
+                object: transaction.object,
+                project: transaction.project,
+                potentialActions,
+                endDate
+            }
+        };
+        await repos.task.runTaskByIdentifier(confirmReturnOrderTask);
         return result;
     };
 }
-/**
- * 取引のタスクを出力します
- * 複数タスクが生成されます
- * この関数では、取引のタスクエクスポートステータスは見ません
- */
-function exportTasksById(params) {
-    return async (repos) => {
-        const transaction = await repos.returnOrder.findReturnOrderById({ typeOf: factory_1.factory.transactionType.ReturnOrder, id: params.id }, ['typeOf', 'status', 'project', 'endDate', 'startDate', 'object', 'potentialActions']);
-        // タスク実行日時バッファの指定があれば調整
-        let taskRunsAt = new Date();
-        if (typeof params.runsTasksAfterInSeconds === 'number') {
-            taskRunsAt = (0, moment_timezone_1.default)(taskRunsAt)
-                .add(params.runsTasksAfterInSeconds, 'seconds')
-                .toDate();
-        }
-        // search settings
-        const setting = await repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['storage']);
-        const deleteTransactionTaskExpiresInDays = setting?.storage?.deleteTransactionTaskExpiresInDays;
-        if (typeof deleteTransactionTaskExpiresInDays !== 'number') {
-            throw new factory_1.factory.errors.Internal('settings.storage.deleteTransactionTaskExpiresInDays required');
-        }
-        const deleteTask = (0, factory_2.createScheduledTasks)({ transaction }, setting);
-        // support scheduledTask(2026-08-02~)
-        await repos.task.saveMany((0, factory_2.createImmediateTasks)({ transaction, taskRunsAt }));
-        await repos.scheduledTask.addScheduledTasks([{
-                ...deleteTask,
-                expires: (0, moment_timezone_1.default)(deleteTask.runsAt)
-                    .add(deleteTransactionTaskExpiresInDays, 'days')
-                    .toDate()
-            }]);
-    };
-}

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

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

package/lib/chevre/service/transaction.js

@@ -70,13 +70,7 @@ function exportOneTransactionTasksIfExists(params) {
                 })(repos);
                 break;
             case factory_1.factory.transactionType.ReturnOrder:
-                await ReturnOrderTransactionService.exportTasksById({
-                    id: transaction.id,
-                    ...(typeof params.runsTasksAfterInSeconds === 'number')
-                        ? { runsTasksAfterInSeconds: params.runsTasksAfterInSeconds }
-                        : undefined
-                })(repos);
-                break;
+                throw new factory_1.factory.errors.NotImplemented(`${factory_1.factory.transactionType.ReturnOrder} not implemented`);
             default:
         }
         await repos.transaction.setTasksExportedById({ id: transaction.id });

package/package.json

@@ -88,5 +88,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "27.1.0-alpha.9"
+  "version": "28.0.0-alpha.0"
 }

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

@@ -1,45 +0,0 @@
-import type { Connection, FilterQuery } from 'mongoose';
-import { 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>;
-/**
- * 返品取引リポジトリ
- */
-export declare class ReturnOrderRepo {
-    private readonly transactionModel;
-    constructor(connection: Connection);
-    static CREATE_MONGO_CONDITIONS(params: factory.transaction.ISearchConditions<factory.transactionType.ReturnOrder>): FilterQuery<import("@chevre/factory/lib/chevre/transaction/returnOrder").ITransaction>[];
-    countReturnOrder(params: factory.transaction.ISearchConditions<factory.transactionType.ReturnOrder>): Promise<{
-        count: number;
-    }>;
-    /**
-     * 取引を検索する
-     */
-    findReturnOrderTransactions(params: factory.transaction.ISearchConditions<factory.transactionType.ReturnOrder> & {
-        inclusion: IKeyOfProjection[];
-    }): 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

@@ -1,294 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturnOrderRepo = void 0;
-const moment_1 = __importDefault(require("moment"));
-const transaction_1 = require("../../eventEmitter/transaction");
-const factory_1 = require("../../factory");
-const settings_1 = require("../../settings");
-const transaction_2 = require("../mongoose/schemas/transaction");
-const AVAILABLE_PROJECT_FIELDS = [
-    'project',
-    'status',
-    'typeOf',
-    'agent',
-    'recipient',
-    'seller',
-    'error',
-    'result',
-    'object',
-    'expires',
-    'startDate',
-    'endDate',
-    'tasksExportAction',
-    'potentialActions',
-    // 'instrument'
-];
-/**
- * 返品取引リポジトリ
- */
-class ReturnOrderRepo {
-    transactionModel;
-    constructor(connection) {
-        this.transactionModel = connection.model(transaction_2.modelName, (0, transaction_2.createSchema)());
-    }
-    static CREATE_MONGO_CONDITIONS(params) {
-        if (params.typeOf !== factory_1.factory.transactionType.ReturnOrder) {
-            throw new factory_1.factory.errors.Argument('typeOf', `must be ${factory_1.factory.transactionType.ReturnOrder}`);
-        }
-        const andConditions = [];
-        const projectIdEq = params.project?.id?.$eq;
-        if (typeof projectIdEq === 'string') {
-            andConditions.push({ 'project.id': { $eq: projectIdEq } });
-        }
-        if (typeof params.typeOf === 'string') {
-            andConditions.push({ typeOf: { $eq: params.typeOf } });
-        }
-        if (params.startFrom !== undefined) {
-            andConditions.push({
-                startDate: { $gte: params.startFrom }
-            });
-        }
-        if (params.startThrough !== undefined) {
-            andConditions.push({
-                startDate: { $lte: params.startThrough }
-            });
-        }
-        if (params.endFrom !== undefined) {
-            andConditions.push({
-                endDate: {
-                    $exists: true,
-                    $gte: params.endFrom
-                }
-            });
-        }
-        if (params.endThrough !== undefined) {
-            andConditions.push({
-                endDate: {
-                    $exists: true,
-                    $lt: params.endThrough
-                }
-            });
-        }
-        if (Array.isArray(params.ids)) {
-            andConditions.push({
-                _id: { $in: params.ids }
-            });
-        }
-        if (Array.isArray(params.statuses)) {
-            andConditions.push({ status: { $in: params.statuses } });
-        }
-        const statusIn = params.status?.$in;
-        if (Array.isArray(statusIn)) {
-            andConditions.push({ status: { $in: statusIn } });
-        }
-        if (params.agent !== undefined) {
-            if (params.agent.typeOf !== undefined) {
-                andConditions.push({
-                    'agent.typeOf': {
-                        $exists: true,
-                        $eq: params.agent.typeOf
-                    }
-                });
-            }
-            if (Array.isArray(params.agent.ids)) {
-                andConditions.push({
-                    'agent.id': {
-                        $exists: true,
-                        $in: params.agent.ids
-                    }
-                });
-            }
-            if (Array.isArray(params.agent.identifiers)) {
-                andConditions.push({
-                    'agent.identifier': {
-                        $exists: true,
-                        $in: params.agent.identifiers
-                    }
-                });
-            }
-        }
-        const tasksExportActionStatusIn = params.tasksExportAction?.actionStatus?.$in;
-        if (Array.isArray(tasksExportActionStatusIn)) {
-            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $in: tasksExportActionStatusIn } });
-        }
-        const tasksExportActionStatusEq = params.tasksExportAction?.actionStatus?.$eq;
-        if (typeof tasksExportActionStatusEq === 'string') {
-            andConditions.push({ 'tasksExportAction.actionStatus': { $exists: true, $eq: tasksExportActionStatusEq } });
-        }
-        if (params.object !== undefined) {
-            if (params.object.order !== undefined) {
-                if (Array.isArray(params.object.order.orderNumbers)) {
-                    andConditions.push({
-                        'object.order.orderNumber': {
-                            $exists: true,
-                            $in: params.object.order.orderNumbers
-                        }
-                    });
-                }
-            }
-        }
-        return andConditions;
-    }
-    async countReturnOrder(params) {
-        const { limit } = params;
-        const conditions = ReturnOrderRepo.CREATE_MONGO_CONDITIONS(params);
-        const query = this.transactionModel.countDocuments((conditions.length > 0) ? { $and: conditions } : {});
-        if (typeof limit === 'number' && limit >= 0) {
-            query.limit(limit);
-        }
-        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
-            .exec();
-        return { count };
-    }
-    /**
-     * 取引を検索する
-     */
-    async findReturnOrderTransactions(params) {
-        const { inclusion } = params;
-        const conditions = ReturnOrderRepo.CREATE_MONGO_CONDITIONS(params);
-        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
-        if (Array.isArray(inclusion) && inclusion.length > 0) {
-            positiveProjectionFields = positiveProjectionFields.filter((key) => inclusion.includes(key));
-        }
-        const projection = {
-            _id: 0,
-            id: { $toString: '$_id' },
-            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
-        };
-        const query = this.transactionModel.find((conditions.length > 0) ? { $and: conditions } : {})
-            .select(projection);
-        if (typeof params.limit === 'number' && params.limit > 0) {
-            const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
-            query.limit(params.limit)
-                .skip(params.limit * (page - 1));
-        }
-        if (params.sort?.startDate !== undefined) {
-            query.sort({ startDate: params.sort.startDate });
-        }
-        // const explainResult = await (<any>query).explain();
-        // console.log(explainResult[0].executionStats.allPlansExecution.map((e: any) => e.executionStages.inputStage));
-        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
-            .lean()
-            .exec();
-    }
-    /**
-     * 取引を開始する
-     */
-    async startReturnOrder(params) {
-        const status = factory_1.factory.transactionStatusType.InProgress;
-        const tasksExportAction = { actionStatus: factory_1.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_1.factory.errors.ArgumentNull('expiresInSeconds');
-        }
-        let creatingTransaction;
-        if (typeOf === factory_1.factory.transactionType.ReturnOrder) {
-            const { agent, project, object, seller } = params;
-            creatingTransaction = {
-                status, startDate, expires, typeOf, tasksExportAction,
-                agent, project, seller, object
-            };
-        }
-        else {
-            throw new factory_1.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_1.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_1.factory.errors.NotImplemented('inclusion must be specified'); // 2024-08-26~
-        }
-        const projection = {
-            _id: 0,
-            id: { $toString: '$_id' },
-            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
-        };
-        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_1.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_1.factory.transactionStatusType.InProgress },
-            expires: { $gt: endDate } // add expires(2025-02-27~)
-        }, {
-            status: factory_1.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_1.factory.transactionStatusType.Confirmed) {
-                // すでに確定済の場合スルー
-            }
-            else if (status === factory_1.factory.transactionStatusType.Expired) {
-                throw new factory_1.factory.errors.Argument('Transaction id', 'Already expired');
-            }
-            else if (status === factory_1.factory.transactionStatusType.Canceled) {
-                throw new factory_1.factory.errors.Argument('Transaction id', 'Already canceled');
-            }
-            else {
-                if ((0, moment_1.default)(expires)
-                    .isSameOrBefore((0, moment_1.default)(endDate))) {
-                    throw new factory_1.factory.errors.Argument('Transaction id', 'potentially expired');
-                }
-                throw new factory_1.factory.errors.NotFound(this.transactionModel.modelName, `${params.typeOf} ${factory_1.factory.transactionStatusType.InProgress} not found`);
-            }
-        }
-        transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
-            id: params.id,
-            typeOf: params.typeOf,
-            status: factory_1.factory.transactionStatusType.Confirmed
-        });
-    }
-}
-exports.ReturnOrderRepo = ReturnOrderRepo;

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

@@ -1,19 +0,0 @@
-import type { ISetting } from '../../../../repo/setting';
-import { factory } from '../../../../factory';
-type IReturnOrderPotentialTask = factory.task.IAttributes<factory.taskName.ReturnOrder>;
-/**
- * 取引のタスクを作成する
- * 取引削除タスクを分離(2026-08-02~)
- */
-export declare function createImmediateTasks(params: {
-    transaction: Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, 'endDate' | 'status' | 'id' | 'project' | 'typeOf' | 'startDate' | 'object' | 'potentialActions'>;
-    taskRunsAt: Date;
-}): IReturnOrderPotentialTask[];
-/**
- * 取引のタスクを作成する
- * 取引削除タスクを分離(2026-08-02~)
- */
-export declare function createScheduledTasks(params: {
-    transaction: Pick<factory.transaction.ITransaction<factory.transactionType.ReturnOrder>, 'endDate' | 'status' | 'id' | 'project' | 'typeOf' | 'object'>;
-}, setting: Pick<ISetting, 'storage'> | null): factory.task.deleteTransaction.IAttributes;
-export {};

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

@@ -1,104 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImmediateTasks = createImmediateTasks;
-exports.createScheduledTasks = createScheduledTasks;
-const moment_1 = __importDefault(require("moment"));
-const factory_1 = require("../../../../factory");
-/**
- * 取引のタスクを作成する
- * 取引削除タスクを分離(2026-08-02~)
- */
-function createImmediateTasks(params) {
-    const taskAttributes = [];
-    const transaction = params.transaction;
-    const taskRunsAt = params.taskRunsAt;
-    switch (transaction.status) {
-        case factory_1.factory.transactionStatusType.Confirmed: {
-            const returnOrderPotentialActions = transaction.potentialActions?.returnOrder;
-            if (Array.isArray(returnOrderPotentialActions)) {
-                // 返品タスク
-                const returnOrderTask = returnOrderPotentialActions.map((r) => {
-                    const { object, potentialActions, typeOf } = transaction;
-                    // data最適化(2023-08-22~)
-                    const returnOrderTaskData = {
-                        agent: r.agent,
-                        object: r.object,
-                        project: transaction.project,
-                        typeOf: r.typeOf,
-                        returnOrderTransaction: { object, potentialActions, typeOf } // add(2026-09-05~)
-                    };
-                    return {
-                        project: transaction.project,
-                        name: factory_1.factory.taskName.ReturnOrder,
-                        status: factory_1.factory.taskStatus.Ready,
-                        runsAt: taskRunsAt,
-                        remainingNumberOfTries: 10,
-                        numberOfTried: 0,
-                        executionResults: [],
-                        data: returnOrderTaskData
-                    };
-                });
-                taskAttributes.push(...returnOrderTask);
-            }
-            break;
-        }
-        case factory_1.factory.transactionStatusType.Expired:
-            // 特にタスクなし
-            break;
-        default:
-            throw new factory_1.factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
-    }
-    return taskAttributes;
-}
-/**
- * 取引のタスクを作成する
- * 取引削除タスクを分離(2026-08-02~)
- */
-function createScheduledTasks(params, setting) {
-    const transaction = params.transaction;
-    const confirmedStoragePeriodInDays = setting?.storage?.transactionConfirmedInDays;
-    const canceledStoragePeriodInDays = setting?.storage?.transactionCanceledInDays;
-    if (typeof confirmedStoragePeriodInDays !== 'number') {
-        throw new factory_1.factory.errors.NotFound('setting.storage.confirmedStoragePeriodInDays');
-    }
-    if (typeof canceledStoragePeriodInDays !== 'number') {
-        throw new factory_1.factory.errors.NotFound('setting.storage.canceledStoragePeriodInDays');
-    }
-    // 取引削除タスクを作成(取引ステータスによってrunsAtを調整)
-    let deleteAt = (0, moment_1.default)(transaction.endDate)
-        .add(confirmedStoragePeriodInDays, 'days')
-        .toDate();
-    switch (transaction.status) {
-        case factory_1.factory.transactionStatusType.Confirmed:
-            break;
-        case factory_1.factory.transactionStatusType.Canceled:
-        case factory_1.factory.transactionStatusType.Expired:
-            deleteAt = (0, moment_1.default)(transaction.endDate)
-                .add(canceledStoragePeriodInDays, 'days')
-                .toDate();
-            break;
-        default:
-    }
-    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
-                },
-                typeOf: transaction.typeOf,
-            }
-        }
-    };
-}