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

package/lib/chevre/repo/orderInTransaction.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderInTransactionRepo = void 0;
 // import { isDeepStrictEqual } from 'util';
+const errorHandler_1 = require("../errorHandler");
 const factory_1 = require("../factory");
 const order_1 = require("./mongoose/schemas/order");
 const acceptedOfferInReserve_1 = require("./acceptedOfferInReserve");
@@ -15,13 +16,86 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         super(connection);
         this.orderModel = connection.model(order_1.modelName, (0, order_1.createSchema)());
     }
+    async createPlaceOrderIfNotExists(params) {
+        const { orderNumber, project, identifier, broker, seller, customer } = params;
+        const setOnInsert = {
+            typeOf: factory_1.factory.transactionType.PlaceOrder,
+            orderDate: new Date(), // orderDate required(2024-12-09~)
+            orderNumber,
+            project,
+            identifier, // 取引ID(2026-06-22~)
+            ...((seller !== undefined) && { seller }),
+            ...((customer !== undefined) && { customer }),
+            ...((broker !== undefined) && { broker })
+        };
+        try {
+            return this.orderModel.updateOne({
+                identifier: { $eq: identifier }, // 取引IDに対してユニークネスを保証する
+            }, { $setOnInsert: setOnInsert }, { upsert: true })
+                .exec();
+        }
+        catch (error) {
+            let throwsError = true;
+            if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
+                // すでにidentifierが存在する場合ok
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+    }
+    /**
+     * 注文取引から注文番号を参照する
+     * 存在しなければNotFoundError
+     */
+    async findOrderNumberByIdentifier(params, options) {
+        const { project, identifier } = params;
+        const onlyPlaceOrder = options.onlyPlaceOrder === true;
+        const doc = await this.orderModel.findOne({
+            identifier: { $eq: identifier },
+            'project.id': { $eq: project.id },
+            ...((onlyPlaceOrder) && { typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder } })
+        }, {
+            _id: 0,
+            orderNumber: 1
+        })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound('orderInTransaction');
+        }
+        return doc.orderNumber;
+    }
+    /**
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
+     */
+    async findCustomerByOrderIdentifier(params) {
+        const doc = await this.orderModel.findOne({
+            identifier: { $eq: params.identifier }
+            // typeOf: { $eq: factory.transactionType.PlaceOrder } // 検証しない
+        }, {
+            _id: 0,
+            customer: 1
+        })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound('orderInTransaction');
+        }
+        if (typeof doc.customer?.typeOf !== 'string') {
+            throw new factory_1.factory.errors.NotFound('orderInTransaction.customer');
+        }
+        return doc.customer;
+    }
     /**
      * 取引進行中の注文からacceptedOffersを検索する
      * 予約取引から予約ごとの価格仕様も参照する
      */
-    async findAcceptedOffersWithPriceByOrderNumber(params) {
+    async findAcceptedOffersWithPriceByIdentifier(params) {
         const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber },
+            identifier: { $eq: params.identifier },
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
         }, { acceptedOffers: 1 })
             .lean()
@@ -38,7 +112,7 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         let acceptedOffersByReserveTransaction = [];
         const reservationNumbers = [...new Set(doc.acceptedOffers.map((aceptedOffer) => aceptedOffer.itemOffered.reservationNumber))];
         if (reservationNumbers.length > 0) {
-            acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers }, { noName: true });
+            acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers });
         }
         return doc.acceptedOffers.map((acceptedOffer) => {
             const acceptedOfferByReserve = acceptedOffersByReserveTransaction.find((acceptedOfferByReserveTransaction) => acceptedOfferByReserveTransaction.itemOffered.id === acceptedOffer.itemOffered.id);
@@ -59,40 +133,19 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
             };
         });
     }
