@chevre/domain 25.2.0-alpha.47 → 25.2.0-alpha.48

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

@@ -1,45 +1,46 @@
 import type { Connection, UpdateWriteOpResult } from 'mongoose';
 import { factory } from '../factory';
-import { IModel } from './mongoose/schemas/task';
+import { IModel } from './mongoose/schemas/asyncAction';
 import type { IExecutableTask } from '../taskSettings';
+type ISavingTask = Pick<factory.task.IAttributes<factory.taskName>, 'alternateName' | 'data' | 'description' | 'executionResults' | 'expires' | 'identifier' | 'name' | 'project' | 'runsAt' | 'status'> & {
+    expires: Date;
+};
+export type IExecutableAsyncAction = Pick<IExecutableTask<factory.taskName>, 'data' | 'expires' | 'id' | 'name' | 'project' | 'runsAt' | 'status'>;
 /**
- * タスクリポジトリ
+ * 非同期アクションリポジトリ
  */
 export declare class AsyncActionRepo {
-    readonly taskModel: IModel;
+    readonly asyncActionModel: IModel;
     constructor(connection: Connection);
     /**
      * Readyタスクをひとつ追加する
      */
-    addReadyAsyncAction(params: Pick<factory.task.IAttributes<factory.taskName>, 'data' | 'expires' | 'name' | 'project' | 'remainingNumberOfTries' | 'runsAt'> & {
+    addReadyAsyncAction(params: Pick<ISavingTask, 'data' | 'expires' | 'name' | 'project' | 'runsAt'> & {
         alternateName?: never;
         identifier?: never;
-        expires: Date;
     }): Promise<{
         id: string;
     }>;
     /**
-     * Ready -> remainingNumberOfTriesが1減る
+     * Ready -> Running
      */
     executeAsyncActionById(params: {
         id: string;
-        status: factory.taskStatus.Ready;
         executor: {
             name: string;
         };
-        expires?: Date;
-    }): Promise<IExecutableTask<factory.taskName> | null>;
+    }): Promise<IExecutableAsyncAction | null>;
     /**
      * Readyのままで期限切れのタスクをExpiredに変更する
      */
     makeExpiredMany(params: {
         expiresLt: Date;
     }): Promise<UpdateWriteOpResult>;
+    /**
+     * taskNameに関わらず、Runningのまま放置された非同期アクションをAbortedに変更する
+     */
     abortMany(params: {
         intervalInMinutes: number;
-        name: {
-            $in?: factory.taskName[];
-        };
     }): Promise<UpdateWriteOpResult>;
     /**
      * タスクIDから実行結果とステータスを保管する
@@ -63,3 +64,4 @@ export declare class AsyncActionRepo {
         };
     }): Promise<import("mongodb").DeleteResult>;
 }
+export {};

package/lib/chevre/repo/asyncAction.js

@@ -7,7 +7,7 @@ exports.AsyncActionRepo = void 0;
 const moment_1 = __importDefault(require("moment"));
 const factory_1 = require("../factory");
 const settings_1 = require("../settings");
-const task_1 = require("./mongoose/schemas/task");
+const asyncAction_1 = require("./mongoose/schemas/asyncAction");
 const executableTaskProjection = {
     _id: 0,
     id: { $toString: '$_id' },
@@ -15,38 +15,32 @@ const executableTaskProjection = {
     data: 1,
     name: 1,
     status: 1,
-    numberOfTried: 1,
     project: 1,
-    remainingNumberOfTries: 1,
     runsAt: 1,
     expires: 1
 };
 /**
- * タスクリポジトリ
+ * 非同期アクションリポジトリ
  */
 class AsyncActionRepo {
-    taskModel;
+    asyncActionModel;
     constructor(connection) {
-        this.taskModel = connection.model(task_1.modelName, (0, task_1.createSchema)());
+        this.asyncActionModel = connection.model(asyncAction_1.modelName, (0, asyncAction_1.createSchema)());
     }
     /**
      * Readyタスクをひとつ追加する
      */
-    async addReadyAsyncAction(
-    // resolve uniqueness of identifier(2025-03-27~)
-    params) {
+    async addReadyAsyncAction(params) {
         const { expires } = params;
         if (!(expires instanceof Date)) {
             throw new factory_1.factory.errors.Argument('expires', 'must be Date');
         }
         const savingTask = {
             ...params,
-            remainingNumberOfTries: 1, // リトライはありえないので、1で固定
             status: factory_1.factory.taskStatus.Ready,
-            numberOfTried: 0,
             executionResults: []
         };
-        const result = await this.taskModel.insertMany(savingTask, { rawResult: true });
+        const result = await this.asyncActionModel.insertMany(savingTask, { rawResult: true });
         const id = result.insertedIds?.[0]?.toHexString();
         if (typeof id !== 'string') {
             throw new factory_1.factory.errors.Internal('task not saved');
@@ -54,25 +48,21 @@ class AsyncActionRepo {
         return { id };
     }
     /**
-     * Ready -> remainingNumberOfTriesが1減る
+     * Ready -> Running
      */
     async executeAsyncActionById(params) {
         const now = new Date();
-        const doc = await this.taskModel.findOneAndUpdate({
+        const doc = await this.asyncActionModel.findOneAndUpdate({
             _id: { $eq: params.id },
-            status: { $eq: params.status },
+            status: { $eq: factory_1.factory.taskStatus.Ready }, // Readyのものしか実行しない
             runsAt: { $lt: now },
-            ...(params.expires instanceof Date) ? { expires: { $gt: now } } : undefined
+            expires: { $exists: true, $gt: now }, // ワンタイムタスクなのでexpiresは必ず存在する
         }, {
             $set: {
                 status: factory_1.factory.taskStatus.Running, // 実行中に変更
                 lastTriedAt: now,
                 executor: params.executor
             },
-            $inc: {
-                remainingNumberOfTries: -1, // 残りトライ可能回数減らす
-                numberOfTried: 1 // トライ回数増やす
-            }
         }, { new: true, projection: executableTaskProjection })
             .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .lean() // lean(2024-09-26~)
@@ -90,7 +80,7 @@ class AsyncActionRepo {
         if (!(expiresLt instanceof Date)) {
             throw new factory_1.factory.errors.Argument('expiresLt', 'must be Date');
         }
-        return this.taskModel.updateMany({
+        return this.asyncActionModel.updateMany({
             status: { $eq: factory_1.factory.taskStatus.Ready },
             expires: { $exists: true, $lt: expiresLt }
         }, {
@@ -100,18 +90,19 @@ class AsyncActionRepo {
         })
             .exec();
     }
+    /**
+     * taskNameに関わらず、Runningのまま放置された非同期アクションをAbortedに変更する
+     */
     async abortMany(params) {
         const lastTriedAtShoudBeLessThan = (0, moment_1.default)()
             .add(-params.intervalInMinutes, 'minutes')
             .toDate();
-        return this.taskModel.updateMany({
+        return this.asyncActionModel.updateMany({
             status: { $eq: factory_1.factory.taskStatus.Running },
             lastTriedAt: {
-                $type: 'date',
+                $exists: true,
                 $lt: lastTriedAtShoudBeLessThan
-            },
-            remainingNumberOfTries: { $eq: 0 },
-            ...(Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined
+            }
         }, {
             $set: {
                 status: factory_1.factory.taskStatus.Aborted,
@@ -127,7 +118,7 @@ class AsyncActionRepo {
     async setExecutionResultAndStatus(params, update) {
         const { id } = params;
         const { status, executionResult } = update;
-        await this.taskModel.updateOne({ _id: { $eq: id } }, {
+        await this.asyncActionModel.updateOne({ _id: { $eq: id } }, {
             $set: {
                 status,
                 ...(status === factory_1.factory.taskStatus.Aborted) ? { dateAborted: executionResult.endDate } : undefined // 2025-08-04~
@@ -140,7 +131,7 @@ class AsyncActionRepo {
      * 不要なタスクを削除する
      */
     async deleteRunsAtPassedCertainPeriod(params) {
-        return this.taskModel.deleteMany({
+        return this.asyncActionModel.deleteMany({
             runsAt: { $lt: params.runsAt.$lt },
             status: {
                 $in: [

package/lib/chevre/repo/mongoose/schemas/asyncAction.d.ts

@@ -0,0 +1,11 @@
+import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
+import { factory } from '../../../factory';
+type IDocType = Pick<factory.task.ITask<factory.taskName>, 'alternateName' | 'data' | 'dateAborted' | 'description' | 'executionResults' | 'executor' | 'expires' | 'identifier' | 'lastTriedAt' | 'name' | 'project' | 'runsAt' | 'status'>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
+type ISchemaDefinition = SchemaDefinition<IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
+declare const modelName = "AsyncAction";
+declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): ISchema;
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelName = exports.indexes = void 0;
+exports.createSchema = createSchema;
+const mongoose_1 = require("mongoose");
+const writeConcern_1 = require("../writeConcern");
+const settings_1 = require("../../../settings");
+const modelName = 'AsyncAction';
+exports.modelName = modelName;
+const schemaDefinition = {
+    alternateName: String, // add(2025-03-28~)
+    identifier: String,
+    description: String, // add(2025-03-30~)
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    name: { type: String, required: true },
+    status: { type: String, required: true },
+    runsAt: { type: Date, required: true },
+    expires: { type: Date, required: true },
+    lastTriedAt: Date,
+    executionResults: [mongoose_1.SchemaTypes.Mixed],
+    executor: mongoose_1.SchemaTypes.Mixed,
+    data: mongoose_1.SchemaTypes.Mixed,
+    dateAborted: Date,
+    // remainingNumberOfTries: { type: Number, required: true }, // ワンタイム前提につき不要
+    // numberOfTried: { type: Number, required: true }, // ワンタイム前提につき不要
+};
+const schemaOptions = {
+    autoIndex: settings_1.MONGO_AUTO_INDEX,
+    autoCreate: false,
+    collection: 'asyncActions',
+    id: true,
+    read: 'primary',
+    writeConcern: writeConcern_1.writeConcern,
+    strict: true,
+    strictQuery: false,
+    timestamps: false,
+    versionKey: false,
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+};
+const indexes = [
+    [
+        { 'project.id': 1, runsAt: -1 },
+        { name: 'projectId' }
+    ],
+    [
+        { name: 1, runsAt: -1 },
+        { name: 'asyncActionName' }
+    ],
+    [
+        { status: 1, runsAt: -1 },
+        { name: 'status' }
+    ],
+    [
+        { runsAt: -1 },
+        { name: 'runsAt' }
+    ],
+    [
+        { identifier: 1, runsAt: -1 },
+        {
+            name: 'identifier',
+            partialFilterExpression: {
+                identifier: { $exists: true }
+            }
+        }
+    ],
+    [
+        { dateAborted: 1, runsAt: -1 },
+        {
+            name: 'dateAborted',
+            partialFilterExpression: {
+                dateAborted: { $exists: true }
+            }
+        }
+    ],
+    [
+        { lastTriedAt: 1, runsAt: -1 },
+        {
+            name: 'lastTriedAt',
+            partialFilterExpression: {
+                lastTriedAt: { $exists: true }
+            }
+        }
+    ],
+    [
+        { expires: 1, runsAt: -1 },
+        {
+            name: 'expires',
+            partialFilterExpression: {
+                expires: { $exists: true }
+            }
+        }
+    ],
+    [
+        { status: 1, lastTriedAt: 1 },
+        {
+            name: 'abortMany',
+            partialFilterExpression: {
+                lastTriedAt: { $exists: true }
+            }
+        }
+    ],
+    [
+        { status: 1, expires: 1 },
+        {
+            name: 'makeExpiredMany',
+            partialFilterExpression: {
+                expires: { $exists: true }
+            }
+        }
+    ],
+    [
+        // add unique index(2025-03-28~)
+        { alternateName: 1 },
+        {
+            unique: true,
+            name: 'uniqueAlternateName',
+            partialFilterExpression: {
+                alternateName: { $exists: true }
+            }
+        }
+    ],
+    [
+        { identifier: 1 },
+        {
+            unique: true,
+            name: 'uniqueIdentifier',
+            partialFilterExpression: {
+                identifier: { $exists: true }
+            }
+        }
+    ]
+];
+exports.indexes = indexes;
+/**
+ * 非同期アクションスキーマ
+ */
+let schema;
+function createSchema() {
+    if (schema === undefined) {
+        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
+        if (settings_1.MONGO_AUTO_INDEX) {
+            indexes.forEach((indexParams) => {
+                schema?.index(...indexParams);
+            });
+        }
+    }
+    return schema;
+}

package/lib/chevre/service/asyncAction.d.ts

@@ -1,7 +1,11 @@
-import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction, IReadyTask } from '../eventEmitter/task';
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction } from '../eventEmitter/task';
 type IExecuteSettings = IMinimumExecuteSettings;
 type IOperation<T> = (settings: IExecuteSettings) => Promise<T>;
-declare function executeAsyncActionById(params: IReadyTask & {
+declare function executeAsyncActionById(params: {
+    /**
+     * タスクID
+     */
+    id: string;
     executor: {
         /**
          * タスク実行者名称

package/lib/chevre/service/asyncAction.js

@@ -13,14 +13,12 @@ const debug = (0, debug_1.default)('chevre-domain:service:task');
 function executeAsyncActionById(params, next) {
     return async (settings) => {
         const asyncActionRepo = new (await import('../repo/asyncAction.js')).AsyncActionRepo(settings.connection);
-        const { id, status, executor, expires } = params;
+        const { id, executor } = params;
         let task = null;
         try {
             task = await asyncActionRepo.executeAsyncActionById({
                 id,
-                status,
-                executor: { name: executor.name },
-                ...(expires instanceof Date) ? { expires } : undefined
+                executor: { name: executor.name }
             });
         }
         catch (error) {

package/lib/chevre/service/asyncActionHandler/onOperationFailed.d.ts

@@ -1,13 +1,11 @@
 import type { IExecutedTask } from '../../eventEmitter/task';
-import { factory } from '../../factory';
 import type { SettingRepo } from '../../repo/setting';
-import type { AsyncActionRepo } from '../../repo/asyncAction';
-import type { IExecutableTask } from '../../taskSettings';
+import type { AsyncActionRepo, IExecutableAsyncAction } from '../../repo/asyncAction';
 /**
  * タスク実行失敗時処理
  */
 declare function onOperationFailed(params: {
-    task: IExecutableTask<factory.taskName>;
+    task: IExecutableAsyncAction;
     now: Date;
     error: any;
 }): (repos: {

package/lib/chevre/service/asyncActionHandler/onOperationFailed.js

@@ -32,7 +32,7 @@ function onOperationFailed(params) {
         });
         const executedTask = {
             id: task.id,
-            remainingNumberOfTries: task.remainingNumberOfTries,
+            remainingNumberOfTries: 0,
             name: task.name,
             status: task.status,
             executionResult: result

package/lib/chevre/service/asyncActionHandler.d.ts

@@ -1,6 +1,6 @@
 import type { INextFunction } from '../eventEmitter/task';
-import { factory } from '../factory';
-import type { ICallResult, ICallableTaskOperation, IExecutableTask, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { ICallResult, ICallableTaskOperation, IExecutableTaskKeys, IOperationExecute } from '../taskSettings';
+import type { IExecutableAsyncAction } from '../repo/asyncAction';
 export declare const taskLoader: {
     load: (taskName: string) => Promise<{
         call: ICallableTaskOperation;
@@ -9,5 +9,5 @@ export declare const taskLoader: {
 /**
  * 非同期アクションを実行する
  */
-declare function executeAsyncAction(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
+declare function executeAsyncAction(task: IExecutableAsyncAction, next?: INextFunction): IOperationExecute<void>;
 export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeAsyncAction };

package/lib/chevre/service/asyncActionHandler.js

@@ -34,16 +34,15 @@ function executeAsyncAction(task, next) {
                     throw new factory_1.factory.errors.Internal(`task expired [expires:${task.expires}]`);
                 }
             }
+            // remainingNumberOfTriesは存在しないので検証不要
             // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
-            // リトライを繰り返した後、不明の原因でRunningのまま残ってしまったタスクがリトライされたケース
-            const { remainingNumberOfTries } = task;
-            const isCallable = remainingNumberOfTries >= 0;
-            if (!isCallable) {
-                throw new factory_1.factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
-            }
             // タスク名の関数が定義されていなければ、TypeErrorとなる
             const { call } = await exports.taskLoader.load(task.name); // testが書きづらいのでtaskLoader経由で呼ぶ
-            const callResult = await call(task)(settings, options);
+            const callResult = await call({
+                ...task,
+                numberOfTried: 1, // ひとまず固定でok(2026-07-26~)
+                remainingNumberOfTries: 0 // ひとまず固定でok(2026-07-26~)
+            })(settings, options);
             const result = {
                 executedAt: now,
                 endDate: new Date(),

package/package.json

@@ -88,5 +88,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "25.2.0-alpha.47"
+  "version": "25.2.0-alpha.48"
 }