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

package/lib/chevre/repo/additionalProperty.js

@@ -114,12 +114,12 @@ class AdditionalPropertyRepo {
         let savedId;
         let doc;
         if (typeof params.id !== 'string') {
-            const { id, ...createParams } = params.attributes;
+            const { id, ...createParams } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             doc = await this.additionalPropertyModel.create(createParams);
             savedId = doc.id;
         }
         else {
-            const { id, codeValue, inCodeSet, project, typeOf, ...updateFields } = params.attributes;
+            const { id, codeValue, inCodeSet, project, typeOf, ...updateFields } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             doc = await this.additionalPropertyModel.findOneAndUpdate({ _id: { $eq: params.id } }, updateFields, { upsert: false, new: true, projection: { _id: 1 } })
                 .exec();
             savedId = params.id;

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

@@ -5,9 +5,7 @@ export type ISavingRequirement = Pick<factory.advanceBookingRequirement.IAdvance
     id?: never;
 };
 interface IUnset {
-    $unset?: {
-        [key: string]: 1;
-    };
+    $unset?: Record<string, 1>;
 }
 type IRequirementWithId = factory.advanceBookingRequirement.IAdvanceBookingRequirement & {
     id: string;

package/lib/chevre/repo/advanceBookingRequirement.js

@@ -67,7 +67,7 @@ class AdvanceBookingRequirementRepo {
             if (savingId === '') {
                 throw new factory.errors.ArgumentNull('id');
             }
-            const { id, identifier, project, typeOf, $unset, ...updateFields } = params.attributes;
+            const { id, identifier, project, typeOf, $unset, ...updateFields } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const filter = {
                 _id: { $eq: savingId },
                 'project.id': { $eq: project.id }
@@ -90,7 +90,7 @@ class AdvanceBookingRequirementRepo {
             savedId = savingId;
         }
         else {
-            const { $unset, id, ...createParams } = params.attributes;
+            const { $unset, id, ...createParams } = params.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
             const result = await this.advanceBookingRequirementModel.insertMany(createParams, { rawResult: true });
             const insertedId = result.insertedIds?.[0]?.toHexString();
             if (typeof insertedId !== 'string') {

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,378 @@
+"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)());
+    }
+    /**
+     * イベントと入場ゲート指定で予約使用アクションを集計する
+     * 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/aggregateOffer.d.ts

@@ -4,9 +4,7 @@ import * as factory from '../factory';
 import { IDocType as IAggregateOfferDocType } from './mongoose/schemas/aggregateOffer';
 type IMatchStage = PipelineStage.Match;
 type KeyOfUnitPriceOffer = keyof factory.unitPriceOffer.IUnitPriceOffer;
-type IProjection = {
-    [key in KeyOfUnitPriceOffer]?: 0 | 1;
-};
+type IProjection = Partial<Record<KeyOfUnitPriceOffer, 0 | 1>>;
 /**
  * 集計オファーリポジトリ
  */
@@ -14,9 +12,7 @@ export declare class AggregateOfferRepo {
     private readonly aggregateOfferModel;
     constructor(connection: Connection);
     static CREATE_MATCH_STAGE(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): IMatchStage[];
-    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
-        [field: string]: AnyExpression;
-    };
+    static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): Record<string, AnyExpression>;
     search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<factory.aggregateOffer.IAggregateOffer[]>;
     pushIncludedInDataCatalog(params: {
         project: {
@@ -59,11 +55,15 @@ export declare class AggregateOfferRepo {
         };
         id: string;
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IAggregateOfferDocType> & IAggregateOfferDocType & Required<{
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, Record<string, never>, IAggregateOfferDocType, import("./mongoose/virtuals").IVirtuals, {}> & IAggregateOfferDocType & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<Document<unknown, {}, IAggregateOfferDocType> & IAggregateOfferDocType & Required<{
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IAggregateOfferDocType>, (Document<unknown, Record<string, never>, IAggregateOfferDocType, import("./mongoose/virtuals").IVirtuals, {}> & IAggregateOfferDocType & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.aggregateOffer.IAggregateOffer>;
         $unset: any;
@@ -80,11 +80,11 @@ export declare class AggregateOfferRepo {
          */
         productType: factory.product.ProductType;
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedOffers: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedOffers?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * sskts専用オファー保管
      */

package/lib/chevre/repo/aggregateOffer.js

@@ -578,7 +578,7 @@ class AggregateOfferRepo {
             aggregateOfferId = newId;
             // サブオファー最適化(2023-12-22~)
             // savedUnitPriceOffer = { ...paramsWithoutUnset, id };
-            const { id, project, ...savedUnitPriceOffer } = paramsWithoutUnset;
+            const { id, project, ...savedUnitPriceOffer } = paramsWithoutUnset; // eslint-disable-line @typescript-eslint/no-unused-vars
             const aggregateOffer = {
                 typeOf: factory.offerType.AggregateOffer,
                 project: params.project,
@@ -614,7 +614,7 @@ class AggregateOfferRepo {
                 throw new factory.errors.NotFound(factory.offerType.Offer);
             }
             // 上書き禁止属性を除外
-            const { id, identifier, project, typeOf, ...updateFields } = paramsWithoutUnset;
+            const { id, identifier, project, typeOf, ...updateFields } = paramsWithoutUnset; // eslint-disable-line @typescript-eslint/no-unused-vars
             // サブオファー最適化(2023-12-22~)
             const subOffer = {
                 ...updateFields,
@@ -674,7 +674,7 @@ class AggregateOfferRepo {
                 });
                 const newOfferId = uniqid(); // setOnInsert時のみに利用する新ID
                 // サブオファー最適化(2023-12-22~)
-                const { project, ...subOffer } = p;
+                const { project, ...subOffer } = p; // eslint-disable-line @typescript-eslint/no-unused-vars
                 const aggregateOffer = {
                     project: p.project,
                     typeOf: factory.offerType.AggregateOffer,
@@ -707,6 +707,7 @@ class AggregateOfferRepo {
                 .exec();
             return { bulkWriteResult, modifiedOffers };
         }
+        return {};
     }
     /**
      * sskts専用オファー保管