@chevre/domain 26.0.0-alpha.0 → 26.0.0-alpha.10

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

@@ -0,0 +1,39 @@
+import type { Connection, UpdateWriteOpResult } from 'mongoose';
+import { factory } from '../factory';
+/**
+ * 旧予定タスクリポジトリ
+ */
+export declare class ScheduledTaskLegacyRepo {
+    private readonly taskModel;
+    constructor(connection: Connection);
+    /**
+     * $eq:0をAbortedにする(特定のタスクのみ)(これらは中止されてもhubへ通知しない)
+     */
+    abortLegacyTasks(params: {
+        intervalInMinutes: number;
+        name: {
+            $in: factory.taskName[];
+        };
+    }): Promise<UpdateWriteOpResult>;
+    /**
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     */
+    emitRunningIfExistsLegacy(params: {
+        /**
+         * 必ずタスク名指定で実行する
+         */
+        name: {
+            $eq: factory.taskName;
+        };
+        runsAt: {
+            $lt: Date;
+        };
+        sort: {
+            numberOfTried?: factory.sortType;
+            runsAt?: factory.sortType;
+        };
+        executor: {
+            name: string;
+        };
+    }): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
+}

package/lib/chevre/repo/scheduledTaskLegacy.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledTaskLegacyRepo = void 0;
+const moment_1 = __importDefault(require("moment"));
+const task_1 = require("../eventEmitter/task");
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const task_2 = require("./mongoose/schemas/task");
+/**
+ * 旧予定タスクリポジトリ
+ */
+class ScheduledTaskLegacyRepo {
+    taskModel;
+    constructor(connection) {
+        this.taskModel = connection.model(task_2.modelName, (0, task_2.createSchema)());
+    }
+    /**
+     * $eq:0をAbortedにする(特定のタスクのみ)(これらは中止されてもhubへ通知しない)
+     */
+    async abortLegacyTasks(params) {
+        const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
+            .add(-params.intervalInMinutes, 'minutes')
+            .toDate();
+        return this.taskModel.updateMany({
+            status: { $eq: factory_1.factory.taskStatus.Running },
+            lastTriedAt: {
+                $type: 'date',
+                $lt: lastTriedAtShoudBeLessThan
+            },
+            remainingNumberOfTries: { $eq: 0 },
+            name: { $in: params.name.$in }
+        }, {
+            $set: {
+                status: factory_1.factory.taskStatus.Aborted,
+                dateAborted: new Date()
+            }
+        })
+            .exec();
+    }
+    /**
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     */
+    async emitRunningIfExistsLegacy(params
+    // next?: INextFunction // 現時点でタスク遅延実行ではnext指定なし(2026-07-30)
+    ) {
+        if (!(params.runsAt.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('runsAt.$lt', 'must be Date');
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            name: 1
+        };
+        const nameEq = params.name?.$eq;
+        // インデックス'executeOneByNameIfExists'を想定したfilter
+        const filter = {
+            status: { $eq: factory_1.factory.taskStatus.Ready },
+            runsAt: { $lt: params.runsAt.$lt },
+            name: params.name
+        };
+        const doc = await this.taskModel.findOneAndUpdate(filter, {
+            $set: {
+                status: factory_1.factory.taskStatus.Running, // 実行中に変更
+                lastTriedAt: new Date(),
+                executor: params.executor
+            },
+            $inc: {
+                remainingNumberOfTries: -1, // 残りトライ可能回数減らす
+                numberOfTried: 1 // トライ回数増やす
+            }
+        }, {
+            new: true,
+            projection,
+            ...(typeof params.sort.numberOfTried === 'number' || typeof params.sort.runsAt === 'number')
+                ? { sort: params.sort }
+                : undefined
+        })
+            .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+        if (doc === null) {
+            return null;
+        }
+        const changedTask = {
+            id: doc.id,
+            status: factory_1.factory.taskStatus.Running,
+            name: nameEq
+        };
+        task_1.taskEventEmitter.emitTaskStatusChanged(changedTask);
+        return doc;
+    }
+}
+exports.ScheduledTaskLegacyRepo = ScheduledTaskLegacyRepo;

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

@@ -0,0 +1,21 @@
+import type { Connection } from 'mongoose';
+/**
+ * 予定タスク移行リポジトリ
+ */
+export declare class ScheduledTaskMigrationRepo {
+    private readonly scheduledTaskModel;
+    private readonly taskModel;
+    constructor(connection: Connection);
+    /**
+     * DeleteTransactionタスク移行処理
+     */
+    migrateDeleteTransactionTasks(params: {
+        limit: number;
+        runsAtGte: Date;
+        expiresInDays: number;
+    }): Promise<(import("mongodb").BulkWriteResult & {
+        mongoose?: {
+            validationErrors: import("mongoose").Error[];
+        } | undefined;
+    }) | undefined>;
+}

package/lib/chevre/repo/scheduledTaskMigration.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledTaskMigrationRepo = void 0;
+const moment_1 = __importDefault(require("moment"));
+const factory_1 = require("../factory");
+const scheduledTasks_1 = require("./mongoose/schemas/scheduledTasks");
+const task_1 = require("./mongoose/schemas/task");
+/**
+ * 予定タスク移行リポジトリ
+ */
+class ScheduledTaskMigrationRepo {
+    scheduledTaskModel;
+    taskModel;
+    constructor(connection) {
+        this.scheduledTaskModel = connection.model(scheduledTasks_1.modelName, (0, scheduledTasks_1.createSchema)());
+        this.taskModel = connection.model(task_1.modelName, (0, task_1.createSchema)());
+    }
+    /**
+     * DeleteTransactionタスク移行処理
+     */
+    async migrateDeleteTransactionTasks(params) {
+        const { limit, runsAtGte, expiresInDays } = params;
+        // limit件抽出
+        const migratingTasks = await this.taskModel.find({
+            // _id: { $eq: '6a66e83f9b21f3d4bf5fa232' },
+            status: { $eq: factory_1.factory.taskStatus.Ready },
+            name: { $eq: factory_1.factory.taskName.DeleteTransaction },
+            runsAt: { $gte: runsAtGte }
+        })
+            .limit(limit)
+            .lean()
+            .exec();
+        if (migratingTasks.length === 0) {
+            return;
+        }
+        ;
+        const bulkOps = migratingTasks.map((migratingTask) => {
+            return {
+                updateOne: {
+                    filter: {
+                        _id: { $eq: migratingTask._id }
+                    },
+                    update: {
+                        $setOnInsert: {
+                            ...migratingTask,
+                            expires: (0, moment_1.default)(migratingTask.runsAt)
+                                .add(expiresInDays, 'days')
+                                .toDate()
+                        }
+                    },
+                    upsert: true
+                }
+            };
+        });
+        // 新コレクションへ挿入
+        const result = await this.scheduledTaskModel.bulkWrite(bulkOps, { ordered: false });
+        // 新コレクションへ書き込めたIDだけを旧DBから削除
+        const successfulIds = [];
+        migratingTasks.forEach(d => successfulIds.push(d._id));
+        if (successfulIds.length > 0) {
+            await this.taskModel.deleteMany({ _id: { $in: successfulIds } })
+                .exec();
+        }
+        return result;
+    }
+}
+exports.ScheduledTaskMigrationRepo = ScheduledTaskMigrationRepo;

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

@@ -1,9 +1,8 @@
 import type { Connection, UpdateWriteOpResult } from 'mongoose';
 import { INextFunction } from '../eventEmitter/task';
 import { factory } from '../factory';
-import { IModel, IDocType } from './mongoose/schemas/task';
+import { IModel } from './mongoose/schemas/task';
 import type { IExecutableTask } from '../taskSettings';
-type IKeyOfProjection = keyof factory.task.ITask<factory.taskName> | 'expires';
 /**
  * リトライ可能なタスク作成属性
  */
@@ -16,13 +15,6 @@ type ICreatingTask = Pick<factory.task.IAttributes<factory.taskName>, 'data' | '
 export declare class TaskRepo {
     readonly taskModel: IModel;
     constructor(connection: Connection);
-    runImmediately(params: Pick<factory.task.IAttributes<factory.taskName>, 'data' | 'name' | 'project' | 'remainingNumberOfTries' | 'runsAt'> & {
-        alternateName?: never;
-        identifier?: never;
-        expires: Date;
-    }, next: INextFunction): Promise<{
-        id: string;
-    }>;
     saveMany(taskAttributes: ICreatingTask[]): Promise<{
         id: string;
     }[]>;
@@ -42,8 +34,9 @@ export declare class TaskRepo {
     /**
      * タスク識別子から冪等作成する
      * reimplement createIfNotExistByIdentifier(2025-03-28~)
+     * reimplement runTaskByIdentifier(2026-08-03~)
      */
-    createIfNotExistByAlternateName(params: ICreatingTask & {
+    runTaskByIdentifier(params: ICreatingTask & {
         alternateName: string;
         identifier: string;
         expires?: never;
@@ -62,24 +55,7 @@ export declare class TaskRepo {
         expires?: Date;
     }): Promise<IExecutableTask<factory.taskName> | null>;
     /**
-     * Readyのタスクをname指定でひとつRunningに変更する
-     */
-    executeOneIfExists(params: {
-        name: {
-            $eq: factory.taskName;
-        };
-        executor: {
-            name: string;
-        };
-        runsAt: {
-            $lt: Date;
-        };
-        sort: {
-            numberOfTried?: factory.sortType;
-            runsAt?: factory.sortType;
-        };
-    }): Promise<IExecutableTask<factory.taskName> | null>;
-    /**
+     * 潜在的に実行されるべきタスクをカウントする
      * add(2025-03-16~)
      */
     countPotentiallyRunning(params: {
@@ -90,14 +66,18 @@ export declare class TaskRepo {
         runsAt: {
             $lt: Date;
         };
-        limit?: number;
+        limit: number;
     }): Promise<{
         count: number;
     }>;
     /**
-     * 実行日時を一定期間過ぎたReadyタスクについて、Runningスタータスに変更した上で、Runningイベントを発生させる
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更する
      */
-    emitRunningIfExists(params: {
+    private runDelayedTask;
+    /**
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     */
+    emitRunningIfExistsByName(params: {
         /**
          * 必ずタスク名指定で実行する
          */
@@ -118,31 +98,41 @@ export declare class TaskRepo {
         executor: {
             name: string;
         };
-        nameFilterBeforeRunsAt: boolean;
     }): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
     /**
-     * Readyのままで期限切れのタスクをExpiredに変更する
+     * 実行日時を一定期間過ぎたReadyタスクについて、Runningステータスに変更した上で、Runningイベントを発生させる
+     * taskNameで絞らない
+     * 2026-08-04~
      */
-    makeExpiredMany(params: {
-        expiresLt: Date;
-    }): Promise<UpdateWriteOpResult>;
+    emitRunningIfExistsNoName(params: {
+        runsAt: {
+            $lt: Date;
+        };
+        executor: {
+            name: string;
+        };
+    }): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
     /**
      * Runningのまま一定期間超過し、かつ、remainingNumberOfTries>0のタスクをReadyに変更する
      */
-    retryMany(params: {
+    retryTasks(params: {
+        intervalInMinutes: number;
+    }): Promise<UpdateWriteOpResult>;
+    /**
+     * $lte:0をReadyにする(特定のタスクを除いて) -> Readyにすれば自動的にAbortedになる
+     */
+    retryAbortingTasksByName(params: {
         intervalInMinutes: number;
-        /**
-         * リトライ条件に残り試行回数条件を追加する
-         * 十分に小さい数値を指定すれば、実質残り試行回数に関係なくRunningがReadyに変更されることになる
-         */
-        remainingNumberOfTries: {
-            $gte?: number;
-            $lte?: number;
-        };
         name: {
             $in?: factory.taskName[];
         };
     }): Promise<UpdateWriteOpResult>;
+    /**
+     * $lte:0をReadyにする(特定のタスクを除いて) -> Readyにすれば自動的にAbortedになる
+     */
+    retryAbortingTasks(params: {
+        intervalInMinutes: number;
+    }): Promise<UpdateWriteOpResult>;
     /**
      * 実行中止済タスクを強制的にリトライ
      * 中止済タスクでなければ何もしない
@@ -151,12 +141,6 @@ export declare class TaskRepo {
         id: string;
         remainingNumberOfTries: number;
     }): Promise<UpdateWriteOpResult>;
-    abortMany(params: {
-        intervalInMinutes: number;
-        name: {
-            $in?: factory.taskName[];
-        };
-    }): Promise<UpdateWriteOpResult>;
     /**
      * タスクIDから実行結果とステータスを保管する
      * Abortedの場合、dateAbortedもセットする
@@ -172,23 +156,6 @@ export declare class TaskRepo {
         status: factory.taskStatus.Executed | factory.taskStatus.Running | factory.taskStatus.Aborted;
         executionResult: factory.task.IExecutionResult;
     }, next?: INextFunction): Promise<void>;
-    /**
-     * タスクの状態を参照する
-     * 非同期アクション移行が完了したら廃止する(2026-07-29~)
-     */
-    findTaskById(params: {
-        id: {
-            $eq: string;
-        };
-        project: {
-            id: {
-                $eq: string;
-            };
-        };
-        name: factory.taskName;
-    }, inclusion: IKeyOfProjection[]): Promise<(IDocType & {
-        id: string;
-    } | undefined)>;
     deleteByProject(params: {
         project: {
             id: string;