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

package/lib/chevre/repo/stockHolder.js

@@ -13,7 +13,7 @@ exports.StockHolderRepo = void 0;
 const createDebug = require("debug");
 const moment = require("moment");
 const factory = require("../factory");
-const setting_1 = require("./mongoose/schemas/setting");
+// 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;
@@ -24,7 +24,7 @@ const USE_STOCK_HOLDER_CHECK_CONFLICT = process.env.USE_STOCK_HOLDER_CHECK_CONFL
 class StockHolderRepo {
     constructor(redisClient, connection) {
         this.redisClient = redisClient;
-        this.settingModel = connection.model(setting_1.modelName, (0, setting_1.createSchema)());
+        // this.settingModel = connection.model(modelName, createSchema());
         this.pendingReservationRepo = new pendingReservation_1.PendingReservationRepo(connection);
     }
     static offer2field(params, hasTicketedSeat) {
@@ -251,8 +251,10 @@ class StockHolderRepo {
         return __awaiter(this, void 0, void 0, function* () {
             const key = StockHolderRepo.createKey(params);
             const existingRedisKeyCount = yield this.redisClient.exists(key);
-            // console.log('existingRedisKeyCount:', existingRedisKeyCount);
-            return typeof existingRedisKeyCount === 'number' && existingRedisKeyCount > 0;
+            if (typeof existingRedisKeyCount !== 'number') {
+                throw new factory.errors.Internal(`unexpected existingKeyCount: ${typeof existingRedisKeyCount}`);
+            }
+            return existingRedisKeyCount > 0;
         });
     }
     checkIfConflicted(params) {
@@ -286,16 +288,24 @@ class StockHolderRepo {
             }
             let useMongoose = false;
             // useMongoAsStockHolder設定有の場合のみmongo利用(2025-04-18~)
-            const useMongoAsStockHolderBySettings = yield this.useMongoAsStockHolderBySettings({ project: { id: params.project.id } });
-            if (useMongoAsStockHolderBySettings) {
-                const redisKeyExists = yield this.redisKeyExists(params);
-                if (redisKeyExists) {
-                    useMongoose = false;
-                }
-                else {
-                    // redis keyが存在しなければmongo利用
-                    useMongoose = true;
-                }
+            // const useMongoAsStockHolderBySettings = await this.useMongoAsStockHolderBySettings({ project: { id: params.project.id } });
+            // if (useMongoAsStockHolderBySettings) {
+            //     const redisKeyExists = await this.redisKeyExists(params);
+            //     if (redisKeyExists) {
+            //         useMongoose = false;
+            //     } else {
+            //         // redis keyが存在しなければmongo利用
+            //         useMongoose = true;
+            //     }
+            // }
+            // 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) {
@@ -304,23 +314,6 @@ class StockHolderRepo {
             return useMongoose;
         });
     }
-    useMongoAsStockHolderBySettings(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // useMongoAsStockHolder設定有の場合のみmongo利用(2025-04-18~)
-            const setting = yield this.settingModel.findOne({ 'project.id': { $eq: '*' } }, {
-                _id: 0,
-                useMongoAsStockHolder: 1,
-                useMongoAsStockHolderProjects: 1
-            })
-                .lean()
-                .exec();
-            const useMongoGlobally = (setting === null || setting === void 0 ? void 0 : setting.useMongoAsStockHolder) === true;
-            const useMongoAsStockHolderProjects = setting === null || setting === void 0 ? void 0 : setting.useMongoAsStockHolderProjects;
-            const useMongoByProject = Array.isArray(useMongoAsStockHolderProjects)
-                && useMongoAsStockHolderProjects.includes(params.project.id);
-            return useMongoGlobally || useMongoByProject;
-        });
-    }
 }
 exports.StockHolderRepo = StockHolderRepo;
 StockHolderRepo.KEY_PREFIX_NEW = 'stockHolder';

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

@@ -1,4 +1,5 @@
 import type { AnyKeys, Connection, FilterQuery, ProjectionType, UpdateWriteOpResult } from 'mongoose';