-    // /**
-    //  * 取引進行中の注文からacceptedOffersを検索する
-    //  */
-    // public async findAcceptedOffersByOrderNumber(
-    //     params: { orderNumber: { $eq: string } }
-    // ): Promise<Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'serialNumber'>[]> {
-    //     const doc = await this.orderModel.findOne<HydratedDocument<Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'serialNumber'>>>(
-    //         {
-    //             orderNumber: { $eq: params.orderNumber.$eq },
-    //             typeOf: { $eq: factory.transactionType.PlaceOrder }
-    //         },
-    //         { acceptedOffers: 1 }
-    //     )
-    //         .lean<Pick<IOrderInTransaction, 'acceptedOffers'>>()
-    //         .exec();
-    //     if (doc === null) {
-    //         throw new factory.errors.NotFound('orderInTransaction');
-    //     }
-    //     return doc.acceptedOffers;
-    // }
     /**
      * 注文を受注する
      * typeOf: PlaceOrder -> typeOf: Order
      */
-    async placeOrder(order) {
+    async placeOrderByIdentifier(filter, order) {
+        const { identifier } = filter;
         if (!(order.orderDate instanceof Date)) {
             throw new factory_1.factory.errors.Argument('orderDate', 'must be Date');
         }
-        // acceptedOffersを上書きしない
-        // const { acceptedOffers, ...orderWithoutAcceptedOffers } = order;
         const setFields = order;
         // typeOf:PlaceOrderのドキュメントが存在すれば、typeOf:Orderに変更する
         await this.orderModel.updateOne({
-            orderNumber: { $eq: order.orderNumber },
+            identifier: { $eq: identifier },
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
         }, { $set: setFields }, {})
             .exec();
@@ -101,43 +154,44 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
      * 注文documentがなければ作成し、受け入れられたオファーを追加する
      * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
      */
-    async acceptOffer(params) {
+    async acceptOfferByIdentifier(params) {
         if (!Array.isArray(params.acceptedOffers) || params.acceptedOffers.length === 0) {
             return;
         }
-        const setOnInsert = {
-            typeOf: factory_1.factory.transactionType.PlaceOrder,
-            orderDate: new Date(), // orderDate required(2024-12-09~)
-            orderNumber: params.orderNumber,
-            project: params.project
-        };
-        return this.orderModel.updateOne({
+        const result = await this.orderModel.updateOne({
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber },
+            identifier: { $eq: params.identifier },
             // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
             // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
             'project.id': { $eq: params.project.id }
         }, {
-            $setOnInsert: setOnInsert,
+            // $setOnInsert: setOnInsert, // createPlaceOrderIfNotExistsへ移行(2026-06-24~)
             $push: {
                 acceptedOffers: {
                     $each: params.acceptedOffers
                 }
             }
-        }, { upsert: true })
+        }, {
+        // upsert: true // createPlaceOrderIfNotExistsへ移行(2026-06-24~)
+        })
             .exec();
+        if (result.matchedCount !== 1) {
+            console.error(params, result);
+            throw new factory_1.factory.errors.Internal(`orderInTransaction not found`);
+        }
+        return result;
     }
     /**
      * serialNumberからオファーを除外する
      * ホワイトリストとブラックリスト両方に対応
      */
-    async voidAcceptedOfferBySerialNumber(params) {
+    async voidAcceptedOfferByIdentifier(params) {
         const serialNumberIn = params.acceptedOffers.serialNumber.$in;
         const serialNumberNin = params.acceptedOffers.serialNumber.$nin;
         if (Array.isArray(serialNumberIn) && serialNumberIn.length > 0) {
             return this.orderModel.updateOne({
                 typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-                orderNumber: { $eq: params.orderNumber }
+                identifier: { $eq: params.identifier }
             }, {
                 $pull: {
                     acceptedOffers: {
@@ -150,7 +204,7 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
         else if (Array.isArray(serialNumberNin) && serialNumberNin.length > 0) {
             return this.orderModel.updateOne({
                 typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-                orderNumber: { $eq: params.orderNumber }
+                identifier: { $eq: params.identifier }
             }, {
                 $pull: {
                     acceptedOffers: {
@@ -164,51 +218,33 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
             return;
         }
     }
-    async setCustomer(params) {
-        const { customer, orderNumber, project } = params;
+    async setCustomerByIdentifier(params) {
+        const { customer, identifier, project } = params;
         const filter = {
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: orderNumber },
+            identifier: { $eq: identifier },
             // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
             // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
             'project.id': { $eq: project.id }
         };
-        const setOnInsert = {
-            typeOf: factory_1.factory.transactionType.PlaceOrder,
-            orderDate: new Date(), // orderDate required(2024-12-09~)
-            orderNumber,
-            project
-        };
         const setKeys = { customer };
-        return this.orderModel.updateOne(filter, {
-            $setOnInsert: setOnInsert,
+        const result = await this.orderModel.updateOne(filter, {
+            // $setOnInsert: setOnInsert, // createPlaceOrderIfNotExistsへ移行(2026-06-24~)
             $set: setKeys
-        }, { upsert: true })
-            .exec();
-    }
-    /**
-     * 注文ドキュメントからcustomer属性を参照する
-     * customer未設定であれば、NotFound
-     */
-    async findCustomerByOrderNumber(params) {
-        const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber.$eq }
-            // typeOf: { $eq: factory.transactionType.PlaceOrder } // 検証しない
-        }, { customer: 1 })
-            .lean()
+        }, {
+        // upsert: true // createPlaceOrderIfNotExistsへ移行(2026-06-24~)
+        })
             .exec();
-        if (doc === null) {
-            throw new factory_1.factory.errors.NotFound('orderInTransaction');
+        if (result.matchedCount !== 1) {
+            console.error(params, result);
+            throw new factory_1.factory.errors.Internal(`orderInTransaction not found`);
         }
-        if (typeof doc.customer?.typeOf !== 'string') {
-            throw new factory_1.factory.errors.NotFound('orderInTransaction.customer');
-        }
-        return doc.customer;
+        return result;
     }
-    async deleteByOrderNumber(params) {
+    async deleteByIdentifier(params) {
         return this.orderModel.deleteOne({
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber }
+            identifier: { $eq: params.identifier }
         })
             .exec();
     }

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

@@ -5,6 +5,9 @@ import type { Connection } from 'mongoose';
 export declare class OrderNumberRepo {
     private readonly counterRepo;
     private readonly settingModel;
+    private static cachedSettings;
+    private static cacheExpiry;
+    private static readonly CACHE_TTL_MS;
     constructor(params: {
         connection: Connection;
     });
@@ -22,6 +25,7 @@ export declare class OrderNumberRepo {
         orderDate: Date;
     }): Promise<string>;
     decrypt(id: string): Promise<string>;
+    clearSettingCache(): void;
     /**
      * 注文番号生成設定を検索する
      */

package/lib/chevre/repo/orderNumber.js

@@ -17,36 +17,25 @@ const ORDER_NUMBER_SEPARATOR = '-';
 class OrderNumberRepo {
     counterRepo;
     settingModel;
+    // static にすることで、クラスが何回 new されてもメモリ上で1つだけ保持される
+    static cachedSettings;
+    static cacheExpiry = 0;
+    static CACHE_TTL_MS = 10 * 60 * 1000; // 10分
     constructor(params) {
         this.counterRepo = new transactionNumberCounter_1.TransactionNumberCounterRepo(params);
         this.settingModel = params.connection.model(setting_1.modelName, (0, setting_1.createSchema)());
     }
-    // public static GENERATE_VERSION0(timestamp: string, seq: number): string {
-    //     let orderNumber = `${timestamp}${seq}`;
-    //     // checkdigit
-    //     const cd = cdigit.luhn.compute(orderNumber);
-    //     orderNumber = fpe({ password: cd })
-    //         .encrypt(orderNumber);
-    //     orderNumber = `${cd}${orderNumber}`;
-    //     return orderNumber;
-    // }
     /**
      * 注文日時から新しい注文番号を発行する
      * グローバルユニークである前提
      */
     async issueOrderNumber(params) {
-        const { fpeSecret, version, validFrom
-        // versioningForceProjects
-        // versioningExceptionProjects
-         } = await this.findSetting();
+        const { fpeSecret, version } = await this.findSetting();
         const timestamp = (0, moment_timezone_1.default)(params.orderDate)
             .valueOf()
             .toString();
-        // const projectPrefix = params.project.alternateName
-        //     .toUpperCase();
         const projectPrefix = params.project.alternateName
             .toUpperCase().at(0);
-        // const dataFeedIdentifier = `${projectPrefix}:${timestamp}`;
         const dataFeedIdentifier = timestamp; // reconsider increment scope(2026-02-21~)
         const dataFeedExpires = (0, moment_timezone_1.default)(params.orderDate)
             .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
@@ -57,32 +46,16 @@ class OrderNumberRepo {
             expires: dataFeedExpires
         });
         let orderNumber;
-        const useVersioning = (validFrom instanceof Date && (0, moment_timezone_1.default)(validFrom)
-            .isSameOrBefore(params.orderDate));
-        if (typeof fpeSecret === 'string' && typeof version === 'string' && useVersioning) {
-            const transactionFactory = new transactionNumber_1.TransactionNumberFactory({ fpeSecret, version });
-            orderNumber = transactionFactory.generate(timestamp, incrReply);
-            orderNumber = `${projectPrefix}${orderNumber}`; // 桁数をversion0に合わせるためにエイリアスの1文字目のみを採用
-            orderNumber = `${[
-                orderNumber.slice(0, 4),
-                orderNumber.slice(4, 11),
-                orderNumber.slice(11)
-            ].join(ORDER_NUMBER_SEPARATOR)}`;
-        }
-        else {
-            // discontinue version0(2026-02-13~)
-            throw new factory_1.factory.errors.NotImplemented('orderNumber with no version discontinued');
-            // orderNumber = OrderNumberRepo.GENERATE_VERSION0(timestamp, incrReply);
-            // orderNumber = `${projectPrefix}${orderNumber}`;
-            // orderNumber = `${[
-            //     // tslint:disable-next-line:no-magic-numbers
-            //     orderNumber.slice(0, 4),
-            //     // tslint:disable-next-line:no-magic-numbers
-            //     orderNumber.slice(4, 11),
-            //     // tslint:disable-next-line:no-magic-numbers
-            //     orderNumber.slice(11)
-            // ].join(ORDER_NUMBER_SEPARATOR)}`;
-        }
+        // const useVersioning: boolean = (validFrom instanceof Date && moment(validFrom)
+        //     .isSameOrBefore(params.orderDate));
+        const transactionFactory = new transactionNumber_1.TransactionNumberFactory({ fpeSecret, version });
+        orderNumber = transactionFactory.generate(timestamp, incrReply);
+        orderNumber = `${projectPrefix}${orderNumber}`; // 桁数をversion0に合わせるためにエイリアスの1文字目のみを採用
+        orderNumber = `${[
+            orderNumber.slice(0, 4),
+            orderNumber.slice(4, 11),
+            orderNumber.slice(11)
+        ].join(ORDER_NUMBER_SEPARATOR)}`;
         return orderNumber;
     }
     async decrypt(id) {
@@ -97,41 +70,40 @@ class OrderNumberRepo {
             throw new factory_1.factory.errors.NotImplemented('no version not implemented');
         }
     }
+    clearSettingCache() {
+        OrderNumberRepo.cacheExpiry = 0;
+        OrderNumberRepo.cachedSettings = undefined;
+    }
     /**
      * 注文番号生成設定を検索する
      */
     async findSetting() {
+        const now = Date.now();
+        // キャッシュ参照(2026-06-22~)
+        if (OrderNumberRepo.cachedSettings !== undefined && now < OrderNumberRepo.cacheExpiry) {
+            return OrderNumberRepo.cachedSettings;
+        }
         const filterQuery = { 'project.id': { $eq: '*' } };
-        const projection = {
+        const setting = await this.settingModel.findOne(filterQuery, {
             _id: 0,
             orderNumber: 1
-        };
-        const setting = await this.settingModel.findOne(filterQuery, projection)
+        })
             .lean()
             .exec();
         if (setting === null || setting.orderNumber === undefined) {
-            return {
-            // versioningForceProjects: []
-            // versioningExceptionProjects: []
-            };
+            throw new factory_1.factory.errors.NotFound('setting.orderNumber');
         }
-        const { fpeSecret, version, validFrom } = setting.orderNumber;
+        const { fpeSecret, version } = setting.orderNumber;
         if (typeof fpeSecret !== 'string' || fpeSecret === '') {
             throw new factory_1.factory.errors.NotFound('setting.orderNumber.secret');
         }
         if (typeof version !== 'string' || version === '') {
             throw new factory_1.factory.errors.NotFound('setting.orderNumber.version');
         }
-        if (!(validFrom instanceof Date)) {
-            throw new factory_1.factory.errors.NotFound('setting.orderNumber.validFrom must be Date');
-        }
-        return {
-            fpeSecret, version, validFrom
-            // versioningForceProjects: [
-            //     ...(Array.isArray(versioningForceProjects)) ? versioningForceProjects : []
-            // ]
-            // versioningExceptionProjects: (Array.isArray(versioningExceptionProjects)) ? versioningExceptionProjects : []
-        };
+        // キャッシュを更新
+        OrderNumberRepo.cachedSettings = { fpeSecret, version };
+        OrderNumberRepo.cacheExpiry = now + OrderNumberRepo.CACHE_TTL_MS;
+        return OrderNumberRepo.cachedSettings;
     }
 }
 exports.OrderNumberRepo = OrderNumberRepo;

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

@@ -20,7 +20,6 @@ interface IOptions {
     secret: string;
     passportValidator?: IPassportValidator;
 }
-type IStartParams = (factory.transaction.placeOrder.IStartParamsWithoutDetail) & {};
 /**
  * 取引許可証リポジトリ
  */
@@ -34,7 +33,11 @@ export declare class PassportRepo {
     /**
      * 許可証トークンがあれば検証する
      */
-    validatePassportTokenIfExist(params: Pick<IStartParams, 'object'>): Promise<{
+    validatePassportTokenIfExist(params: {
+        object?: {
+            passport?: factory.transaction.IPassportBeforeStart;
+        };
+    }): Promise<{
         passport?: IVerifiedPassport;
         customerType?: string;
     }>;

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

@@ -122,16 +122,18 @@ class PlaceOrderRepo {
         if (Array.isArray(sellerIdIn)) {
             andConditions.push({ 'seller.id': { $exists: true, $in: sellerIdIn } });
         }
-        const resultOrderNumberIn = params.result?.order?.orderNumbers;
-        if (Array.isArray(resultOrderNumberIn)) {
-            andConditions.push({ 'result.order.orderNumber': { $exists: true, $in: resultOrderNumberIn } });
-        }
-        const resultOrderConfirmationNumberEq = params.result?.order?.confirmationNumber?.$eq;
-        if (typeof resultOrderConfirmationNumberEq === 'string') {
-            andConditions.push({
-                'result.order.confirmationNumber': { $exists: true, $eq: resultOrderConfirmationNumberEq }
-            });
-        }
+        // result.orderは完全に廃止したので検索条件としても廃止(2026-06-26~)
+        // const resultOrderNumberIn = params.result?.order?.orderNumbers;
+        // if (Array.isArray(resultOrderNumberIn)) {
+        //     andConditions.push({ 'result.order.orderNumber': { $exists: true, $in: resultOrderNumberIn } });
+        // }
+        // result.orderは完全に廃止したので検索条件としても廃止(2026-06-26~)
+        // const resultOrderConfirmationNumberEq = params.result?.order?.confirmationNumber?.$eq;
+        // if (typeof resultOrderConfirmationNumberEq === 'string') {
+        //     andConditions.push({
+        //         'result.order.confirmationNumber': { $exists: true, $eq: resultOrderConfirmationNumberEq }
+        //     });
+        // }
         const objectOrderNumberEq = params.object?.orderNumber?.$eq;
         if (typeof objectOrderNumberEq === 'string') {
             andConditions.push({ 'object.orderNumber': { $exists: true, $eq: objectOrderNumberEq } });

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

@@ -1,4 +1,4 @@
-import type { Connection } from 'mongoose';
+import type { Connection, UpdateQuery } from 'mongoose';
 import { factory } from '../factory';
 import { IDocType } from './mongoose/schemas/transaction';
 interface IAggregationByStatus {
@@ -116,6 +116,10 @@ export declare class TransactionRepo {
         filter: any;
         $unset: any;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
+    updateById4migration(params: {
+        id: string;
+        update: UpdateQuery<IDocType>;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
     /**
      * 終了日時を一定期間過ぎたアクションを削除する
      */
@@ -126,7 +130,7 @@ export declare class TransactionRepo {
             $lt: Date;
         };
     }): Promise<import("mongodb").DeleteResult>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & (({
+    getCursor(conditions: any, projection: any, sort?: factory.sortType): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & (({
         object: import("@chevre/factory/lib/chevre/transaction/placeOrder").IObject;
         error?: any;
         project: import("@chevre/factory/lib/chevre/transaction").IProject;

package/lib/chevre/repo/transaction.js

@@ -297,6 +297,10 @@ class TransactionRepo {
         return this.transactionModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
             .exec();
     }
+    async updateById4migration(params) {
+        return this.transactionModel.updateOne({ _id: { $eq: params.id } }, params.update)
+            .exec();
+    }
     /**
      * 終了日時を一定期間過ぎたアクションを削除する
      */
@@ -312,9 +316,9 @@ class TransactionRepo {
         })
             .exec();
     }
-    getCursor(conditions, projection) {
+    getCursor(conditions, projection, sort) {
         return this.transactionModel.find(conditions, projection)
-            .sort({ startDate: factory_1.factory.sortType.Descending })
+            .sort({ startDate: (sort === factory_1.factory.sortType.Ascending) ? sort : factory_1.factory.sortType.Descending })
             .cursor();
     }
     async aggregatePlaceOrder(params) {

package/lib/chevre/service/assetTransaction/reserve/start.d.ts

@@ -15,7 +15,6 @@ import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import { SeatRepo } from '../../../repo/place/seat';
 import type { PriceSpecificationRepo } from '../../../repo/priceSpecification';
 import type { ProductRepo } from '../../../repo/product';
-import type { ProjectRepo } from '../../../repo/project';
 import type { OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
 import type { SettingRepo } from '../../../repo/setting';
 import type { StockHolderRepo } from '../../../repo/stockHolder';
@@ -37,7 +36,6 @@ interface IStartOperationRepos {
     paymentService: PaymentServiceRepo;
     product: ProductRepo;
     priceSpecification: PriceSpecificationRepo;
-    project: ProjectRepo;
     seat: SeatRepo;
     setting: SettingRepo;
     task: TaskRepo;

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

@@ -6,16 +6,11 @@ interface IAcceptOfferOperationRepos {
 type IAcceptOfferOperation<T> = (repos: IAcceptOfferOperationRepos) => Promise<T>;
 export type IAuthorizeActionWithInstrument = Pick<factory.action.authorize.offer.eventService.IAction, 'instrument'>;
 export declare function acceptOffer(params: {
-    orderNumber: string;
     project: {
         id: string;
     };
-    acceptedOffers: IMinimizedAcceptedOffer[] | (Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
-        /**
-         * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
-         */
-        priceSpecification?: factory.order.ITicketPriceSpecification;
-    })[];
+    placeOrderId: string;
+    acceptedOffers: IMinimizedAcceptedOffer[] | factory.order.ICOAAcceptedOffer[];
 }): IAcceptOfferOperation<void>;
 export declare function voidAcceptedOffer(params: {
     /**
@@ -25,7 +20,7 @@ export declare function voidAcceptedOffer(params: {
      * instrument.serialNumberからvoidする場合に指定
      */
     authorizeActionsWithInstrument: IAuthorizeActionWithInstrument[];
-    orderNumber: string;
+    placeOrderId: string;
 }): (repos: {
     orderInTransaction: OrderInTransactionRepo;
 }) => Promise<void>;

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

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

package/lib/chevre/service/offer/event/authorize/processStartReserve4chevre.d.ts

@@ -15,7 +15,6 @@ import type { PaymentServiceRepo } from '../../../../repo/paymentService';
 import type { SeatRepo } from '../../../../repo/place/seat';
 import type { PriceSpecificationRepo } from '../../../../repo/priceSpecification';
 import type { ProductRepo } from '../../../../repo/product';
-import type { ProjectRepo } from '../../../../repo/project';
 import type { OfferRateLimitRepo } from '../../../../repo/rateLimit/offer';
 import type { SettingRepo } from '../../../../repo/setting';
 import type { StockHolderRepo } from '../../../../repo/stockHolder';
@@ -63,7 +62,6 @@ declare function processStartReserve4chevre(params: {
     paymentService: PaymentServiceRepo;
     product: ProductRepo;
     priceSpecification: PriceSpecificationRepo;
-    project: ProjectRepo;
     seat: SeatRepo;
     setting: SettingRepo;
     task: TaskRepo;