@chevre/domain 24.1.0-alpha.4 → 24.1.0-alpha.41

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

@@ -1,38 +1,80 @@
 import type { Connection } from 'mongoose';
 import { factory } from '../factory';
+import { AcceptedOfferInReserveRepo } from './acceptedOfferInReserve';
 type IOrderInTransaction = Pick<factory.order.IOrder, 'orderNumber' | 'project'> & {
     typeOf: factory.transactionType.PlaceOrder;
     orderDate: Date;
     acceptedOffers: factory.order.IAcceptedOffer[];
     customer?: factory.order.ICustomer;
 };
+type IAcceptedOffer = factory.order.IAcceptedOffer & {
+    /**
+     * 受け入れ時に指定必須
+     */
+    offeredThrough: factory.offer.IOfferedThrough;
+};
+/**
+ * typeOf: Orderへドキュメント変換時の編集フィールド
+ */
 export type IPlacingOrder = Pick<factory.order.IOrder, 'broker' | 'confirmationNumber' | 'identifier' | 'isGift' | 'name' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'price' | 'priceCurrency' | 'seller' | 'typeOf' | 'url'> & {
+    /**
+     * 上書きしてはいけない
+     */
     acceptedOffers?: never;
+    /**
+     * 上書きしてはいけない
+     */
     customer?: never;
 };
+export type IMinimizedReservationFor = Pick<factory.order.IEventAsReservationFor, 'endDate' | 'id' | 'startDate' | 'typeOf'> & {
+    location: Pick<factory.order.IEventAsReservationFor['location'], 'branchCode' | 'typeOf'>;
+    superEvent: Pick<factory.order.ISuperEvent, 'id' | 'typeOf'> & {
+        location: Pick<factory.order.ISuperEvent['location'], 'branchCode' | 'typeOf'>;
+        workPerformed: Pick<factory.order.ISuperEvent['workPerformed'], 'identifier' | 'typeOf'>;
+    };
+};
+export type IMinimizedItemOffered = Pick<factory.order.IEventReservation, 'id' | 'reservationNumber' | 'typeOf'> & {
+    reservedTicket: Pick<factory.order.IReservedTicket, 'identifier' | 'ticketedSeat' | 'typeOf'>;
+    reservationFor: IMinimizedReservationFor;
+};
+export type IMinimizedAcceptedOffer = Pick<factory.order.IOptimizedAcceptedOffer, 'id' | 'name' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
+    itemOffered: IMinimizedItemOffered;
+};
 /**
  * 取引中注文リポジトリ
  */
-export declare class OrderInTransactionRepo {
+export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
     private readonly orderModel;
     constructor(connection: Connection);
     /**
      * 取引進行中の注文からacceptedOffersを検索する
+     * 予約取引から予約ごとの価格仕様も参照する
      */
-    findAcceptedOffersByOrderNumber(params: {
-        orderNumber: {
-            $eq: string;
+    findAcceptedOffersWithPriceByOrderNumber(params: {
+        orderNumber: string;
+        project: {
+            id: string;
         };
-    }): Promise<factory.order.IAcceptedOffer[]>;
+    }): Promise<(Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
+        priceSpecification?: factory.order.ITicketPriceSpecification;
+    })[]>;
     /**
      * 注文を受注する
+     * typeOf: PlaceOrder -> typeOf: Order
      */
     placeOrder(order: IPlacingOrder): Promise<void>;
     /**
      * 注文documentがなければ作成し、受け入れられたオファーを追加する
      * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
      */
-    acceptOffer(params: Pick<IOrderInTransaction, 'acceptedOffers' | 'orderNumber' | 'project'>): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
+    acceptOffer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project'> & {
+        acceptedOffers: IMinimizedAcceptedOffer[] | (Omit<IAcceptedOffer, 'priceSpecification'> & {
+            /**
+             * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
+             */
+            priceSpecification?: factory.order.ITicketPriceSpecification;
+        })[];
+    }): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
     /**
      * serialNumberからオファーを除外する
      * ホワイトリストとブラックリスト両方に対応

package/lib/chevre/repo/orderInTransaction.js

@@ -1,22 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderInTransactionRepo = void 0;
+// import { isDeepStrictEqual } from 'util';
 const factory_1 = require("../factory");
 const order_1 = require("./mongoose/schemas/order");
+const acceptedOfferInReserve_1 = require("./acceptedOfferInReserve");
+// const debug = createDebug('chevre-domain:repo:orderInTransaction');
 /**
  * 取引中注文リポジトリ
  */