+import { INextFunction } from '../eventEmitter/task';
 import * as factory from '../factory';
 import { IModel } from './mongoose/schemas/task';
 interface IAggregationByStatus {
@@ -23,7 +24,6 @@ interface IOptionOnCreate {
 }
 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>;
-type IDelayedTask = Pick<factory.task.ITask<factory.taskName>, 'id' | 'name' | 'status'>;
 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'>;
 /**
@@ -36,7 +36,8 @@ export declare class TaskRepo {
     runImmediately(params: Pick<factory.task.IAttributes<factory.taskName>, 'data' | 'expires' | 'name' | 'project' | 'remainingNumberOfTries' | 'runsAt'> & {
         alternateName?: never;
         identifier?: never;
-    }): Promise<{
+        expires: Date;
+    }, next: INextFunction): Promise<{
         id: string;
     }>;
     saveMany(taskAttributes: ICreatingTask[], options: IOptionOnCreate): Promise<{
@@ -133,24 +134,6 @@ export declare class TaskRepo {
     /**
      * emit OnTaskStatusChanged on delayed tasks
      */
-    emitDelayedTasksEvent(params: {
-        now: Date;
-        /**
-         * 指定期間遅延しているタスクを実行する
-         */
-        delayInSeconds: number;
-        limit: number;
-        name: {
-            /**
-             * 指定タスクのみ実行する
-             */
-            $in?: factory.taskName[];
-            /**
-             * 指定タスク以外のみ実行する
-             */
-            $nin?: factory.taskName[];
-        };
-    }): Promise<IDelayedTask[]>;
     /**
      * make tasks expired
      */
@@ -180,11 +163,13 @@ export declare class TaskRepo {
     /**
      * 実行結果を保管する
      */
-    pushExecutionResultById(
-    /**
-     * タスクID
-     */
-    id: string, status: factory.taskStatus, executionResult: factory.task.IExecutionResult): Promise<void>;
+    pushExecutionResultById(params: {
+        /**
+         * タスクID
+         */
+        id: string;
+        status: factory.taskStatus;
+    }, executionResult: factory.task.IExecutionResult, next?: INextFunction): Promise<void>;
     /**
      * 特定タスク検索
      */

package/lib/chevre/repo/task.js

@@ -156,7 +156,9 @@ class TaskRepo {
     }
     runImmediately(
     // resolve uniqueness of identifier(2025-03-27~)
-    params) {
+    params, 
+    // support customr function(2025-05-25~)
+    next) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const { expires } = params;
@@ -173,7 +175,7 @@ class TaskRepo {
                 id,
                 status: factory.taskStatus.Ready,
                 expires // emit expires(2025-03-31~)
-            });
+            }, next);
             return { id };
         });
     }
@@ -623,38 +625,62 @@ class TaskRepo {
             return doc;
         });
     }
+    // discontinue(2025-05-26~)
     /**
      * emit OnTaskStatusChanged on delayed tasks
      */
-    emitDelayedTasksEvent(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const runsAtLt = moment(params.now)
-                .add(-params.delayInSeconds, 'seconds')
-                .toDate();
-            const projection = {
-                _id: 0,
-                id: { $toString: '$_id' },
-                name: 1,
-                status: 1
-            };
-            const delayedTasks = yield this.taskModel.find(Object.assign(Object.assign({ status: { $eq: factory.taskStatus.Ready }, runsAt: { $lt: runsAtLt } }, (Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined), (Array.isArray(params.name.$nin)) ? { name: { $nin: params.name.$nin } } : undefined), projection)
-                .limit(params.limit)
-                .sort(sortOrder4executionOfTasks) // sort(2025-03-03~)
-                .setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
-                .lean() // lean(2024-09-26~)
-                .exec();
-            if (delayedTasks.length > 0) {
-                delayedTasks.forEach((delayedTask) => {
-                    task_1.taskEventEmitter.emitTaskStatusChanged({
-                        id: delayedTask.id,
-                        name: delayedTask.name,
-                        status: factory.taskStatus.Ready
-                    });
-                });
-            }
-            return delayedTasks;
-        });
-    }
+    // public async emitDelayedTasksEvent(params: {
+    //     now: Date;
+    //     /**
+    //      * 指定期間遅延しているタスクを実行する
+    //      */
+    //     delayInSeconds: number;
+    //     limit: number;
+    //     name: {
+    //         /**
+    //          * 指定タスクのみ実行する
+    //          */
+    //         $in?: factory.taskName[];
+    //         /**
+    //          * 指定タスク以外のみ実行する
+    //          */
+    //         $nin?: factory.taskName[];
+    //     };
+    // }) {
+    //     const runsAtLt = moment(params.now)
+    //         .add(-params.delayInSeconds, 'seconds')
+    //         .toDate();
+    //     const projection: ProjectionType<factory.task.ITask<factory.taskName>> = {
+    //         _id: 0,
+    //         id: { $toString: '$_id' },
+    //         name: 1,
+    //         status: 1
+    //     };
+    //     const delayedTasks = await this.taskModel.find(
+    //         {
+    //             status: { $eq: factory.taskStatus.Ready },
+    //             runsAt: { $lt: runsAtLt },
+    //             ...(Array.isArray(params.name.$in)) ? { name: { $in: params.name.$in } } : undefined,
+    //             ...(Array.isArray(params.name.$nin)) ? { name: { $nin: params.name.$nin } } : undefined
+    //         },
+    //         projection
+    //     )
+    //         .limit(params.limit)
+    //         .sort(sortOrder4executionOfTasks) // sort(2025-03-03~)
+    //         .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<IDelayedTask[]>() // lean(2024-09-26~)
+    //         .exec();
+    //     if (delayedTasks.length > 0) {
+    //         delayedTasks.forEach((delayedTask) => {
+    //             taskEventEmitter.emitTaskStatusChanged({
+    //                 id: delayedTask.id,
+    //                 name: delayedTask.name,
+    //                 status: factory.taskStatus.Ready
+    //             });
+    //         });
+    //     }
+    //     return delayedTasks;
+    // }
     /**
      * make tasks expired
      */
