@chevre/domain 22.11.0-alpha.9 → 22.12.0-alpha.0

package/lib/chevre/repo/stockHolder.js

@@ -10,71 +10,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StockHolderRepo = void 0;
-const createDebug = require("debug");
-const moment = require("moment");
+// import type { RedisClientType } from 'redis';
 const factory = require("../factory");
-// import { createSchema, IModel, ISetting, modelName } from './mongoose/schemas/setting';
 const pendingReservation_1 = require("./pendingReservation");
-const debug = createDebug('chevre-domain:repo:stockHolder');
 const SEARCH_OFFERS_MAX_LENGTH = 100;
-const USE_STOCK_HOLDER_CHECK_CONFLICT = process.env.USE_STOCK_HOLDER_CHECK_CONFLICT === '1';
 /**
- * イベントストックホルダーリポジトリ
+ * 保留予約リポジトリ
  */
 class StockHolderRepo {
-    constructor(redisClient, connection) {
-        this.redisClient = redisClient;
-        // this.settingModel = connection.model(modelName, createSchema());
+    constructor(params) {
+        const { connection } = params;
+        // this.redisClient = redisClient;
         this.pendingReservationRepo = new pendingReservation_1.PendingReservationRepo(connection);
     }
-    static offer2field(params, hasTicketedSeat) {
-        var _a, _b;
-        if (hasTicketedSeat) {
-            return `${params.seatSection}:${params.seatNumber}`;
-        }
-        else {
-            // 予約IDをfieldにする場合
-            const serviceOutputId = (_b = (_a = params.itemOffered) === null || _a === void 0 ? void 0 : _a.serviceOutput) === null || _b === void 0 ? void 0 : _b.id;
-            if (typeof serviceOutputId === 'string') {
-                return serviceOutputId;
-            }
-            else {
-                throw new factory.errors.Internal('offer2field requires itemOffered.serviceOutput.id');
-            }
-        }
-    }
-    static createKey(params) {
-        if (!(params.startDate instanceof Date)) {
-            throw new factory.errors.Argument('startDate', 'must be Date');
-        }
-        return `${StockHolderRepo.KEY_PREFIX_NEW}:${params.eventId}`;
-    }
+    // private static offer2field(params: IOffer, hasTicketedSeat: boolean) {
+    //     if (hasTicketedSeat) {
+    //         return `${params.seatSection}:${params.seatNumber}`;
+    //     } else {
+    //         // 予約IDをfieldにする場合
+    //         const serviceOutputId = params.itemOffered?.serviceOutput?.id;
+    //         if (typeof serviceOutputId === 'string') {
+    //             return serviceOutputId;
+    //         } else {
+    //             throw new factory.errors.Internal('offer2field requires itemOffered.serviceOutput.id');
+    //         }
+    //     }
+    // }
+    // private static createKey(params: {
+    //     eventId: string;
+    //     startDate: Date;
+    // }): string {
+    //     if (!(params.startDate instanceof Date)) {
+    //         throw new factory.errors.Argument('startDate', 'must be Date');
+    //     }
+    //     return `${StockHolderRepo.KEY_PREFIX_NEW}:${params.eventId}`;
+    // }
     /**
      * 座席をロックする(maxキャパシティチェック有)
      */
     lockIfNotLimitExceeded(lockKey, maximum) {
         return __awaiter(this, void 0, void 0, function* () {
-            const useMongoose = yield this.useMongoose({
+            const useMongoose = this.useMongoose({
                 project: { id: lockKey.project.id },
                 eventId: lockKey.eventId,
                 startDate: lockKey.startDate,
                 hasTicketedSeat: lockKey.hasTicketedSeat
             });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.lockIfNotLimitExceeded(lockKey, maximum);
             }
             else {
-                const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
-                yield this.redisClient.watch(key);
-                const hashCount = yield this.redisClient.hLen(key);
-                // Process result
-                // Heavy and time consuming operation here
-                debug('checking hash count...hashCount:', hashCount);
-                if (hashCount + lockKey.offers.length > maximum) {
-                    throw new factory.errors.Argument('Event', 'maximumAttendeeCapacity exceeded');
-                }
-                yield this.lock(lockKey);
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
+                // await this.redisClient.watch(key);
+                // const hashCount = await this.redisClient.hLen(key);
+                // if (hashCount + lockKey.offers.length > maximum) {
+                //     throw new factory.errors.Argument('Event', 'maximumAttendeeCapacity exceeded');
+                // }
+                // await this.lock(lockKey);
             }
         });
     }
@@ -87,62 +83,65 @@ class StockHolderRepo {
             if (!(lockKey.expires instanceof Date)) {
                 throw new factory.errors.Argument('expires', 'must be Date');
             }
-            const useMongoose = yield this.useMongoose({
+            const useMongoose = this.useMongoose({
                 project: { id: lockKey.project.id },
                 eventId: lockKey.eventId,
                 startDate: lockKey.startDate,
                 hasTicketedSeat: lockKey.hasTicketedSeat
             });
-            const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
+            // const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
             // await this.checkIfConflicted({ key, eventId: lockKey.eventId, useMongoose });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.lock(lockKey);
             }
             else {
-                const value = lockKey.holder;
-                const multi = this.redisClient.multi();
-                const fields = lockKey.offers.map((offer) => StockHolderRepo.offer2field(offer, lockKey.hasTicketedSeat));
-                // check uniqueness(2025-04-20~)
-                const uniqueFields = [...new Set(fields)];
-                if (uniqueFields.length !== fields.length) {
-                    throw new factory.errors.Argument('offers', 'offers must be unique');
-                }
-                fields.forEach((field) => {
-                    multi.hSetNX(key, field, value);
-                });
-                const results = yield multi.expireAt(key, moment(lockKey.expires)
-                    .unix())
-                    .exec();
-                const lockedFields = [];
-                if (Array.isArray(results)) {
-                    results.slice(0, fields.length)
-                        .forEach((r, index) => {
-                        if (r === 1 || r === true) {
-                            lockedFields.push(fields[index]);
-                        }
-                    });
-                }
-                const lockedAll = lockedFields.length === fields.length;
-                debug('lockedAll?', lockedAll);
-                // expireAtReplyの検証も追加する(2023-04-19~)
-                const expiredAll = results.slice(fields.length)
-                    .every((r) => (r === 1 || r === true));
-                debug('expiredAll?', expiredAll);
-                if (!lockedAll || !expiredAll) {
-                    if (lockedFields.length > 0) {
-                        // 全て仮押さえできなければ仮押さえできたものは解除
-                        yield this.redisClient.multi()
-                            .hDel(key, lockedFields)
-                            .exec();
-                    }
-                    if (!lockedAll) {
-                        throw new factory.errors.AlreadyInUse(factory.reservationType.EventReservation, ['ticketedSeat'], 'Already hold');
-                    }
-                    else {
-                        throw new factory.errors.Internal('timeout cannot be set unexpectedly');
-                    }
-                }
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const value = lockKey.holder;
+                // const multi = this.redisClient.multi();
+                // const fields = lockKey.offers.map((offer) => StockHolderRepo.offer2field(offer, lockKey.hasTicketedSeat));
+                // // check uniqueness(2025-04-20~)
+                // const uniqueFields = [...new Set(fields)];
+                // if (uniqueFields.length !== fields.length) {
+                //     throw new factory.errors.Argument('offers', 'offers must be unique');
+                // }
+                // fields.forEach((field) => {
+                //     multi.hSetNX(key, field, value);
+                // });
+                // const results = await multi.expireAt(
+                //     key,
+                //     moment(lockKey.expires)
+                //         .unix()
+                // )
+                //     .exec();
+                // const lockedFields: string[] = [];
+                // if (Array.isArray(results)) {
+                //     results.slice(0, fields.length)
+                //         .forEach((r, index) => {
+                //             if (r === 1 || (<any>r) === true) {
+                //                 lockedFields.push(fields[index]);
+                //             }
+                //         });
+                // }
+                // const lockedAll = lockedFields.length === fields.length;
+                // // expireAtReplyの検証も追加する(2023-04-19~)
+                // const expiredAll = results.slice(fields.length)
+                //     .every((r) => (r === 1 || (<any>r) === true));
+                // if (!lockedAll || !expiredAll) {
+                //     if (lockedFields.length > 0) {
+                //         // 全て仮押さえできなければ仮押さえできたものは解除
+                //         await this.redisClient.multi()
+                //             .hDel(key, lockedFields)
+                //             .exec();
+                //     }
+                //     if (!lockedAll) {
+                //         throw new factory.errors.AlreadyInUse(factory.reservationType.EventReservation, ['ticketedSeat'], 'Already hold');
+                //     } else {
+                //         throw new factory.errors.Internal('timeout cannot be set unexpectedly');
+                //     }
+                // }
             }
         });
     }
@@ -151,23 +150,26 @@ class StockHolderRepo {
      */
     unlock(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const useMongoose = yield this.useMongoose({
+            const useMongoose = this.useMongoose({
                 project: { id: params.project.id },
                 eventId: params.eventId,
                 startDate: params.startDate,
                 hasTicketedSeat: params.hasTicketedSeat
             });
-            const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
+            // const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
             // await this.checkIfConflicted({ key, eventId: params.eventId, useMongoose });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.unlock(params);
             }
             else {
-                const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
-                yield this.redisClient.multi()
-                    .hDel(key, field)
-                    .exec();
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
+                // await this.redisClient.multi()
+                //     .hDel(key, field)
+                //     .exec();
             }
         });
     }
@@ -176,23 +178,26 @@ class StockHolderRepo {
      */
     countUnavailableOffers(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (yield this.useMongoose({
+            if (this.useMongoose({
                 project: { id: params.project.id },
                 eventId: params.event.id,
                 startDate: params.event.startDate,
                 hasTicketedSeat: params.event.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.countUnavailableOffers(params);
             }
             else {
-                const key = StockHolderRepo.createKey({ eventId: params.event.id, startDate: params.event.startDate });
-                const reply = yield this.redisClient.hLen(key);
-                let fieldCount = 0;
-                if (typeof reply === 'number') {
-                    fieldCount = Number(reply);
-                }
-                return fieldCount;
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const key = StockHolderRepo.createKey({ eventId: params.event.id, startDate: params.event.startDate });
+                // const reply = await this.redisClient.hLen(key);
+                // let fieldCount: number = 0;
+                // if (typeof reply === 'number') {
+                //     fieldCount = Number(reply);
+                // }
+                // return fieldCount;
             }
         });
     }
@@ -201,19 +206,22 @@ class StockHolderRepo {
      */
     getHolder(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (yield this.useMongoose({
+            if (this.useMongoose({
                 project: { id: params.project.id },
                 eventId: params.eventId,
                 startDate: params.startDate,
                 hasTicketedSeat: params.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.getHolder(params);
             }
             else {
-                const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
-                const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
-                return this.redisClient.hGet(key, field);
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
+                // const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
+                // return this.redisClient.hGet(key, field);
             }
         });
     }
@@ -223,86 +231,66 @@ class StockHolderRepo {
             if (params.offers.length > SEARCH_OFFERS_MAX_LENGTH) {
                 throw new factory.errors.Argument('offers', `offers.length must be <= ${SEARCH_OFFERS_MAX_LENGTH}`);
             }
-            if (yield this.useMongoose({
+            if (this.useMongoose({
                 project: { id: params.project.id },
                 eventId: params.eventId,
                 startDate: params.startDate,
                 hasTicketedSeat: params.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.searchHolders(params);
             }
             else {
-                const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
-                const fields = params.offers.map((o) => {
-                    return StockHolderRepo.offer2field(o, params.hasTicketedSeat);
-                });
-                // Array reply: list of values associated with the given fields, in the same order as they are requested.
-                const result = yield this.redisClient.hmGet(key, fields);
-                if (!Array.isArray(result)) {
-                    throw new factory.errors.Internal(`searchAvailability got non-array: ${typeof result}`);
-                }
-                // そのまま返却(2023-04-17~)
-                return result;
-            }
-        });
-    }
-    redisKeyExists(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = StockHolderRepo.createKey(params);
-            const existingRedisKeyCount = yield this.redisClient.exists(key);
-            if (typeof existingRedisKeyCount !== 'number') {
-                throw new factory.errors.Internal(`unexpected existingKeyCount: ${typeof existingRedisKeyCount}`);
+                throw new factory.errors.NotImplemented('useRedis discontinued.');
+                // if (this.redisClient === undefined) {
+                //     throw new factory.errors.Internal('redisClient required');
+                // }
+                // const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
+                // const fields = params.offers.map((o) => {
+                //     return StockHolderRepo.offer2field(o, params.hasTicketedSeat);
+                // });
+                // // Array reply: list of values associated with the given fields, in the same order as they are requested.
+                // const result = await this.redisClient.hmGet(key, fields);
+                // if (!Array.isArray(result)) {
+                //     throw new factory.errors.Internal(`searchAvailability got non-array: ${typeof result}`);
+                // }
+                // // そのまま返却(2023-04-17~)
+                // return result;
             }
-            return existingRedisKeyCount > 0;
-        });
-    }
-    checkIfConflicted(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisKeyExists = yield this.redisKeyExists(params);
-            const mongoDocExists = yield this.pendingReservationRepo.docExists(params);
-            if (redisKeyExists && mongoDocExists) {
-                throw new factory.errors.Internal(`repository conflicted. eventId:${params.eventId}`);
-            }
-        });
-    }
-    /**
-     * 万が一に備えて、保留予約をredis->mongo移行
-     */
-    migrate2mongoJustInCase(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisKey = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
-            return {
-                expireTime: yield this.redisClient.expireTime(redisKey),
-                hash: yield this.redisClient.hGetAll(redisKey)
-            };
         });
     }
+    // public async checkIfConflicted(params: {
+    //     eventId: string;
+    //     startDate: Date;
+    // }): Promise<void> {
+    //     const redisKeyExists = await this.redisKeyExists(params);
+    //     const mongoDocExists = await this.pendingReservationRepo.docExists(params);
+    //     if (redisKeyExists && mongoDocExists) {
+    //         throw new factory.errors.Internal(`repository conflicted. eventId:${params.eventId}`);
+    //     }
+    // }
     /**
      * 新リポジトリを使用するかどうか
      */
+    // tslint:disable-next-line:prefer-function-over-method
     useMongoose(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(params.startDate instanceof Date)) {
-                throw new factory.errors.Argument('startDate', 'must be Date');
-            }
-            let useMongoose = false;
-            // always use mongo(2025-05-21~)
-            const redisKeyExists = yield this.redisKeyExists(params);
-            if (redisKeyExists) {
-                useMongoose = false;
-            }
-            else {
-                // redis keyが存在しなければmongo利用
-                useMongoose = true;
-            }
-            // check confliction for test
-            if (USE_STOCK_HOLDER_CHECK_CONFLICT) {
-                yield this.checkIfConflicted(params);
-            }
-            return useMongoose;
-        });
+        if (!(params.startDate instanceof Date)) {
+            throw new factory.errors.Argument('startDate', 'must be Date');
+        }
+        // always use mongo(2025-08-17~)
+        return true;
+        // let useMongoose = false;
+        // const redisKeyExists = await this.redisKeyExists(params);
+        // if (redisKeyExists) {
+        //     useMongoose = false;
+        // } else {
+        //     // redis keyが存在しなければmongo利用
+        //     useMongoose = true;
+        // }
+        // // check confliction for test
+        // if (USE_STOCK_HOLDER_CHECK_CONFLICT) {
+        //     await this.checkIfConflicted(params);
+        // }
+        // return useMongoose;
     }
 }
 exports.StockHolderRepo = StockHolderRepo;
-StockHolderRepo.KEY_PREFIX_NEW = 'stockHolder';

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

@@ -23,7 +23,9 @@ interface IOptionOnCreate {
     emitImmediately: boolean;
 }
 export type IExecutableTaskKeys = 'data' | 'id' | 'name' | 'status' | 'numberOfTried' | 'project' | 'remainingNumberOfTries' | 'runsAt' | 'expires';
-export type IExecutableTask<T extends factory.taskName> = Pick<factory.task.ITask<T>, IExecutableTaskKeys>;
+export type IExecutableTask<T extends factory.taskName> = Pick<factory.task.ITask<T>, IExecutableTaskKeys> & {
+    status: factory.taskStatus.Running;
+};
 type IKeyOfProjection = keyof factory.task.ITask<factory.taskName>;
 type ICreatingTask = Pick<factory.task.IAttributes<factory.taskName>, 'data' | 'executionResults' | 'name' | 'numberOfTried' | 'project' | 'remainingNumberOfTries' | 'runsAt' | 'status' | 'identifier' | 'description'>;
 /**
@@ -68,6 +70,10 @@ export declare class TaskRepo {
      */
     createDeleteTransactionTaskIfNotExist(params: Pick<factory.task.IAttributes<factory.taskName.DeleteTransaction>, 'data' | 'executionResults' | 'name' | 'numberOfTried' | 'project' | 'remainingNumberOfTries' | 'runsAt' | 'status'>, options: IOptionOnCreate): Promise<void>;
     createOnAssetTransactionStatusChangedTaskIfNotExist(params: Pick<factory.task.IAttributes<factory.taskName.OnAssetTransactionStatusChanged>, 'data' | 'executionResults' | 'name' | 'numberOfTried' | 'project' | 'remainingNumberOfTries' | 'runsAt' | 'status'>, options: IOptionOnCreate): Promise<void>;
+    /**
+     * Ready -> remainingNumberOfTriesが1減る
+     * Running -> findOneするだけ
+     */
     executeOneById(params: {
         id: string;
         status: factory.taskStatus.Ready | factory.taskStatus.Running;
@@ -77,12 +83,11 @@ export declare class TaskRepo {
         expires?: Date;
     }): Promise<IExecutableTask<factory.taskName> | null>;
     /**
-     * support no name(2025-03-04~)
+     * Readyのタスクをname指定でひとつRunningに変更する
      */
     executeOneIfExists(params: {
-        name?: {
-            $eq?: factory.taskName;
-            $nin?: factory.taskName[];
+        name: {
+            $eq: factory.taskName;
         };
         executor: {
             name: string;
@@ -90,6 +95,10 @@ export declare class TaskRepo {
         runsAt: {
             $lt: Date;
         };
+        sort: {
+            numberOfTried?: factory.sortType;
+            runsAt?: factory.sortType;
+        };
     }): Promise<IExecutableTask<factory.taskName> | null>;
     /**
      * add(2025-03-16~)
@@ -97,7 +106,7 @@ export declare class TaskRepo {
     countPotentiallyRunning(params: {
         name?: {
             $eq?: factory.taskName;
-            $nin?: factory.taskName[];
+            $in?: factory.taskName[];
         };
         runsAt: {
             $lt: Date;
@@ -106,45 +115,54 @@ export declare class TaskRepo {
     }): Promise<{
         count: number;
     }>;
+    /**
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningスタータスに変更した上で、Runningイベントを発生させる
+     */
     emitRunningIfExists(params: {
-        name?: {
-            $eq?: factory.taskName;
-            $nin?: factory.taskName[];
-        };
-        executor: {
-            name: string;
+        /**
+         * 必ずタスク名指定で実行する
+         */
+        name: {
+            $eq: factory.taskName;
+            $in?: never;
+        } | {
+            $eq?: never;
+            $in: factory.taskName[];
         };
         runsAt: {
             $lt: Date;
         };
         sort: {
             numberOfTried?: factory.sortType;
-            runsAt: factory.sortType;
+            runsAt?: factory.sortType;
         };
-    }): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
-    findExecutableOne(params: {
-        name?: {
-            $eq?: factory.taskName;
-            $nin?: factory.taskName[];
-        };
-        runsAt: {
-            $lt: Date;
+        executor: {
+            name: string;
         };
-    }): Promise<IExecutableTask<factory.taskName> | null>;
-    /**
-     * emit OnTaskStatusChanged on delayed tasks
-     */
+        nameFilterBeforeRunsAt: boolean;
+    }, next?: INextFunction): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
     /**
-     * make tasks expired
+     * Readyのままで期限切れのタスクをExpiredに変更する
      */
     makeExpiredMany(params: {
         expiresLt: Date;
     }): Promise<UpdateWriteOpResult>;
     /**
-     * 実行中ステータスのままになっているタスクをリトライする
+     * Runningのまま一定期間超過し、かつ、remainingNumberOfTries>0のタスクをReadyに変更する
      */
-    retry(params: {
+    retryMany(params: {
         intervalInMinutes: number;
+        /**
+         * リトライ条件に残り試行回数条件を追加する
+         * 十分に小さい数値を指定すれば、実質残り試行回数に関係なくRunningがReadyに変更されることになる
+         */
+        remainingNumberOfTries: {
+            $gte?: number;
+            $lte?: number;
+        };
+        name: {
+            $in?: factory.taskName[];
+        };
     }): Promise<UpdateWriteOpResult>;
     /**
      * 実行中止済タスクを強制的にリトライ
@@ -154,25 +172,27 @@ export declare class TaskRepo {
         id: string;
         remainingNumberOfTries: number;
     }): Promise<UpdateWriteOpResult>;
-    abortOne(params: {
-        intervalInMinutes: number;
-    }): Promise<factory.task.ITask<factory.taskName> | null>;
     abortMany(params: {
         intervalInMinutes: number;
+        name: {
+            $in?: factory.taskName[];
+        };
     }): Promise<UpdateWriteOpResult>;
     /**
-     * 実行結果を保管する
+     * タスクIDから実行結果とステータスを保管する
+     * Abortedの場合、dateAbortedもセットする
      */
-    pushExecutionResultById(params: {
+    setExecutionResultAndStatus(params: {
         /**
          * タスクID
          */
         id: string;
-        status: factory.taskStatus;
-    }, executionResult: factory.task.IExecutionResult, next?: INextFunction): Promise<void>;
-    /**
-     * 特定タスク検索
-     */
+        remainingNumberOfTries: number;
+        name: factory.taskName;
+    }, update: {
+        status: factory.taskStatus.Executed | factory.taskStatus.Running | factory.taskStatus.Aborted;
+        executionResult: factory.task.IExecutionResult;
+    }, next?: INextFunction): Promise<void>;
     count(params: factory.task.ISearchConditions): Promise<{
         count: number;
     }>;