-class OrderInTransactionRepo {
+class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveRepo {
     orderModel;
     constructor(connection) {
+        super(connection);
         this.orderModel = connection.model(order_1.modelName, (0, order_1.createSchema)());
     }
     /**
      * 取引進行中の注文からacceptedOffersを検索する
+     * 予約取引から予約ごとの価格仕様も参照する
      */
-    async findAcceptedOffersByOrderNumber(params) {
+    async findAcceptedOffersWithPriceByOrderNumber(params) {
         const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber.$eq },
+            orderNumber: { $eq: params.orderNumber },
             typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
         }, { acceptedOffers: 1 })
             .lean()
@@ -24,10 +29,59 @@ class OrderInTransactionRepo {
         if (doc === null) {
             throw new factory_1.factory.errors.NotFound('orderInTransaction');
         }
-        return doc.acceptedOffers;
+        const isCOA = doc.acceptedOffers.at(0)?.offeredThrough?.identifier === factory_1.factory.service.webAPI.Identifier.COA;
+        // COAの場合、予約取引は存在しないのでそのまま返す
+        if (isCOA) {
+            return doc.acceptedOffers;
+        }
+        // priceSpecificationを予約取引から補完する(2026-05-12~)
+        let acceptedOffersByReserveTransaction = [];
+        const reservationNumbers = [...new Set(doc.acceptedOffers.map((aceptedOffer) => aceptedOffer.itemOffered.reservationNumber))];
+        if (reservationNumbers.length > 0) {
+            acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers });
+        }
+        return doc.acceptedOffers.map((acceptedOffer) => {
+            const acceptedOfferByReserve = acceptedOffersByReserveTransaction.find((acceptedOfferByReserveTransaction) => acceptedOfferByReserveTransaction.itemOffered.id === acceptedOffer.itemOffered.id);
+            const priceSpecification = acceptedOfferByReserve?.priceSpecification;
+            // COA予約でなければ、予約取引の価格は必ず存在するはず(2026-05-20~)
+            if (priceSpecification === undefined) {
+                throw new factory_1.factory.errors.Internal(`findAcceptedOffersWithPriceByOrderNumber: priceSpecification undefined. ${acceptedOffer.itemOffered.id}`);
+            }
+            const itemOffered = acceptedOfferByReserve?.itemOffered;
+            // COA予約でなければ、予約取引のitemOfferedは必ず存在するはず(2026-05-25~)
+            if (itemOffered === undefined) {
+                throw new factory_1.factory.errors.Internal(`findAcceptedOffersWithPriceByOrderNumber: itemOffered undefined. ${acceptedOffer.itemOffered.id}`);
+            }
+            return {
+                ...acceptedOffer,
+                itemOffered,
+                priceSpecification
+            };
+        });
     }
