@chevre/domain 26.0.0-alpha.26 → 26.0.0-alpha.27

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

@@ -0,0 +1,131 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+import { IDocType } from './mongoose/schemas/transaction';
+/**
+ * 取引管理リポジトリ
+ */
+export declare class AdminTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    countPotentiallyExportTasks(params: {
+        endDate: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    reExportAction(params: {
+        startDate: {
+            $lt: Date;
+        };
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * add(2025-03-13~)
+     */
+    countPotentiallyExpired(params: {
+        expires: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * add(2025-03-03~)
+     */
+    makeOneExpiredIfExists(params: {
+        expires: {
+            $lt: Date;
+        };
+    }): Promise<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'> | undefined>;
+    findByIdAndDelete(params: {
+        id: string;
+    }): Promise<void>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    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;
+        seller: import("@chevre/factory/lib/chevre/transaction/placeOrder").ISeller;
+        typeOf: factory.transactionType.PlaceOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | ({
+        object: import("@chevre/factory/lib/chevre/transaction/returnOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction").ISeller;
+        typeOf: factory.transactionType.ReturnOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
+        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;
+    } & {
+        __v: number;
+    })), import("mongoose").QueryOptions<IDocType>, (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;
+        seller: import("@chevre/factory/lib/chevre/transaction/placeOrder").ISeller;
+        typeOf: factory.transactionType.PlaceOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | ({
+        object: import("@chevre/factory/lib/chevre/transaction/returnOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction").ISeller;
+        typeOf: factory.transactionType.ReturnOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
+        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;
+    } & {
+        __v: number;
+    }))) | null>;
+}

package/lib/chevre/repo/adminTransaction.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTransactionRepo = void 0;
+const transaction_1 = require("../eventEmitter/transaction");
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const transaction_2 = require("./mongoose/schemas/transaction");
+/**
+ * 取引管理リポジトリ
+ */
+class AdminTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(transaction_2.modelName, (0, transaction_2.createSchema)());
+    }
+    async countPotentiallyExportTasks(params) {
+        const { endDate, limit } = params;
+        const endDateLt = endDate?.$lt;
+        if (!(endDateLt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('endDate.$lt', 'must be Date');
+        }
+        const query = this.transactionModel.countDocuments({
+            status: {
+                $in: [
+                    factory_1.factory.transactionStatusType.Canceled,
+                    factory_1.factory.transactionStatusType.Confirmed,
+                    factory_1.factory.transactionStatusType.Expired
+                ]
+            },
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.PotentialActionStatus
+            },
+            endDate: { $exists: true, $lt: endDateLt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    async reExportAction(params) {
+        const { startDate } = params;
+        if (!(startDate.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('startDate.$lt', 'must be Date');
+        }
+        return this.transactionModel.updateMany({
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.ActiveActionStatus
+            },
+            'tasksExportAction.startDate': {
+                $exists: true,
+                $lt: startDate.$lt
+            }
+        }, {
+            $set: {
+                tasksExportAction: {
+                    actionStatus: factory_1.factory.actionStatusType.PotentialActionStatus
+                }
+            }
+        })
+            .exec();
+    }
+    // /**
+    //  * タスクエクスポートの遅延している取引について明示的にemitTransactionStatusChangedを実行する
+    //  */
+    // public async exportTasksMany(params: {
+    //     now: Date;
+    //     delayInSeconds: number;
+    //     status: {
+    //         $in: factory.transactionStatusType[];
+    //     };
+    //     limit: number;
+    // }) {
+    //     const delayedTransactions = await this.transactionModel.find({
+    //         status: { $in: params.status.$in },
+    //         'tasksExportAction.actionStatus': {
+    //             $exists: true,
+    //             $eq: factory.actionStatusType.PotentialActionStatus
+    //         },
+    //         endDate: {
+    //             $exists: true,
+    //             $lt: moment(params.now)
+    //                 .add(-params.delayInSeconds, 'seconds')
+    //                 .toDate()
+    //         }
+    //     })
+    //         .select({
+    //             _id: 0,
+    //             id: { $toString: '$_id' },
+    //             typeOf: 1,
+    //             status: 1
+    //         })
+    //         .limit(params.limit)
+    //         .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'status' | 'typeOf'>[]>()
+    //         .exec();
+    //     if (delayedTransactions.length > 0) {
+    //         delayedTransactions.forEach((delayedTransaction) => {
+    //             transactionEventEmitter.emitTransactionStatusChanged({
+    //                 id: delayedTransaction.id,
+    //                 typeOf: delayedTransaction.typeOf,
+    //                 status: delayedTransaction.status
+    //             });
+    //         });
+    //     }
+    //     return delayedTransactions;
+    // }
+    /**
+     * add(2025-03-13~)
+     */
+    async countPotentiallyExpired(params) {
+        const { expires, limit } = params;
+        const query = this.transactionModel.countDocuments({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: expires.$lt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * add(2025-03-03~)
+     */
+    async makeOneExpiredIfExists(params) {
+        const endDate = new Date();
+        const sort = {
+            expires: factory_1.factory.sortType.Ascending
+        };
+        const doc = await this.transactionModel.findOneAndUpdate({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: params.expires.$lt }
+        }, {
+            status: factory_1.factory.transactionStatusType.Expired,
+            endDate
+        }, {
+            new: true,
+            projection: {
+                _id: 0,
+                id: { $toString: '$_id' },
+                typeOf: 1
+            }
+        })
+            .sort(sort)
+            .lean()
+            .exec();
+        if (doc === null) {
+            // no op
+            return;
+        }
+        else {
+            transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+                id: doc.id,
+                typeOf: doc.typeOf,
+                status: factory_1.factory.transactionStatusType.Expired
+            });
+            return doc;
+        }
+    }
+    // /**
+    //  * 取引を期限切れにする
+    //  */
+    // public async makeExpired(params: {
+    //     expires: { $lt: Date };
+    //     limit: number; // add limit(2025-02-27~)
+    // }): Promise<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'>[]> {
+    //     if (typeof params.limit !== 'number' || params.limit === 0) {
+    //         throw new factory.errors.ArgumentNull('limit');
+    //     }
+    //     const sort: { [key in keyof factory.transaction.ITransaction<factory.transactionType>]?: factory.sortType } = {
+    //         expires: factory.sortType.Ascending
+    //     };
+    //     // IDをemitしたいのでまずリスト検索(2023-04-27~)
+    //     const expiringTransactions =
+    //         await this.transactionModel.find({
+    //             status: { $eq: factory.transactionStatusType.InProgress },
+    //             expires: { $lt: params.expires.$lt }
+    //         })
+    //             .select({
+    //                 _id: 0,
+    //                 id: { $toString: '$_id' },
+    //                 typeOf: 1
+    //             })
+    //             .limit(params.limit)
+    //             .sort(sort) // sort(2025-03-03~)
+    //             .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //             .lean<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'>[]>()
+    //             .exec();
+    //     if (expiringTransactions.length > 0) {
+    //         // ステータスと期限を見て更新
+    //         await this.transactionModel.updateMany(
+    //             {
+    //                 _id: { $in: expiringTransactions.map((t) => t.id) },
+    //                 status: { $eq: factory.transactionStatusType.InProgress },
+    //                 expires: { $lt: params.expires.$lt }
+    //             },
+    //             {
+    //                 status: factory.transactionStatusType.Expired,
+    //                 endDate: new Date()
+    //             }
+    //         )
+    //             .exec();
+    //         expiringTransactions.forEach((expiringTransaction) => {
+    //             transactionEventEmitter.emitTransactionStatusChanged({
+    //                 id: expiringTransaction.id,
+    //                 typeOf: expiringTransaction.typeOf,
+    //                 status: factory.transactionStatusType.Expired
+    //             });
+    //         });
+    //     }
+    //     return expiringTransactions;
+    // }
+    async findByIdAndDelete(params) {
+        await this.transactionModel.findByIdAndDelete(params.id)
+            .exec();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.transactionModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+    getCursor(conditions, projection, sort) {
+        return this.transactionModel.find(conditions, projection)
+            .sort({ startDate: (sort === factory_1.factory.sortType.Ascending) ? sort : factory_1.factory.sortType.Descending })
+            .cursor();
+    }
+}
+exports.AdminTransactionRepo = AdminTransactionRepo;

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

@@ -0,0 +1,39 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+interface IAggregationByStatus {
+    transactionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.transactionStatusType;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregatePlaceOrder {
+    statuses: IStatus[];
+}
+/**
+ * 取引集計リポジトリ
+ */
+export declare class AggregateTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    aggregatePlaceOrder(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.transactionType;
+        clientId?: string;
+    }): Promise<IAggregatePlaceOrder>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateTransaction.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateTransactionRepo = void 0;
+const factory_1 = require("../factory");
+const transaction_1 = require("./mongoose/schemas/transaction");
+/**
+ * 取引集計リポジトリ
+ */
+class AggregateTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(transaction_1.modelName, (0, transaction_1.createSchema)());
+    }
+    async aggregatePlaceOrder(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.transactionStatusType.Confirmed,
+            factory_1.factory.transactionStatusType.Canceled,
+            factory_1.factory.transactionStatusType.Expired
+        ].map(async (transactionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                status: { $eq: transactionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined,
+                ...(typeof params.clientId === 'string')
+                    // customerIdentifierAll.push();
+                    ? {
+                        'agent.identifier': {
+                            $exists: true,
+                            $all: [{ name: 'clientId', value: params.clientId }]
+                        }
+                    }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, status: transactionStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const matchConditions = params.matchConditions;
+        const transactionStatus = params.status;
+        const aggregations = await this.transactionModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    duration: { $subtract: ['$endDate', '$startDate'] },
+                    status: '$status',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf'
+                }
+            },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    transactionCount: { $sum: 1 },
+                    maxDuration: { $max: '$duration' },
+                    minDuration: { $min: '$duration' },
+                    avgDuration: { $avg: '$duration' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    transactionCount: '$transactionCount',
+                    avgDuration: '$avgDuration',
+                    maxDuration: '$maxDuration',
+                    minDuration: '$minDuration'
+                }
+            }
+        ])
+            .exec();
+        const percents = [50, 95, 99];
+        if (aggregations.length === 0) {
+            return {
+                status: transactionStatus,
+                aggregation: {
+                    transactionCount: 0,
+                    avgDuration: 0,
+                    maxDuration: 0,
+                    minDuration: 0,
+                    percentilesDuration: percents.map((percent) => {
+                        return {
+                            name: String(percent),
+                            value: 0
+                        };
+                    })
+                    // totalPrice: 0,
+                    // maxPrice: 0,
+                    // minPrice: 0,
+                    // avgPrice: 0
+                }
+            };
+        }
+        const ranks4percentile = percents.map((percentile) => {
+            return {
+                percentile,
+                rank: Math.floor(aggregations[0].transactionCount * percentile / 100)
+            };
+        });
+        const aggregations2 = await this.transactionModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    duration: { $subtract: ['$endDate', '$startDate'] },
+                    status: '$status',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf'
+                    // result: '$result',
+                    // price: {
+                    //     $cond: {
+                    //         if: { $isNumber: '$result.order.price' },
+                    //         then: '$result.order.price',
+                    //         else: 0
+                    //     }
+                    // }
+                }
+            },
+            { $sort: { duration: 1 } },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    durations: { $push: '$duration' }
+                    // totalPrice: { $sum: '$price' },
+                    // maxPrice: { $max: '$price' },
+                    // minPrice: { $min: '$price' },
+                    // avgPrice: { $avg: '$price' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    percentilesDuration: ranks4percentile.map((rank) => {
+                        return {
+                            name: String(rank.percentile),
+                            value: { $arrayElemAt: ['$durations', rank.rank] }
+                        };
+                    })
+                    // totalPrice: '$totalPrice',
+                    // maxPrice: '$maxPrice',
+                    // minPrice: '$minPrice',
+                    // avgPrice: '$avgPrice'
+                }
+            }
+        ])
+            .exec();
+        return {
+            status: transactionStatus,
+            aggregation: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateTransactionRepo = AggregateTransactionRepo;

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

@@ -38,18 +38,17 @@ const schemaOptions = {
     }
 };
 const indexes = [
-    // [ // discontinue(2024-08-07~)
-    //     { createdAt: 1 },
-    //     { name: 'searchByCreatedAt' }
-    // ],
-    // [
-    //     { updatedAt: 1 },
-    //     { name: 'searchByUpdatedAt' }
-    // ],
     [
         { 'reservationFor.startDate': 1 },
-        { name: 'searchByReservationForStartDate' }
+        {
+            name: 'ttlByReservationForStartDate', // support ttl index(2026-08-11~)
+            expireAfterSeconds: 16416000 // 190 days
+        }
     ],
+    // [
+    //     { 'reservationFor.startDate': 1 },
+    //     { name: 'searchByReservationForStartDate' }
+    // ],
     [
         { 'project.id': 1, 'reservationFor.startDate': 1 },
         { name: 'searchByProjectId' }

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

@@ -77,6 +77,13 @@ const schemaOptions = {
     }
 };
 const indexes = [
+    [
+        { endDate: 1 },
+        {
+            name: 'ttlByEndDate', // support ttl index(2026-08-11~)
+            expireAfterSeconds: 16416000 // 190 days
+        }
+    ],
     [
         { 'project.id': 1, startDate: 1 },
         {

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

@@ -44,6 +44,13 @@ const schemaOptions = {
     }
 };
 const indexes = [
+    [
+        { validThrough: 1 },
+        {
+            name: 'ttlByValidThrough', // support ttl index(2026-08-11~)
+            expireAfterSeconds: 0 // 0 days
+        }
+    ],
     [
         { validFrom: 1 },
         { name: 'validFrom' }

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

@@ -45,6 +45,13 @@ const schemaOptions = {
     }
 };
 const indexes = [
+    [
+        { expires: 1 },
+        {
+            name: 'ttlByExpires', // support ttl index(2026-08-11~)
+            expireAfterSeconds: 0 // 0 days
+        }
+    ],
     [
         { bookingTime: -1 },
         { name: 'bookingTime' }
@@ -113,10 +120,10 @@ const indexes = [
             }
         }
     ],
-    [
-        { expires: 1 },
-        { name: 'deleteExpiredMany' }
-    ]
+    // [
+    //     { expires: 1 },
+    //     { name: 'deleteExpiredMany' }
+    // ]
 ];
 exports.indexes = indexes;
 /**