@@ -770,17 +796,20 @@ class TaskRepo {
     /**
      * 実行結果を保管する
      */
-    pushExecutionResultById(
-    /**
-     * タスクID
-     */
-    id, status, executionResult) {
+    pushExecutionResultById(params, executionResult, 
+    // support customr function(2025-05-25~)
+    next) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { id, status } = params;
             yield this.taskModel.updateOne({ _id: { $eq: id } }, {
                 $set: { status },
                 $push: { executionResults: executionResult }
             })
                 .exec();
+            // emit event(2025-05-26~)
+            if (typeof next === 'function') {
+                task_1.taskEventEmitter.emitTaskStatusChanged({ id, status, executionResult }, next);
+            }
         });
     }
     /**

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

@@ -1,4 +1,6 @@
+import type { Connection } from 'mongoose';
 import { RedisClientType } from 'redis';
+import { ISetting } from './mongoose/schemas/setting';
 interface IPublishResult {
     transactionNumber: string;
 }
@@ -6,15 +8,24 @@ interface IPublishResult {
  * 取引番号リポジトリ
  */
 export declare class TransactionNumberRepo {
-    private static readonly REDIS_KEY_PREFIX;
-    private readonly redisClient;
-    constructor(redisClient: RedisClientType);
-    private static createKey;
+    private readonly settingModel;
+    private readonly counterRepo;
+    constructor(params: {
+        redisClient: RedisClientType;
+        connection: Connection;
+    });
     /**
      * タイムスタンプから発行する
      */
     publishByTimestamp(params: {
         startDate: Date;
     }): Promise<IPublishResult>;
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4transactionNumberFrom(params: {
+        useMongo4transactionNumberFrom: Date;
+    }): Promise<Pick<ISetting, "useMongo4transactionNumberFrom"> | null>;
+    private useMongoBySettings;
 }
 export {};

package/lib/chevre/repo/transactionNumber.js

@@ -12,20 +12,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionNumberRepo = void 0;
 const cdigit = require("cdigit");
 const moment = require("moment-timezone");
-const util = require("util");
 // tslint:disable-next-line:no-require-imports no-var-requires
 const fpe = require('node-fpe');