+    // /**
+    //  * 取引進行中の注文から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) {
         if (!(order.orderDate instanceof Date)) {

package/lib/chevre/repo/place/hasPOS.js

@@ -67,7 +67,8 @@ class HasPOSRepo {
             throw new factory_1.factory.errors.NotFound(factory_1.factory.placeType.MovieTheater);
         }
         const creatingPOS = {
-            id: params.branchCode, // 互換性維持対応として
+            // 互換性維持対応としてidを保管
+            id: params.branchCode, // eslint-disable-line @typescript-eslint/no-explicit-any
             branchCode: params.branchCode,
             name: params.name
         };

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

@@ -8,9 +8,7 @@ export interface IUpdatePartiallyParams {
 export type ICancelResult = UpdateWriteOpResult;
 export type ICheckedInResult = UpdateWriteOpResult;
 type ISavingReservedTicket = Omit<factory.assetTransaction.reserve.ISubReservationReservedTicket, 'ticketType'> & {
-    ticketType: {
-        id?: string;
-    };
+    ticketType?: never;
 };
 /**
  * ドキュメントとして保管する予約
@@ -22,7 +20,7 @@ export type ICreatingReservation = Omit<factory.reservation.eventReservation.IRe
 /**
  * 廃止予定の予約属性
  */
-export type IDeprecatedField = 'price' | 'underName';
+export type IDeprecatedField = 'price' | 'underName' | 'priceCurrency' | 'issuedThrough' | 'numSeats';
 export type IKeyOfProjection = Exclude<keyof factory.reservation.eventReservation.IReservation, IDeprecatedField> | 'reservedTicket.dateUsed' | 'reservationFor.id' | 'reservationFor.typeOf';
 export type IAttendedReservation = Pick<factory.reservation.eventReservation.IReservation, 'id' | 'typeOf' | 'project' | 'modifiedTime'> & {
     reservationFor: Pick<factory.reservation.eventReservation.IReservationForMinimized, 'id' | 'typeOf'>;
@@ -37,6 +35,18 @@ export type IReservationAsFindResult = Omit<factory.reservation.eventReservation
      * 実データとしてはまだ存在しているが型から廃止(2026-03-26~)
      */
     underName?: never;
+    /**
+     * discontinue(2026-05-10~)
+     */
+    priceCurrency?: never;
+    /**
+     * discontinue(2026-05-10~)
+     */
+    issuedThrough?: never;
+    /**
+     * discontinue(2026-05-11~)
+     */
+    numSeats?: never;
 };
 /**
  * 予約リポジトリ
@@ -63,7 +73,6 @@ export declare class ReservationRepo {
         };
         provider: factory.reservation.IProvider;
         subReservation: factory.assetTransaction.reserve.IObjectSubReservation[];
-        issuedThrough: factory.assetTransaction.reserve.IIssuedThrough;
         reservationFor: factory.assetTransaction.reserve.IReservationFor;
         reservationNumber: string;
         underName?: factory.reservation.IUnderName;
@@ -145,16 +154,20 @@ export declare class ReservationRepo {
     }): Promise<string[]>;
     getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<import("@chevre/factory/lib/chevre/reservation/event").IReservation, "id"> & {
         _id: string;
-        bookingAgent?: any;
         previousReservationStatus?: factory.reservationStatusType;
+        price?: never;
+        priceCurrency?: never;
+        issuedThrough?: never;
     } & Required<{
         _id: string;
     }> & {
         __v: number;
     }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<import("@chevre/factory/lib/chevre/reservation/event").IReservation, "id"> & {
         _id: string;
-        bookingAgent?: any;
         previousReservationStatus?: factory.reservationStatusType;
+        price?: never;
+        priceCurrency?: never;
+        issuedThrough?: never;
     } & Required<{
         _id: string;
     }> & {

package/lib/chevre/repo/reservation.js

@@ -19,7 +19,7 @@ class ReservationRepo {
      * 汎用予約カウント
      */
     async count(params) {
-        const conditions = (0, createMongoConditions_1.CREATE_MONGO_CONDITIONS)(params);
+        const conditions = (0, createMongoConditions_1.createMongoConditions)(params);
         return this.reservationModel.countDocuments((conditions.length > 0) ? { $and: conditions } : {})
             .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .exec();
@@ -28,7 +28,7 @@ class ReservationRepo {
      * 予約検索
      */
     async findReservations(params, inclusion) {
-        const conditions = (0, createMongoConditions_1.CREATE_MONGO_CONDITIONS)(params);
+        const conditions = (0, createMongoConditions_1.createMongoConditions)(params);
         let projection;
         if (inclusion !== undefined && inclusion !== null) {
             projection = {
@@ -114,15 +114,19 @@ class ReservationRepo {
         const bulkWriteOps = [];
         if (Array.isArray(params.subReservation)) {
             params.subReservation.forEach((subReservation) => {
-                const { price: _discontinuePrice, reservedTicket, ...subReservationWithoutPrice } = subReservation;
-                const { ticketType, ...reservedTicketWithoutTicketType } = reservedTicket;
-                // 予約ドキュメントのticketTypeを最小化(2026-04-03~)
-                const savingReservedTicket = {
-                    ...reservedTicketWithoutTicketType,
-                    ticketType: {
-                        ...((typeof ticketType.id === 'string') && { id: ticketType.id })
-                    }
-                };
+                const { price: _discontinuePrice, reservedTicket, priceCurrency: _discontinuePriceCurrency, // discontinue priceCurrency
+                numSeats: _numSeats, // discontinue(2026-05-11~)
+                ...subReservationWithoutPrice } = subReservation;
+                const { ticketType: _ticketType, ...reservedTicketWithoutTicketType } = reservedTicket;
+                // discontinue ticketType(2026-05-09~)
+                const savingReservedTicket = reservedTicketWithoutTicketType;
+                // // 予約ドキュメントのticketTypeを最小化(2026-04-03~)
+                // const savingReservedTicket: ISavingReservedTicket = {
+                //     ...reservedTicketWithoutTicketType,
+                //     ticketType: {
+                //         ...((typeof ticketType.id === 'string') && { id: ticketType.id })
+                //     }
+                // };
                 // reservationFor最小化(2026-04-06~)
                 const { minimizedReservationFor } = (0, minimizeReservationFor_1.minimizeReservationFor)(params.reservationFor);
                 const setOnInsert = {
@@ -132,7 +136,7 @@ class ReservationRepo {
                     bookingTime: params.bookingTime,
                     checkedIn: false,
                     attended: false,
-                    issuedThrough: params.issuedThrough,
+                    // issuedThrough: params.issuedThrough, // discontinue issuedThrough
                     project: { id: params.project.id, typeOf: factory_1.factory.organizationType.Project },
                     reservationFor: minimizedReservationFor,
                     reservationNumber: params.reservationNumber,

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

@@ -59,23 +59,9 @@ export declare class RoleRepo {
     } & {
         __v: number;
     }) | null>;
-    addMember(params: Pick<IRole, 'member' | 'memberOf' | 'roleName'>): Promise<(import("mongoose").FlattenMaps<{
-        typeOf: import("@chevre/factory/lib/chevre/role").RoleType;
-        memberOf: {
-            typeOf: factory.organizationType.Corporation | factory.organizationType.Project;
-        };
-        member: {
-            typeOf: import("@chevre/factory/lib/chevre/role/organizationRole").IMemberType;
-        };
-        roleName: import("@chevre/factory/lib/chevre/role/organizationRole").RoleName;
-        permissions: string[];
-    }> & {
-        _id: import("mongoose").Types.ObjectId;
-    } & {
-        __v: number;
-    }) | null>;
     create(params: Pick<IRole, 'member' | 'memberOf' | 'permissions' | 'roleName'>): Promise<{
         id: string;
     }>;
+    deleteByRoleName(params: Pick<IRole, 'roleName'>): Promise<import("mongodb").DeleteResult>;
 }
 export {};

package/lib/chevre/repo/role.js

@@ -139,20 +139,6 @@ class RoleRepo {
             .lean()
             .exec();
     }
-    async addMember(params) {
-        const { roleName, member, memberOf } = params;
-        return this.roleModel.findOneAndUpdate({
-            roleName: { $eq: roleName },
-            'member.typeOf': { $ne: member.typeOf }
-        }, {
-            $set: { member, memberOf }
-        }, {
-            new: true,
-            projection: { _id: 1 }
-        })
-            .lean()
-            .exec();
-    }
     async create(params) {
         const { member, memberOf, permissions, roleName } = params;
         const creatingRole = {
@@ -167,5 +153,12 @@ class RoleRepo {
         const savedId = insertedId;
         return { id: savedId };
     }
+    async deleteByRoleName(params) {
+        const { roleName } = params;
+        return this.roleModel.deleteOne({
+            roleName: { $eq: roleName }
+        })
+            .exec();
+    }
 }
 exports.RoleRepo = RoleRepo;

package/lib/chevre/repo/setting/integration.d.ts

@@ -0,0 +1,26 @@
+import type { Connection } from 'mongoose';
+import { IIntegrationSettings, ISendGridSettings } from '../mongoose/schemas/setting';
+interface IDBOptions {
+    connection: Connection;
+}
+/**
+ * 外部連携設定リポジトリ
+ */
+export declare class IntegrationSettingRepo {
+    private readonly settingModel;
+    private readonly defaultOptions;
+    private static cachedSettings;
+    private static cacheExpiry;
+    private static readonly CACHE_TTL_MS;
+    constructor(options: IDBOptions);
+    /**
+     * 設定全体をDBまたはキャッシュから取得する
+     */
+    private getAllSettings;
+    /**
+     * 設定名称から設定を参照する
+     */
+    getByKey<T extends keyof IIntegrationSettings>(key: T): Promise<IIntegrationSettings[T]>;
+    addSendGridSettings(params: ISendGridSettings): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};

package/lib/chevre/repo/setting/integration.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationSettingRepo = void 0;
+const debug_1 = __importDefault(require("debug"));
+const factory_1 = require("../../factory");
+const setting_1 = require("../mongoose/schemas/setting");
+const debug = (0, debug_1.default)('chevre-domain:repo:integrationSetting');
+const defaultOptions = {
+    abortedTasksWithoutReport: [
+        factory_1.factory.taskName.ImportEventCapacitiesFromCOA,
+        factory_1.factory.taskName.ImportEventsFromCOA,
+        factory_1.factory.taskName.ImportOffersFromCOA,
+    ],
+    numTryConfirmReserveTransaction: 10,
+    deliverOrderLimit: 10,
+    coa: {
+        timeoutReserve: 20000,
+        timeoutMaster: 30000
+    },
+    gmo: {
+        timeout: 4000,
+        timeoutBackground: 6000
+    },
+    movieticketReserve: {
+        timeoutPay: 5000,
+        timeoutRefund: 5000,
+        timeoutCheck: 4000,
+        minIntervalBetweenPayAndRefund: 10000,
+        credentialsExpireInSeconds: 600
+    },
+    useExperimentalFeature: false
+};
+/**
+ * 外部連携設定リポジトリ
+ */
+class IntegrationSettingRepo {
+    settingModel;
+    defaultOptions;
+    // static にすることで、クラスが何回 new されてもメモリ上で1つだけ保持される
+    static cachedSettings;
+    static cacheExpiry = 0;
+    static CACHE_TTL_MS = 10 * 60 * 1000; // 10分
+    constructor(options) {
+        const { connection } = options;
+        this.settingModel = connection.model(setting_1.modelName, (0, setting_1.createSchema)());
+        this.defaultOptions = defaultOptions;
+    }
+    /**
+     * 設定全体をDBまたはキャッシュから取得する
+     */
+    async getAllSettings() {
+        const now = Date.now();
+        // static プロパティにアクセスするため、クラス名（IntegrationSettingRepo）経由で参照
+        if (IntegrationSettingRepo.cachedSettings !== undefined && now < IntegrationSettingRepo.cacheExpiry) {
+            debug('cache exist!', JSON.stringify(IntegrationSettingRepo.cachedSettings));
+            return IntegrationSettingRepo.cachedSettings;
+        }
+        const settingDoc = await this.settingModel.findOne({ 'project.id': { $eq: '*' } }, {
+            _id: 0,
+            integration: 1
+        })
+            .lean()
+            .exec();
+        // キャッシュを更新
+        if (settingDoc?.integration !== undefined) {
+            // console.log('docuemnt exist!');
+            IntegrationSettingRepo.cachedSettings = settingDoc.integration;
+        }
+        else {
+            IntegrationSettingRepo.cachedSettings = this.defaultOptions;
+        }
+        IntegrationSettingRepo.cacheExpiry = now + IntegrationSettingRepo.CACHE_TTL_MS;
+        return IntegrationSettingRepo.cachedSettings;
+    }
+    /**
+     * 設定名称から設定を参照する
+     */
+    async getByKey(key) {
+        const settings = await this.getAllSettings();
+        return settings[key];
+    }
+    async addSendGridSettings(params) {
+        return this.settingModel.updateOne({ 'project.id': { $eq: '*' } }, {
+            $set: {
+                'integration.sendGrid': params
+            }
+        })
+            .exec();
+    }
+}
+exports.IntegrationSettingRepo = IntegrationSettingRepo;

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

@@ -136,11 +136,11 @@ export declare class TransactionRepo {
         result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
         startDate: Date;
         endDate?: Date | undefined;
-        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
         instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
-        potentialActions?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IPotentialActions | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
         status: factory.transactionStatusType;
         tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IPotentialActions | undefined;
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
@@ -156,10 +156,10 @@ export declare class TransactionRepo {
         startDate: Date;
         endDate?: Date | undefined;
         agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
-        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
         recipient?: undefined;
         status: factory.transactionStatusType;
         tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
@@ -174,11 +174,11 @@ export declare class TransactionRepo {
         result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
         startDate: Date;
         endDate?: Date | undefined;
-        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
         instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
-        potentialActions?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IPotentialActions | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
         status: factory.transactionStatusType;
         tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IPotentialActions | undefined;
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {
@@ -194,10 +194,10 @@ export declare class TransactionRepo {
         startDate: Date;
         endDate?: Date | undefined;
         agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
-        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
         recipient?: undefined;
         status: factory.transactionStatusType;
         tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
     } & {
         _id: import("mongoose").Types.ObjectId;
     } & {

package/lib/chevre/repository.d.ts

@@ -79,6 +79,7 @@ import type { SellerPaymentAcceptedRepo } from './repo/sellerPaymentAccepted';
 import type { SellerReturnPolicyRepo } from './repo/sellerReturnPolicy';
 import type { ServiceAvailableHourRepo } from './repo/service/availableHour';
 import type { SettingRepo } from './repo/setting';
+import type { IntegrationSettingRepo } from './repo/setting/integration';
 import type { JWTSettingRepo } from './repo/setting/jwt';
 import type { StockHolderRepo } from './repo/stockHolder';
 import type { TaskRepo } from './repo/task';
@@ -437,6 +438,10 @@ export declare namespace Setting {
     function createInstance(...params: ConstructorParameters<typeof SettingRepo>): Promise<SettingRepo>;
 }
 export declare namespace setting {
+    type Integration = IntegrationSettingRepo;
+    namespace Integration {
+        function createInstance(...params: ConstructorParameters<typeof IntegrationSettingRepo>): Promise<IntegrationSettingRepo>;
+    }
     type JWT = JWTSettingRepo;
     namespace JWT {
         function createInstance(...params: ConstructorParameters<typeof JWTSettingRepo>): Promise<JWTSettingRepo>;

package/lib/chevre/repository.js

@@ -911,6 +911,17 @@ var Setting;
 })(Setting || (exports.Setting = Setting = {}));
 var setting;
 (function (setting) {
+    let Integration;
+    (function (Integration) {
+        let repo;
+        async function createInstance(...params) {
+            if (repo === undefined) {
+                repo = (await import('./repo/setting/integration.js')).IntegrationSettingRepo;
+            }
+            return new repo(...params);
+        }
+        Integration.createInstance = createInstance;
+    })(Integration = setting.Integration || (setting.Integration = {}));
     let JWT;
     (function (JWT) {
         let repo;

package/lib/chevre/service/aggregation/event/aggregateOffers.js

@@ -150,7 +150,12 @@ function aggregateReservationByOffer(params) {
                         }
                     }
                 });
-                console.log('aggregateReservationByOffer: reservationCount4offer:', reservationCount4offer, 'aggregateSeatingType:', aggregateSeatingType, 'offer.id:', params.offer.id, 'offer.category:', params.offer.category?.codeValue);
+                // console.log(
+                //     'aggregateReservationByOffer: reservationCount4offer:', reservationCount4offer,
+                //     'aggregateSeatingType:', aggregateSeatingType,
+                //     'offer.id:', params.offer.id,
+                //     'offer.category:', params.offer.category?.codeValue
+                // );
             }
         }
         const { maximumAttendeeCapacity, remainingAttendeeCapacity } = await calculateCapacityByOffer(params)(repos);

package/lib/chevre/service/aggregation/event/aggregateScreeningEvent.js

@@ -10,7 +10,6 @@ exports.aggregateScreeningEvent = aggregateScreeningEvent;
 const debug_1 = __importDefault(require("debug"));
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const factory_1 = require("../../../factory");
-// import { Settings } from '../../../settings';
 const findEventOffers_1 = require("./findEventOffers");
 const debug = (0, debug_1.default)('chevre-domain:service:aggregation');
 /**

package/lib/chevre/service/assetTransaction/cancelReservation/factory.js

@@ -69,10 +69,11 @@ function createPotentialActions(params) {
     const reservationForByReserveTransaction = transaction.object.transaction?.object.reservationFor;
     if (reservationForByReserveTransaction !== undefined && typeof reservationNumber === 'string') {
         const cancelObject = {
-            reservationFor: {
-                typeOf: reservationForByReserveTransaction.typeOf,
-                id: String(reservationForByReserveTransaction.id)
-            },
+            // discontinue reservationFor(2026-05-09~)
+            // reservationFor: {
+            //     typeOf: reservationForByReserveTransaction.typeOf,
+            //     id: String(reservationForByReserveTransaction.id)
+            // },
             reservationNumber,
             // ReservationConfirmed->ReservationCancelledのみ処理されるように保証する
             reservationStatus: factory_1.factory.reservationStatusType.ReservationConfirmed,
@@ -100,13 +101,15 @@ function createPotentialActions(params) {
                     cancelObject = {
                         typeOf: reservation.typeOf,
                         id: reservation.id,
-                        issuedThrough: {
-                            typeOf: reservation.issuedThrough?.typeOf
-                        },
-                        reservationFor: {
-                            typeOf: reservation.reservationFor.typeOf,
-                            id: String(reservation.reservationFor.id)
-                        },
+                        // discontinue issuedThrough(2026-05-08~)
+                        // issuedThrough: {
+                        //     typeOf: reservation.issuedThrough?.typeOf
+                        // },
+                        // discontinue reservationFor(2026-05-09~)
+                        // reservationFor: {
+                        //     typeOf: reservation.reservationFor.typeOf,
+                        //     id: String(reservation.reservationFor.id)
+                        // },
                         reservationNumber: reservation.reservationNumber,
                         // ReservationConfirmed->ReservationCancelledのみ処理されるように保証する
                         reservationStatus: factory_1.factory.reservationStatusType.ReservationConfirmed