@chevre/domain 24.0.0-alpha.2 → 24.0.0-alpha.21

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

@@ -0,0 +1,102 @@
+import { Connection } from 'mongoose';
+import * as factory from '../factory';
+interface IAggregationByStatus {
+    actionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.actionStatusType;
+    aggregation: IAggregationByStatus;
+}
+interface IAggregateAction {
+    statuses: IStatus[];
+}
+/**
+ * アクション集計リポジトリ
+ */
+export declare class AggregateActionRepo {
+    private readonly actionModel;
+    constructor(connection: Connection);
+    /**
+     * イベントと入場ゲート指定で予約使用アクションを集計する
+     * discontinue(2024-12-26~)
+     */
+    aggregateAuthorizeEventServiceOfferAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizePaymentAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizeOrderAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateCancelReservationAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    aggregateByTypeOf(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateCheckMovieTicketAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    aggregatePayMovieTicketAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateAction.js

@@ -0,0 +1,379 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateActionRepo = void 0;
+const factory = __importStar(require("../factory"));
+// import { MONGO_MAX_TIME_MS } from '../../settings';
+const action_1 = require("./mongoose/schemas/action");
+/**
+ * アクション集計リポジトリ
+ */
+class AggregateActionRepo {
+    actionModel;
+    // private readonly actionRecipeModel: IActionRecipeModel;
+    constructor(connection) {
+        this.actionModel = connection.model(action_1.modelName, (0, action_1.createSchema)());
+        // this.actionRecipeModel = connection.model(recipeModelName, createRecipeSchema());
+    }
+    /**
+     * イベントと入場ゲート指定で予約使用アクションを集計する
+     * discontinue(2024-12-26~)
+     */
+    // public async countUseActionsByEntranceGate(params: {
+    //     event: { id: string };
+    //     entranceGateIdentifier: string;
+    // }): Promise<IUseActionCountByOffer[]> {
+    //     return this.actionModel.aggregate([
+    //         {
+    //             $match: {
+    //                 actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 typeOf: { $eq: factory.actionType.UseAction }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'object.typeOf': {
+    //                     $exists: true,
+    //                     $eq: factory.reservationType.EventReservation
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'object.reservationFor.id': {
+    //                     $exists: true,
+    //                     $eq: params.event.id
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'location.identifier': {
+    //                     $exists: true,
+    //                     $eq: params.entranceGateIdentifier
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $group: {
+    //                 _id: '$object.id',
+    //                 object: { $first: '$object' }
+    //             }
+    //         },
+    //         {
+    //             $group: {
+    //                 _id: '$object.reservedTicket.ticketType.id',
+    //                 useActionCount: {
+    //                     $sum: 1
+    //                 }
+    //             }
+    //         }
+    //     ])
+    //         .exec();
+    // }
+    async aggregateAuthorizeEventServiceOfferAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.action.authorize.offer.eventService.ObjectType.SeatReservation
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateAuthorizePaymentAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateAuthorizeOrderAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.order.OrderType.Order
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateCancelReservationAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory.actionType.CancelAction },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $in: [
+                        factory.reservationType.BusReservation,
+                        factory.reservationType.EventReservation,
+                        factory.reservationType.ReservationPackage
+                    ]
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    async aggregateByTypeOf(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateCheckMovieTicketAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory.actionType.CheckAction },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.service.paymentService.PaymentServiceType.MovieTicket
+                },
+                actionStatus: { $eq: actionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregatePayMovieTicketAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory.actionType.PayAction },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.service.paymentService.PaymentServiceType.MovieTicket
+                },
+                actionStatus: { $eq: actionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const aggregations = await this.actionModel.aggregate([
+            { $match: params.matchConditions },
+            {
+                $project: {
+                    duration: { $subtract: ['$endDate', '$startDate'] },
+                    actionStatus: '$actionStatus',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf'
+                }
+            },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    actionCount: { $sum: 1 },
+                    maxDuration: { $max: '$duration' },
+                    minDuration: { $min: '$duration' },
+                    avgDuration: { $avg: '$duration' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    actionCount: '$actionCount',
+                    avgDuration: '$avgDuration',
+                    maxDuration: '$maxDuration',
+                    minDuration: '$minDuration'
+                }
+            }
+        ])
+            .exec();
+        const percents = [50, 95, 99];
+        if (aggregations.length === 0) {
+            return {
+                status: params.actionStatus,
+                aggregation: {
+                    actionCount: 0,
+                    avgDuration: 0,
+                    maxDuration: 0,
+                    minDuration: 0,
+                    percentilesDuration: percents.map((percent) => {
+                        return {
+                            name: String(percent),
+                            value: 0
+                        };
+                    })
+                }
+            };
+        }
+        const ranks4percentile = percents.map((percentile) => {
+            return {
+                percentile,
+                rank: Math.floor(aggregations[0].actionCount * percentile / 100)
+            };
+        });
+        const aggregations2 = await this.actionModel.aggregate([
+            {
+                $match: params.matchConditions
+            },
+            {
+                $project: {
+                    duration: { $subtract: ['$endDate', '$startDate'] },
+                    actionStatus: '$actionStatus',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf'
+                }
+            },
+            { $sort: { duration: 1 } },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    durations: { $push: '$duration' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    avgSmallDuration: '$avgSmallDuration',
+                    avgMediumDuration: '$avgMediumDuration',
+                    avgLargeDuration: '$avgLargeDuration',
+                    percentilesDuration: ranks4percentile.map((rank) => {
+                        return {
+                            name: String(rank.percentile),
+                            value: { $arrayElemAt: ['$durations', rank.rank] }
+                        };
+                    })
+                }
+            }
+        ])
+            .exec();
+        return {
+            status: params.actionStatus,
+            aggregation: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateActionRepo = AggregateActionRepo;

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

@@ -163,6 +163,37 @@ const indexes = [
             }
         }
     ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber20260221',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true },
+                startDate: { $gte: new Date('2026-02-21T11:00:00Z') }
+            }
+        }
+    ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true }
+            }
+        }
+    ],
     [
         // ひとつの注文取引に対する確定返品取引はユニークなはず
         { 'object.order.orderNumber': 1 },

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

@@ -28,6 +28,10 @@ export declare class OrderInTransactionRepo {
      * 注文を受注する
      */
     placeOrder(order: IPlacingOrder): Promise<void>;
+    /**
+     * 注文documentがなければ作成し、受け入れられたオファーを追加する
+     * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
+     */
     acceptOffer(params: Pick<IOrderInTransaction, 'acceptedOffers' | 'orderNumber' | 'project'>): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
     /**
      * serialNumberからオファーを除外する
@@ -45,6 +49,10 @@ export declare class OrderInTransactionRepo {
     setCustomer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project'> & {
         customer: factory.order.ICustomer;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
+     */
     findCustomerByOrderNumber(params: {
         orderNumber: {
             $eq: string;

package/lib/chevre/repo/orderInTransaction.js

@@ -66,6 +66,10 @@ class OrderInTransactionRepo {
         }, { $set: setFields }, {})
             .exec();
     }
+    /**
+     * 注文documentがなければ作成し、受け入れられたオファーを追加する
+     * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
+     */
     async acceptOffer(params) {
         if (!Array.isArray(params.acceptedOffers) || params.acceptedOffers.length === 0) {
             return;
@@ -78,7 +82,10 @@ class OrderInTransactionRepo {
         };
         return this.orderModel.updateOne({
             typeOf: { $eq: factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber }
+            orderNumber: { $eq: params.orderNumber },
+            // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
+            // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
+            'project.id': { $eq: params.project.id }
         }, {
             $setOnInsert: setOnInsert,
             $push: {
@@ -130,7 +137,10 @@ class OrderInTransactionRepo {
         const { customer, orderNumber, project } = params;
         const filter = {
             typeOf: { $eq: factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: orderNumber }
+            orderNumber: { $eq: orderNumber },
+            // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
+            // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
+            'project.id': { $eq: project.id }
         };
         const setOnInsert = {
             typeOf: factory.transactionType.PlaceOrder,
@@ -145,6 +155,10 @@ class OrderInTransactionRepo {
         }, { upsert: true })
             .exec();
     }
+    /**
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
+     */
     async findCustomerByOrderNumber(params) {
         const doc = await this.orderModel.findOne({
             orderNumber: { $eq: params.orderNumber.$eq }

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

@@ -9,9 +9,10 @@ export declare class OrderNumberRepo {
         connection: Connection;
     });
     /**
-     * タイムスタンプから発行する
+     * 注文日時から新しい注文番号を発行する
+     * グローバルユニークである前提
      */
-    publishByTimestamp(params: {
+    issueOrderNumber(params: {
         project: {
             alternateName: string;
         };