-const factory = require("../factory");
+const setting_1 = require("./mongoose/schemas/setting");
+const transactionNumber_1 = require("./mongoose/schemas/transactionNumber");
+const transactionNumberCounter_1 = require("./transactionNumberCounter");
 /**
  * 取引番号リポジトリ
  */
 class TransactionNumberRepo {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    static createKey(params) {
-        return util.format('%s:%s', TransactionNumberRepo.REDIS_KEY_PREFIX, params.timestamp);
+    constructor(params) {
+        const { connection } = params;
+        this.settingModel = connection.model(setting_1.modelName, (0, setting_1.createSchema)());
+        this.counterRepo = new transactionNumberCounter_1.TransactionNumberCounterRepo(params);
     }
+    // private static createKey(params: {
+    //     startDate: Date;
+    //     timestamp: string;
+    // }): string {
+    //     return util.format(
+    //         '%s:%s',
+    //         TransactionNumberRepo.REDIS_KEY_PREFIX,
+    //         params.timestamp
+    //     );
+    // }
     /**
      * タイムスタンプから発行する
      */
@@ -34,20 +44,29 @@ class TransactionNumberRepo {
             const timestamp = moment(params.startDate)
                 .valueOf()
                 .toString();
-            const now = moment();
-            const TTL = moment(params.startDate)
-                .add(1, 'minute') // ミリ秒でカウントしていくので、予約日時後1分で十分
-                .diff(now, 'seconds');
-            const key = TransactionNumberRepo.createKey({ startDate: params.startDate, timestamp });
-            const [incrReply] = yield this.redisClient.multi()
-                .incr(key)
-                .expire(key, TTL)
-                .exec();
-            // tslint:disable-next-line:no-single-line-block-comment
-            /* istanbul ignore else: please write tests */
-            if (typeof incrReply !== 'number') {
-                // 基本的にありえないフロー
-                throw new factory.errors.Internal('transaction number not incremented unexpectedly');
+            let dataFeedExpires;
+            const dataFeedIdentifier = timestamp;
+            let incrReply;
+            const useMongoBySettings = yield this.useMongoBySettings(params);
+            if (useMongoBySettings) {
+                dataFeedExpires = moment(params.startDate)
+                    .add(1, 'minute') // ミリ秒でカウントしていくので、予約日時後1分で十分
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByMongo({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.transactionNumber },
+                    expires: dataFeedExpires
+                });
+            }
+            else {
+                dataFeedExpires = moment(params.startDate)
+                    .add(1, 'minute') // ミリ秒でカウントしていくので、予約日時後1分で十分
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByRedis({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.transactionNumber },
+                    expires: dataFeedExpires
+                });
             }
             let transactionNumber = `${timestamp}${incrReply}`;
             // checkdigit
@@ -58,6 +77,32 @@ class TransactionNumberRepo {
             return { transactionNumber };
         });
     }
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4transactionNumberFrom(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useMongo4transactionNumberFrom } = params;
+            return this.settingModel.findOneAndUpdate({ 'project.id': { $eq: '*' } }, {
+                $set: { useMongo4transactionNumberFrom }
+            }, { projection: { _id: 0, useMongo4transactionNumberFrom: 1 } })
+                .lean()
+                .exec();
+        });
+    }
+    useMongoBySettings(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const setting = yield this.settingModel.findOne({ 'project.id': { $eq: '*' } }, {
+                _id: 0,
+                useMongo4transactionNumberFrom: 1
+            })
+                .lean()
+                .exec();
+            const useMongo4transactionNumberFrom = setting === null || setting === void 0 ? void 0 : setting.useMongo4transactionNumberFrom;
+            return useMongo4transactionNumberFrom instanceof Date
+                && moment(params.startDate)
+                    .isSameOrAfter(moment(useMongo4transactionNumberFrom));
+        });
+    }
 }
 exports.TransactionNumberRepo = TransactionNumberRepo;
-TransactionNumberRepo.REDIS_KEY_PREFIX = 'transactionNumber';

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

@@ -0,0 +1,28 @@
+import type { Connection } from 'mongoose';
+import { RedisClientType } from 'redis';
+import { DataCatalogIdentifier } from './mongoose/schemas/transactionNumber';
+/**
+ * 取引番号カウンターリポジトリ
+ */
+export declare class TransactionNumberCounterRepo {
+    private readonly redisClient;
+    private readonly transactionNumberModel;
+    constructor(params: {
+        redisClient: RedisClientType;
+        connection: Connection;
+    });
+    incrementByRedis(params: {
+        identifier: string;
+        includedInDataCatalog: {
+            identifier: DataCatalogIdentifier;
+        };
+        expires: Date;
+    }): Promise<number>;
+    incrementByMongo(params: {
+        identifier: string;
+        includedInDataCatalog: {
+            identifier: DataCatalogIdentifier;
+        };
+        expires: Date;
+    }): Promise<number>;
+}

