@chevre/domain 25.2.0-alpha.9 → 26.0.0-alpha.0

package/lib/chevre/repo/adminTask.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTaskRepo = void 0;
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const task_1 = require("./mongoose/schemas/task");
+const AVAILABLE_PROJECT_FIELDS = [
+    'alternateName',
+    'identifier',
+    'description',
+    'project',
+    'name',
+    'status',
+    'runsAt',
+    'remainingNumberOfTries',
+    'lastTriedAt',
+    'numberOfTried',
+    'executionResults',
+    'executor',
+    'data',
+    'dateAborted',
+    'expires'
+];
+/**
+ * タスク管理リポジトリ
+ */
+class AdminTaskRepo {
+    taskModel;
+    constructor(connection) {
+        this.taskModel = connection.model(task_1.modelName, (0, task_1.createSchema)());
+    }
+    static CREATE_MONGO_CONDITIONS(params) {
+        const andConditions = [];
+        const idEq = params.id?.$eq;
+        if (typeof idEq === 'string') {
+            andConditions.push({ _id: { $eq: idEq } });
+        }
+        const projectIdEq = params.project?.id?.$eq;
+        if (typeof projectIdEq === 'string') {
+            andConditions.push({ 'project.id': { $eq: projectIdEq } });
+        }
+        if (typeof params.name === 'string') {
+            andConditions.push({ name: { $eq: params.name } });
+        }
+        else {
+            const nameIn = params.name?.$in;
+            if (Array.isArray(nameIn)) {
+                andConditions.push({ name: { $in: nameIn } });
+            }
+            const nameNin = params.name?.$nin;
+            if (Array.isArray(nameNin)) {
+                andConditions.push({ name: { $nin: nameNin } });
+            }
+        }
+        const statusEq = params.status?.$eq;
+        if (typeof statusEq === 'string') {
+            andConditions.push({ status: { $eq: statusEq } });
+        }
+        if (Array.isArray(params.statuses)) {
+            andConditions.push({ status: { $in: params.statuses } });
+        }
+        if (params.runsFrom instanceof Date) {
+            andConditions.push({ runsAt: { $gte: params.runsFrom } });
+        }
+        if (params.runsThrough instanceof Date) {
+            andConditions.push({ runsAt: { $lte: params.runsThrough } });
+        }
+        if (params.lastTriedFrom instanceof Date) {
+            andConditions.push({ lastTriedAt: { $type: 'date', $gte: params.lastTriedFrom } });
+        }
+        if (params.lastTriedThrough instanceof Date) {
+            andConditions.push({ lastTriedAt: { $type: 'date', $lte: params.lastTriedThrough } });
+        }
+        const dateAbortedGte = params.dateAborted?.$gte;
+        if (dateAbortedGte instanceof Date) {
+            andConditions.push({ dateAborted: { $type: 'date', $gte: dateAbortedGte } });
+        }
+        const dateAbortedLte = params.dateAborted?.$lte;
+        if (dateAbortedLte instanceof Date) {
+            andConditions.push({ dateAborted: { $type: 'date', $lte: dateAbortedLte } });
+        }
+        const objectIdEq = params.data?.object?.id?.$eq;
+        if (typeof objectIdEq === 'string') {
+            andConditions.push({ 'data.object.id': { $exists: true, $eq: objectIdEq } });
+        }
+        const objectOrderNumberEq = params.data?.object?.orderNumber?.$eq;
+        if (typeof objectOrderNumberEq === 'string') {
+            andConditions.push({ 'data.object.orderNumber': { $exists: true, $eq: objectOrderNumberEq } });
+        }
+        const objectTransactionNumberEq = params.data?.object?.transactionNumber?.$eq;
+        if (typeof objectTransactionNumberEq === 'string') {
+            andConditions.push({ 'data.object.transactionNumber': { $exists: true, $eq: objectTransactionNumberEq } });
+        }
+        const objectPurposeIdEq = params.data?.purpose?.id?.$eq;
+        if (typeof objectPurposeIdEq === 'string') {
+            andConditions.push({ 'data.purpose.id': { $exists: true, $eq: objectPurposeIdEq } });
+        }
+        const objectPurposeOrderNumberEq = params.data?.purpose?.orderNumber?.$eq;
+        if (typeof objectPurposeOrderNumberEq === 'string') {
+            andConditions.push({ 'data.purpose.orderNumber': { $exists: true, $eq: objectPurposeOrderNumberEq } });
+        }
+        const alternateNameRegex = params.alternateName?.$regex;
+        if (typeof alternateNameRegex === 'string' && alternateNameRegex.length > 0) {
+            andConditions.push({ alternateName: { $exists: true, $regex: new RegExp(alternateNameRegex) } });
+        }
+        const identifierRegex = params.identifier?.$regex;
+        if (typeof identifierRegex === 'string' && identifierRegex.length > 0) {
+            andConditions.push({ identifier: { $exists: true, $regex: new RegExp(identifierRegex) } });
+        }
+        return andConditions;
+    }
+    async countTasks(params) {
+        const { limit } = params;
+        const conditions = AdminTaskRepo.CREATE_MONGO_CONDITIONS(params);
+        const query = this.taskModel.countDocuments((conditions.length > 0) ? { $and: conditions } : {});
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * 検索する
+     */
+    async findTasks(params, inclusion) {
+        const conditions = AdminTaskRepo.CREATE_MONGO_CONDITIONS(params);
+        let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = inclusion.filter((key) => AVAILABLE_PROJECT_FIELDS.includes(key));
+        }
+        else {
+            // no op
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const query = this.taskModel.find((conditions.length > 0) ? { $and: conditions } : {}, projection);
+        if (typeof params.limit === 'number' && params.limit > 0) {
+            const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
+            query.limit(params.limit)
+                .skip(params.limit * (page - 1));
+        }
+        if (params.sort?.runsAt !== undefined) {
+            query.sort({ runsAt: params.sort.runsAt });
+        }
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean() // lean(2024-09-26~)
+            .exec();
+    }
+    getCursor(conditions, projection) {
+        return this.taskModel.find(conditions, projection)
+            .sort({ runsAt: factory_1.factory.sortType.Ascending })
+            .cursor();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.taskModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminTaskRepo = AdminTaskRepo;

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

@@ -1,5 +1,4 @@
-import type { BulkWriteResult } from 'mongodb';
-import { AnyExpression, Connection, Document, FilterQuery, PipelineStage } from 'mongoose';
+import { AnyExpression, Connection, Document, FilterQuery, PipelineStage, mongo } from 'mongoose';
 import { factory } from '../factory';
 import { IDocType as IAggregateOfferDocType } from './mongoose/schemas/aggregateOffer';
 type IMatchStage = PipelineStage.Match;
@@ -13,7 +12,7 @@ export declare class AggregateOfferRepo {
     constructor(connection: Connection);
     static CREATE_MATCH_STAGE(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): IMatchStage[];
     static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): Record<string, AnyExpression>;
-    search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<factory.aggregateOffer.IAggregateOffer[]>;
+    findAggregateOffers(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<Pick<factory.aggregateOffer.IAggregateOffer, 'id' | 'offers' | 'typeOf'>[]>;
     pushIncludedInDataCatalog(params: {
         project: {
             id: string;
@@ -80,7 +79,7 @@ export declare class AggregateOfferRepo {
          */
         productType: factory.product.ProductType;
     }): Promise<{
-        bulkWriteResult?: BulkWriteResult;
+        bulkWriteResult?: mongo.BulkWriteResult;
         modifiedOffers?: {
             id: string;
         }[];
@@ -110,15 +109,5 @@ export declare class AggregateOfferRepo {
             };
         };
     }): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
-    countIncludedInDataCatalog(params: {
-        id: {
-            $eq: string;
-        };
-    }): Promise<{
-        includedInDataCatalogCount: number;
-    }[]>;
-    maxIncludedInDataCatalogCount(): Promise<{
-        includedInDataCatalogCount: number;
-    }[]>;
 }
 export {};

package/lib/chevre/repo/aggregateOffer.js

@@ -374,11 +374,11 @@ class AggregateOfferRepo {
             _id: 0,
             id: '$_id',
             typeOf: '$typeOf',
-            project: '$project',
             offers: [{ $first: '$offers' }],
-            highPrice: { $max: '$offers.priceSpecification.price' },
-            lowPrice: { $min: '$offers.priceSpecification.price' },
-            offerCount: { $size: '$offers' }
+            // project: '$project', // discontinue(2026-07-24~)
+            // highPrice: { $max: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+            // lowPrice: { $min: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+            // offerCount: { $size: '$offers' } // offers.length:1に限定につき廃止(2026-07-24~)
         };
         const positiveProjectionFields = Object.keys(params)
             .filter((key) => params[key] !== 0);
@@ -389,11 +389,10 @@ class AggregateOfferRepo {
                 _id: 0,
                 id: '$_id',
                 typeOf: '$typeOf',
-                project: '$project',
-                // offers: [{ $first: '$offers' }],
-                highPrice: { $max: '$offers.priceSpecification.price' },
-                lowPrice: { $min: '$offers.priceSpecification.price' },
-                offerCount: { $size: '$offers' }
+                // project: '$project', // discontinue(2026-07-24~)
+                // highPrice: { $max: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+                // lowPrice: { $min: '$offers.priceSpecification.price' }, // offers.length:1に限定につき廃止(2026-07-24~)
+                // offerCount: { $size: '$offers' } // offers.length:1に限定につき廃止(2026-07-24~)
             };
             const offersProjection = {};
             positiveProjectionFields.forEach((field) => {
@@ -410,7 +409,7 @@ class AggregateOfferRepo {
         }
         return projectStage;
     }
-    async search(params, projection) {
+    async findAggregateOffers(params, projection) {
         const matchStages = AggregateOfferRepo.CREATE_MATCH_STAGE(params);
         const projectStage = AggregateOfferRepo.CREATE_AGGREGATE_OFFERS_PROJECTION({ ...projection });
         const sortByPrice = params.sort?.['priceSpecification.price'];
@@ -436,8 +435,11 @@ class AggregateOfferRepo {
         /* istanbul ignore else */
         if (typeof params.limit === 'number' && params.limit > 0) {
             const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
-            aggregate.limit(params.limit * page)
-                .skip(params.limit * (page - 1));
+            // support skip -> limit(2026-07-24~)
+            // aggregate.limit(params.limit * page)
+            //     .skip(params.limit * (page - 1));
+            aggregate.skip(params.limit * (page - 1))
+                .limit(params.limit);
         }
         return aggregate.exec();
     }
@@ -499,25 +501,6 @@ class AggregateOfferRepo {
         }, { projection: { _id: 1 } })
             .exec();
     }
-    // 単価オファー最適化作業における一時的な処理
-    // public async optimizeOffers() {
-    //     return this.aggregateOfferModel.updateMany(
-    //         {
-    //             $or: [
-    //                 { 'offers.id': { $exists: true } },
-    //                 { 'offers.project': { $exists: true } }
-    //             ]
-    //         },
-    //         {
-    //             $set: {},
-    //             $unset: {
-    //                 'offers.0.id': 1,
-    //                 'offers.0.project': 1
-    //             }
-    //         }
-    //     )
-    //         .exec();
-    // }
     getCursor(conditions, projection) {
         return this.aggregateOfferModel.find(conditions, projection)
             .sort({ 'offers.identifier': factory_1.factory.sortType.Ascending })
@@ -530,15 +513,12 @@ class AggregateOfferRepo {
     async save(params) {
         let doc;
         let aggregateOfferId;
-        // const { $unset, ...paramsWithoutUnset } = params;
         const { ...paramsWithoutUnset } = params;
-        // let savedUnitPriceOffer: factory.unitPriceOffer.IUnitPriceOffer;
         if (typeof params.id !== 'string' || params.id.length === 0) {
             const { default: uniqid } = await import('uniqid');
             const newId = uniqid();
             aggregateOfferId = newId;
             // サブオファー最適化(2023-12-22~)
-            // savedUnitPriceOffer = { ...paramsWithoutUnset, id };
             const { id, project, ...savedUnitPriceOffer } = paramsWithoutUnset; // eslint-disable-line @typescript-eslint/no-unused-vars
             const aggregateOffer = {
                 typeOf: factory_1.factory.offerType.AggregateOffer,
@@ -552,18 +532,7 @@ class AggregateOfferRepo {
         }
         else {
             aggregateOfferId = params.id;
-            // const unitPriceOffers = <Pick<factory.unitPriceOffer.IUnitPriceOffer, 'id' | 'identifier' | 'project' | 'typeOf'>[]>
-            //     await this.search(
-            //         {
-            //             limit: 1,
-            //             page: 1,
-            //             project: { id: { $eq: params.project.id } },
-            //             id: { $eq: params.id }
-            //         },
-            //         { identifier: 1, project: 1, typeOf: 1 }
-            //     );
-            // const originalUnitPriceOffer = unitPriceOffers.shift();
-            const aggregateOffers = await this.search({
+            const aggregateOffers = await this.findAggregateOffers({
                 limit: 1,
                 page: 1,
                 project: { id: { $eq: params.project.id } },
@@ -579,26 +548,17 @@ class AggregateOfferRepo {
             // サブオファー最適化(2023-12-22~)
             const subOffer = {
                 ...updateFields,
-                // id: originalUnitPriceOffer.id,
                 identifier: originalUnitPriceOffer.identifier,
-                // project: originalUnitPriceOffer.project,
                 typeOf: originalUnitPriceOffer.typeOf
             };
-            doc = await this.aggregateOfferModel.findOneAndUpdate(
-            // { 'offers.id': params.id },
-            { _id: params.id }, // _idに変更(2023-12-22~)
+            doc = await this.aggregateOfferModel.findOneAndUpdate({ _id: params.id }, // _idに変更(2023-12-22~)
             {
                 $set: {
-                    // 'offers.$[offer]': savedUnitPriceOffer
                     'offers.0': subOffer // _idに変更(2023-12-22~)
                 }
             }, {
                 upsert: false,
                 new: true
-                // _idに変更(2023-12-22~)
-                // arrayFilters: [
-                //     { 'offer.id': { $eq: params.id } }
-                // ]
             })
                 .exec();
         }
@@ -676,7 +636,6 @@ class AggregateOfferRepo {
     async saveManyByIdentifier4sskts(params) {
         const { default: uniqid } = await import('uniqid');
         const insertBulkWriteOps = [];
-        // const updateBulkWriteOps: AnyBulkWriteOperation[] = [];
         if (Array.isArray(params)) {
             params.forEach((p) => {
                 const newOfferId = uniqid();
@@ -710,7 +669,6 @@ class AggregateOfferRepo {
         }
         if (insertBulkWriteOps.length > 0) {
             await this.aggregateOfferModel.bulkWrite(insertBulkWriteOps, { ordered: false });
-            // await this.aggregateOfferModel.bulkWrite(updateBulkWriteOps, { ordered: false });
         }
     }
     /**
@@ -724,13 +682,6 @@ class AggregateOfferRepo {
             'project.id': { $eq: params.project.id },
             'offers.addOn.itemOffered.id': { $exists: true, $in: params.addOn.itemOffered.id.$in }
         };
-        // const updatingOffers = <Pick<factory.unitPriceOffer.IUnitPriceOffer, 'id' | 'identifier'>[]>await this.search(
-        //     {
-        //         project: { id: { $eq: params.project.id } },
-        //         addOn: { itemOffered: { id: { $in: params.addOn.itemOffered.id.$in } } }
-        //     },
-        //     { identifier: 1 }
-        // );
         return this.aggregateOfferModel.updateMany(conditions, {
             $pull: {
                 'offers.$[offer].addOn': {
@@ -743,66 +694,6 @@ class AggregateOfferRepo {
             ]
         })
             .exec();
-        // if (updatingOffers.length > 0) {
-        //     // no op
-        // }
-        // return result;
-    }
-    async countIncludedInDataCatalog(params) {
-        const aggregate = this.aggregateOfferModel.aggregate([
-            {
-                $match: {
-                    _id: { $eq: params.id.$eq }
-                }
-            },
-            {
-                $project: {
-                    _id: 0,
-                    includedInDataCatalogCount: {
-                        $cond: {
-                            if: { $isArray: '$includedInDataCatalog' },
-                            then: { $size: '$includedInDataCatalog' },
-                            else: 0
-                        }
-                    }
-                }
-            }
-        ]);
-        return aggregate.exec();
-    }
-    async maxIncludedInDataCatalogCount() {
-        const aggregate = this.aggregateOfferModel.aggregate([
-            // {
-            //     $match: {
-            //         _id: { $eq: params.id.$eq }
-            //     }
-            // },
-            {
-                $project: {
-                    _id: 0,
-                    includedInDataCatalogCount: {
-                        $cond: {
-                            if: { $isArray: '$includedInDataCatalog' },
-                            then: { $size: '$includedInDataCatalog' },
-                            else: 0
-                        }
-                    }
-                }
-            },
-            {
-                $group: {
-                    _id: null,
-                    maxCount: { $max: '$includedInDataCatalogCount' }
-                }
-            },
-            {
-                $project: {
-                    _id: 0,
-                    maxCount: '$maxCount'
-                }
-            }
-        ]);
-        return aggregate.exec();
     }
 }
 exports.AggregateOfferRepo = AggregateOfferRepo;

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

@@ -0,0 +1,37 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+interface IAggregationByStatus {
+    taskCount: number;
+    avgLatency: number;
+    maxLatency: number;
+    minLatency: number;
+    percentilesLatency: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.taskStatus;
+    aggregation: IAggregationByStatus;
+}
+interface IAggregateTask {
+    statuses: IStatus[];
+}
+/**
+ * タスク集計リポジトリ
+ */
+export declare class AggregateTaskRepo {
+    private readonly taskModel;
+    constructor(connection: Connection);
+    aggregateTask(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        runsFrom: Date;
+        runsThrough: Date;
+    }): Promise<IAggregateTask>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateTask.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateTaskRepo = void 0;
+const factory_1 = require("../factory");
+const task_1 = require("./mongoose/schemas/task");
+/**
+ * タスク集計リポジトリ
+ */
+class AggregateTaskRepo {
+    taskModel;
+    constructor(connection) {
+        this.taskModel = connection.model(task_1.modelName, (0, task_1.createSchema)());
+    }
+    async aggregateTask(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.taskStatus.Executed,
+            factory_1.factory.taskStatus.Aborted
+        ].map(async (taskStatus) => {
+            const matchConditions = {
+                runsAt: {
+                    $gte: params.runsFrom,
+                    $lte: params.runsThrough
+                },
+                status: { $eq: taskStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, status: taskStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const matchConditions = params.matchConditions;
+        const taskStatus = params.status;
+        const aggregate1 = this.taskModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    latency: { $subtract: ['$lastTriedAt', '$runsAt'] },
+                    status: '$status',
+                    runsAt: '$runsAt',
+                    lastTriedAt: '$lastTriedAt'
+                }
+            },
+            {
+                $group: {
+                    _id: '$status',
+                    taskCount: { $sum: 1 },
+                    maxLatency: { $max: '$latency' },
+                    minLatency: { $min: '$latency' },
+                    avgLatency: { $avg: '$latency' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    taskCount: '$taskCount',
+                    avgLatency: '$avgLatency',
+                    maxLatency: '$maxLatency',
+                    minLatency: '$minLatency'
+                }
+            }
+        ]);
+        // const explainResult = await aggregate1.explain();
+        // console.dir(explainResult, { depth: null });
+        // return;
+        const aggregations = await aggregate1.exec();
+        const percents = [50, 95, 99];
+        if (aggregations.length === 0) {
+            return {
+                status: taskStatus,
+                aggregation: {
+                    taskCount: 0,
+                    avgLatency: 0,
+                    maxLatency: 0,
+                    minLatency: 0,
+                    percentilesLatency: percents.map((percent) => {
+                        return {
+                            name: String(percent),
+                            value: 0
+                        };
+                    })
+                }
+            };
+        }
+        const ranks4percentile = percents.map((percentile) => {
+            return {
+                percentile,
+                rank: Math.floor(aggregations[0].taskCount * percentile / 100)
+            };
+        });
+        const aggregate2 = this.taskModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    latency: { $subtract: ['$lastTriedAt', '$runsAt'] },
+                    status: '$status',
+                    runsAt: '$runsAt',
+                    lastTriedAt: '$lastTriedAt'
+                }
+            },
+            { $sort: { latency: 1 } },
+            {
+                $group: {
+                    _id: '$status',
+                    latencies: { $push: '$latency' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    percentilesLatency: ranks4percentile.map((rank) => {
+                        return {
+                            name: String(rank.percentile),
+                            value: { $arrayElemAt: ['$latencies', rank.rank] }
+                        };
+                    })
+                }
+            }
+        ]);
+        const aggregations2 = await aggregate2.exec();
+        return {
+            status: taskStatus,
+            aggregation: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateTaskRepo = AggregateTaskRepo;