package/lib/chevre/repo/transactionNumberCounter.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionNumberCounterRepo = void 0;
+const errorHandler_1 = require("../errorHandler");
+const factory = require("../factory");
+const transactionNumber_1 = require("./mongoose/schemas/transactionNumber");
+const MAX_RETRY_INCREMENT = 1;
+/**
+ * 取引番号カウンターリポジトリ
+ */
+class TransactionNumberCounterRepo {
+    constructor(params) {
+        const { redisClient, connection } = params;
+        this.redisClient = redisClient;
+        this.transactionNumberModel = connection.model(transactionNumber_1.modelName, (0, transactionNumber_1.createSchema)());
+    }
+    incrementByRedis(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const now = moment();
+            const { expires } = params;
+            const key = `${params.includedInDataCatalog.identifier}:${params.identifier}`;
+            // const TTL = moment(expires)
+            //     .diff(now, 'seconds');
+            const [incrReply, expireAtReply] = yield this.redisClient.multi()
+                .incr(key)
+                // .expire(key, TTL)
+                .expireAt(key, expires)
+                .exec();
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore else: please write tests */
+            if (typeof incrReply !== 'number') {
+                // 基本的にありえないフロー
+                throw new factory.errors.Internal('transaction number not incremented unexpectedly');
+            }
+            // expireAtReplyの検証も追加する(2023-04-19~)
+            const expiredSet = expireAtReply === 1 || expireAtReply === true;
+            if (!expiredSet) {
+                // 基本的にありえないフロー
+                throw new factory.errors.Internal('transaction number expiration not set unexpectedly');
+            }
+            return incrReply;
+        });
+    }
+    incrementByMongo(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const now = new Date();
+            const dataFeedExpires = params.expires;
+            const dataFeedIdentifier = params.identifier;
+            const dataFeed = {
+                typeOf: 'DataFeed',
+                includedInDataCatalog: {
+                    identifier: params.includedInDataCatalog.identifier,
+                    typeOf: 'DataCatalog'
+                },
+                dateCreated: now,
+                expires: dataFeedExpires,
+                identifier: dataFeedIdentifier,
+                interactionStatistic: {
+                    typeOf: 'InteractionCounter',
+                    userInteractionCount: 0
+                },
+                project: { id: '*', typeOf: factory.organizationType.Project }
+            };
+            const { typeOf, includedInDataCatalog, dateCreated, expires, identifier, project, interactionStatistic } = dataFeed;
+            let doc;
+            let retryCount = 0;
+            while (retryCount <= MAX_RETRY_INCREMENT) {
+                try {
+                    doc = yield this.transactionNumberModel.findOneAndUpdate({
+                        'project.id': { $eq: dataFeed.project.id },
+                        'includedInDataCatalog.identifier': { $eq: dataFeed.includedInDataCatalog.identifier },
+                        identifier: { $eq: dataFeed.identifier }
+                    }, {
+                        $set: {
+                            dateModified: now
+                        },
+                        $setOnInsert: {
+                            typeOf, includedInDataCatalog, dateCreated, expires, identifier, project,
+                            'interactionStatistic.typeOf': interactionStatistic.typeOf
+                        },
+                        $inc: {
+                            'interactionStatistic.userInteractionCount': 1
+                        }
+                    }, {
+                        upsert: true,
+                        new: true,
+                        projection: { _id: 0, interactionStatistic: 1 }
+                    })
+                        .lean()
+                        .exec();
+                    break;
+                }
+                catch (error) {
+                    if (yield (0, errorHandler_1.isMongoError)(error)) {
+                        if (error.code === errorHandler_1.MongoErrorCode.DuplicateKey) {
+                            // すでに存在するので、リトライすればincrementに成功するはず
+                            retryCount += 1;
+                            continue;
+                        }
+                    }
+                    throw error;
+                }
+            }
+            if (doc === undefined) {
+                throw new factory.errors.NotFound('DataFeed');
+            }
+            const incrReply = (_a = doc.interactionStatistic) === null || _a === void 0 ? void 0 : _a.userInteractionCount;
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore if */
+            if (typeof incrReply !== 'number') {
+                // 基本的にありえないフロー
+                throw new factory.errors.Internal('confirmation number not incremented unexpectedly');
+            }
+            return incrReply;
+        });
+    }
+}
+exports.TransactionNumberCounterRepo = TransactionNumberCounterRepo;

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

@@ -6,6 +6,9 @@ interface IProcessKey {
      * 取引ID
      */
     id: string;
+    project: {
+        id: string;
+    };
 }
 interface IOptions {
     lockExpiresInSeconds: number;
@@ -14,11 +17,11 @@ interface IOptions {
  * 取引プロセスリポジトリ
  */
 export declare class TransactionProcessRepo {
+    private readonly concurrentLockRepo;
     private readonly options;
-    private readonly redisClient;
     constructor(redisClient: RedisClientType, options: IOptions);
-    static CREATE_REDIS_KEY(params: IProcessKey): string;
-    lock(params: IProcessKey): Promise<boolean>;
-    unlock(params: IProcessKey): Promise<void>;
+    static CREATE_REDIS_KEY(params: Pick<IProcessKey, 'id' | 'typeOf'>): string;
+    lock(params: IProcessKey): Promise<void>;
+    unlock(params: Pick<IProcessKey, 'id' | 'typeOf'>): Promise<void>;
 }
 export {};