@chevre/domain 22.10.0-alpha.20 → 22.10.0-alpha.22

package/example/src/chevre/concurrentLock/lockOfferRateLimit.ts

@@ -0,0 +1,64 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const rateLimitRepo = await chevre.repository.rateLimit.Offer.createInstance(
+        client
+    );
+
+    // await rateLimitRepo.unlock({
+    //     project: { id: project.id },
+    //     reservedTicket: {
+    //         ticketType: {
+    //             validRateLimit: {
+    //                 scope: 'scope2',
+    //                 unitInSeconds: 60
+    //             }
+    //         }
+    //     },
+    //     reservationFor: {
+    //         startDate: new Date()
+    //     },
+    //     reservationNumber: 'xxx'
+    // });
+    // console.log('unlocked');
+    await rateLimitRepo.lock({
+        project: { id: project.id },
+        reservedTicket: {
+            ticketType: {
+                validRateLimit: {
+                    scope: 'scope2',
+                    unitInSeconds: 60
+                }
+            }
+        },
+        reservationFor: {
+            startDate: new Date()
+        },
+        reservationNumber: 'xxx'
+    });
+    console.log('locked');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/concurrentLock/lockTransactionProcess.ts

@@ -0,0 +1,44 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const processRepo = await chevre.repository.TransactionProcess.createInstance(
+        client,
+        { lockExpiresInSeconds: 60 }
+    );
+
+    // await processRepo.unlock({
+    //     id: 'xxx',
+    //     typeOf: chevre.factory.transactionType.PlaceOrder
+    // });
+    // console.log('unlocked');
+    await processRepo.lock({
+        id: 'xxx',
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        project: { id: project.id }
+    });
+    console.log('locked');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/transactionNumber/setUseMongo4orderNumberFrom.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const orderNumberRepo = await chevre.repository.OrderNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await orderNumberRepo.setUseMongo4orderNumberFrom({
+        useMongo4orderNumberFrom: moment('2025-05-26T05:40:00Z')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/redisMulti.ts

@@ -0,0 +1,63 @@
+
+// tslint:disable:no-console no-magic-numbers no-null-keyword
+import type * as Redis from 'redis';
+
+const REDIS_PING_INTERVAL_MS: number = (typeof process.env.REDIS_PING_INTERVAL_MS === 'string')
+    ? Number(process.env.REDIS_PING_INTERVAL_MS)
+    // tslint:disable-next-line:no-magic-numbers
+    : 30000;
+const REDIS_HOST: string = String(process.env.REDIS_HOST);
+const REDIS_PORT: number = Number(process.env.REDIS_PORT);
+const REDIS_KEY: string = String(process.env.REDIS_KEY);
+
+const redisClientOptions: Redis.RedisClientOptions<Redis.RedisDefaultModules, Record<string, never>, Record<string, never>> = {
+    socket: {
+        host: REDIS_HOST,
+        port: REDIS_PORT
+        // tls: (process.env.REDIS_TLS_SERVERNAME !== undefined) ? { servername: process.env.REDIS_TLS_SERVERNAME } : undefined
+    },
+    password: REDIS_KEY,
+    pingInterval: REDIS_PING_INTERVAL_MS,
+    disableOfflineQueue: false
+};
+
+let redis: typeof Redis | undefined;
+async function createRedisClient(): Promise<Redis.RedisClientType> {
+    return new Promise<Redis.RedisClientType>(async (resolve, reject) => {
+        if (redis === undefined) {
+            redis = await import('redis');
+        }
+
+        const client = redis.createClient<Redis.RedisDefaultModules, Record<string, never>, Record<string, never>>(redisClientOptions)
+            .on('error', (err) => {
+                // tslint:disable-next-line:no-console
+                console.error('createRedisClient: client onError:', err);
+                reject(err);
+            })
+            .on('connect', () => {
+                resolve(client);
+            });
+        // client.on('ready', () => {
+        //     console.error('Redis Client ready');
+        // });
+
+        await client.connect()
+            .catch((err) => {
+                // tslint:disable-next-line:no-console
+                console.error('createRedisClient: redisClient.connect:', err);
+                reject(new Error('createRedisClient: failed in creating connection'));
+            });
+    });
+}
+
+async function main() {
+    const redisClient = await createRedisClient();
+    console.log('redisClient created.', redisClient.options?.name);
+
+    const multi = await redisClient.multi();
+    const results = await multi.exec();
+    console.log(results);
+}
+
+main()
+    .catch(console.error);

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

@@ -0,0 +1,14 @@
+import type { RedisClientType } from 'redis';
+import { AbstractConcurrentLockRepo, ILockParams, IUnlockParams } from './concurrentLockAbstract';
+/**
+ * 同時実行ロックリポジトリ
+ */
+export declare class ConcurrentLockRepo implements AbstractConcurrentLockRepo {
+    private readonly redisClient;
+    constructor(params: {
+        redisClient: RedisClientType;
+    });
+    static CREATE_REDIS_KEY(params: Pick<ILockParams, 'about'>): string;
+    lock(params: ILockParams): Promise<void>;
+    unlock(params: IUnlockParams): Promise<void>;
+}

package/lib/chevre/repo/concurrentLock.js

@@ -0,0 +1,48 @@
+"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.ConcurrentLockRepo = void 0;
+const factory = require("../factory");
+/**
+ * 同時実行ロックリポジトリ
+ */
+class ConcurrentLockRepo {
+    constructor(params) {
+        const { redisClient } = params;
+        this.redisClient = redisClient;
+    }
+    static CREATE_REDIS_KEY(params) {
+        return params.about.identifier;
+    }
+    lock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = ConcurrentLockRepo.CREATE_REDIS_KEY(params);
+            const value = params.audience.identifier;
+            const results = yield this.redisClient.multi()
+                .setNX(key, value)
+                .expireAt(key, params.expires)
+                .exec();
+            if (Array.isArray(results) && (results[0] === 1 || results[0] === true)) {
+                return;
+            }
+            else {
+                throw new factory.errors.AlreadyInUse(params.about.identifier, []);
+            }
+        });
+    }
+    unlock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = ConcurrentLockRepo.CREATE_REDIS_KEY(params);
+            yield this.redisClient.del([key]);
+        });
+    }
+}
+exports.ConcurrentLockRepo = ConcurrentLockRepo;

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

@@ -0,0 +1,42 @@
+import * as factory from '../factory';
+export interface IOffer {
+    itemOffered?: {
+        serviceOutput?: {
+            /**
+             * 予約ID
+             */
+            id?: string;
+        };
+    };
+    seatSection: string;
+    seatNumber: string;
+}
+export interface IAbout {
+    identifier: string;
+    typeOf: 'Thing';
+}
+export interface IAudience {
+    identifier: string;
+    typeOf: 'Audience';
+}
+export interface IConcurrentLock {
+    project: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    typeOf: factory.creativeWorkType.Certification;
+    about: IAbout;
+    dateCreated: Date;
+    expires: Date;
+    audience: IAudience;
+}
+export type ILockParams = Pick<IConcurrentLock, 'about' | 'audience' | 'expires' | 'project'>;
+export type IUnlockParams = Pick<IConcurrentLock, 'about' | 'audience'>;
+export type IGetHolderResult = string | null;
+/**
+ * 抽象同時実行ロックリポジトリ
+ */
+export declare abstract class AbstractConcurrentLockRepo {
+    abstract lock(lockKey: ILockParams): Promise<void>;
+    abstract unlock(params: IUnlockParams): Promise<void>;
+}

package/lib/chevre/repo/concurrentLockAbstract.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractConcurrentLockRepo = void 0;
+/**
+ * 抽象同時実行ロックリポジトリ
+ */
+class AbstractConcurrentLockRepo {
+}
+exports.AbstractConcurrentLockRepo = AbstractConcurrentLockRepo;

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

@@ -25,7 +25,9 @@ const schemaDefinition = {
     waiter: mongoose_1.SchemaTypes.Mixed,
     useMongoAsStockHolder: Boolean,
     useMongoAsStockHolderProjects: [String],
-    useMongo4confirmationNumberFrom: { type: Date, required: false }
+    useMongo4confirmationNumberFrom: { type: Date, required: false },
+    useMongo4orderNumberFrom: { type: Date, required: false },
+    useMongo4transactionNumberFrom: { type: Date, required: false }
 };
 const schemaOptions = {
     autoIndex: settings_1.MONGO_AUTO_INDEX,

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

@@ -1,5 +1,6 @@
 import type { Connection } from 'mongoose';
 import { RedisClientType } from 'redis';
+import { ISetting } from './mongoose/schemas/setting';
 /**
  * 注文番号リポジトリ
  */
@@ -22,5 +23,11 @@ export declare class OrderNumberRepo {
          */
         orderDate: Date;
     }): Promise<string>;
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4orderNumberFrom(params: {
+        useMongo4orderNumberFrom: Date;
+    }): Promise<Pick<ISetting, "useMongo4orderNumberFrom"> | null>;
     private useMongoBySettings;
 }

package/lib/chevre/repo/orderNumber.js

@@ -84,6 +84,19 @@ class OrderNumberRepo {
             return orderNumber;
         });
     }
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4orderNumberFrom(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useMongo4orderNumberFrom } = params;
+            return this.settingModel.findOneAndUpdate({ 'project.id': { $eq: '*' } }, {
+                $set: { useMongo4orderNumberFrom }
+            }, { projection: { _id: 0, useMongo4orderNumberFrom: 1 } })
+                .lean()
+                .exec();
+        });
+    }
     useMongoBySettings(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const setting = yield this.settingModel.findOne({ 'project.id': { $eq: '*' } }, {

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

@@ -25,7 +25,7 @@ type IStartParams = (factory.transaction.placeOrder.IStartParamsWithoutDetail |
  * 取引許可証リポジトリ
  */
 export declare class PassportRepo {
-    private readonly redisClient;
+    private readonly concurrentLockRepo;
     private readonly options;
     constructor(redisClient: RedisClientType, options: IOptions);
     static CREATE_VERIFIED_PASSPORT(params: string | jwt.JwtPayload | undefined): IVerifiedPassport;

package/lib/chevre/repo/passport.js

@@ -14,13 +14,15 @@ const createDebug = require("debug");
 const jwt = require("jsonwebtoken");
 const moment = require("moment");
 const factory = require("../factory");
+const concurrentLock_1 = require("./concurrentLock");
 const debug = createDebug('chevre-domain:repo:passport');
 /**
  * 取引許可証リポジトリ
  */
 class PassportRepo {
     constructor(redisClient, options) {
-        this.redisClient = redisClient;
+        this.concurrentLockRepo = new concurrentLock_1.ConcurrentLockRepo({ redisClient });
+        // this.redisClient = redisClient;
         this.options = options;
     }
     static CREATE_VERIFIED_PASSPORT(params) {
@@ -63,21 +65,37 @@ class PassportRepo {
             const now = moment();
             const passportExpires = moment.unix(params.exp);
             const key = PassportRepo.CREATE_REDIS_KEY(params);
-            const ttl = (passportExpires.isAfter(now))
-                ? moment.unix(params.exp)
-                    .diff(moment(), 'seconds')
-                : 1;
-            const results = yield this.redisClient.multi()
-                .setNX(key, '1')
-                .expire(key, ttl)
-                .exec();
-            debug('locked,', params.issueUnit.identifier, now, passportExpires, ttl, results);
-            if (Array.isArray(results) && (results[0] === 1 || results[0] === true)) {
-                return;
+            const expires = (passportExpires.isAfter(now))
+                ? passportExpires.toDate()
+                : now.add(1, 'second')
+                    .toDate();
+            // reimplement using concurrentLockRepo(2025-05-27~)
+            try {
+                yield this.concurrentLockRepo.lock({
+                    project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                    about: { identifier: key, typeOf: 'Thing' },
+                    expires,
+                    audience: { identifier: '1', typeOf: 'Audience' }
+                });
+                debug('locked,', params.issueUnit.identifier, passportExpires);
             }
-            else {
+            catch (error) {
                 throw new factory.errors.AlreadyInUse('passport', [], 'passport already in use');
             }
+            // const ttl = (passportExpires.isAfter(now))
+            //     ? moment.unix(params.exp)
+            //         .diff(moment(), 'seconds')
+            //     : 1;
+            // const results = await this.redisClient.multi()
+            //     .setNX(key, '1')
+            //     .expire(key, ttl)
+            //     .exec();
+            // debug('locked,', params.issueUnit.identifier, now, passportExpires, ttl, results);
+            // if (Array.isArray(results) && (results[0] === 1 || (<any>results)[0] === true)) {
+            //     return;
+            // } else {
+            //     throw new factory.errors.AlreadyInUse('passport', [], 'passport already in use');
+            // }
         });
     }
     /**

package/lib/chevre/repo/rateLimit/offer.d.ts

@@ -4,6 +4,9 @@ import * as factory from '../../factory';
  * レート制限キーインターフェース
  */
 export interface IRateLimitKey {
+    project: {
+        id: string;
+    };
     reservedTicket: {
         ticketType: {
             validRateLimit: factory.offer.IValidRateLimit;
@@ -19,13 +22,15 @@ export interface IRateLimitKey {
  */
 export declare class OfferRateLimitRepo {
     private static readonly KEY_PREFIX_NEW;
+    private readonly concurrentLockRepo;
     private readonly redisClient;
     constructor(redisClient: RedisClientType);
     private static createKey;
     /**
      * ロックする
+     * discontinue array params(2025-05-26~)
      */
-    lock(ratelimitKeys: IRateLimitKey[]): Promise<void>;
-    unlock(ratelimitKeys: IRateLimitKey[]): Promise<void>;
+    lock(params: IRateLimitKey): Promise<void>;
+    unlock(params: IRateLimitKey): Promise<void>;
     getHolder(ratelimitKey: IRateLimitKey): Promise<string | null>;
 }

package/lib/chevre/repo/rateLimit/offer.js

@@ -12,11 +12,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OfferRateLimitRepo = void 0;
 const moment = require("moment");
 const factory = require("../../factory");
+const concurrentLock_1 = require("../concurrentLock");
 /**
  * オファーレート制限リポジトリ
  */
 class OfferRateLimitRepo {
     constructor(redisClient) {
+        this.concurrentLockRepo = new concurrentLock_1.ConcurrentLockRepo({ redisClient });
         this.redisClient = redisClient;
     }
     static createKey(ratelimitKey) {
@@ -28,54 +30,53 @@ class OfferRateLimitRepo {
     }
     /**
      * ロックする
+     * discontinue array params(2025-05-26~)
      */
-    lock(ratelimitKeys) {
+    // public async lock(ratelimitKeys: IRateLimitKey[]): Promise<void> {
+    lock(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const datasets = ratelimitKeys.map((ratelimitKey) => {
-                return {
-                    key: OfferRateLimitRepo.createKey(ratelimitKey),
-                    value: ratelimitKey.reservationNumber,
-                    ttl: moment(ratelimitKey.reservationFor.startDate)
-                        .add(ratelimitKey.reservedTicket.ticketType.validRateLimit.unitInSeconds, 'seconds')
-                        .diff(moment(), 'seconds')
-                };
-            });
-            let multi = this.redisClient.multi();
-            datasets.forEach((dataset) => {
-                multi.setNX(dataset.key, dataset.value)
-                    .expire(dataset.key, dataset.ttl);
-            });
-            const results = yield multi.exec();
-            const lockedFields = [];
-            results.forEach((r, index) => {
-                // tslint:disable-next-line:no-magic-numbers
-                if (index % 2 === 0 && (r === 1 || r === true)) {
-                    // tslint:disable-next-line:no-magic-numbers
-                    lockedFields.push(datasets[index / 2].key);
-                }
-            });
-            const lockedAll = lockedFields.length === ratelimitKeys.length;
-            if (!lockedAll) {
-                if (lockedFields.length > 0) {
-                    // 全てロックできなければロックできたものは解除
-                    multi = this.redisClient.multi();
-                    lockedFields.forEach((key) => {
-                        multi.del(key);
-                    });
-                    yield multi.exec();
-                }
+            const key = OfferRateLimitRepo.createKey(params);
+            const value = params.reservationNumber;
+            const ttl = moment(params.reservationFor.startDate)
+                .add(params.reservedTicket.ticketType.validRateLimit.unitInSeconds, 'seconds')
+                .diff(moment(), 'seconds');
+            const expires = moment()
+                .add(ttl, 'seconds')
+                .toDate();
+            // reimplement using concurrentLockRepo(2025-05-27~)
+            try {
+                yield this.concurrentLockRepo.lock({
+                    project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                    about: { identifier: key, typeOf: 'Thing' },
+                    expires,
+                    audience: { identifier: value, typeOf: 'Audience' }
+                });
+            }
+            catch (error) {
                 throw new factory.errors.RateLimitExceeded('Offer');
             }
+            // const multi = this.redisClient.multi();
+            // multi.setNX(key, value)
+            //     .expire(key, ttl);
+            // const results = await multi.exec();
+            // if (Array.isArray(results) && (results[0] === 1 || (<any>results)[0] === true)) {
+            //     return;
+            // } else {
+            //     throw new factory.errors.RateLimitExceeded('Offer');
+            // }
         });
     }
-    unlock(ratelimitKeys) {
+    // discontinue array params(2025-05-26~)
+    // public async unlock(ratelimitKeys: IRateLimitKey[]): Promise<void> {
+    unlock(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const multi = this.redisClient.multi();
-            ratelimitKeys.forEach((ratelimitKey) => {
-                const key = OfferRateLimitRepo.createKey(ratelimitKey);
-                multi.del(key);
+            const key = OfferRateLimitRepo.createKey(params);
+            // reimplement using concurrentLockRepo(2025-05-27~)
+            yield this.concurrentLockRepo.unlock({
+                about: { identifier: key, typeOf: 'Thing' },
+                audience: { identifier: params.reservationNumber, typeOf: 'Audience' }
             });
-            yield multi.exec();
+            // await this.redisClient.del(key);
         });
     }
     getHolder(ratelimitKey) {

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 {};

package/lib/chevre/repo/transactionProcess.js

@@ -11,44 +11,65 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionProcessRepo = void 0;
 const createDebug = require("debug");
+const moment = require("moment");
 const factory = require("../factory");
+const concurrentLock_1 = require("./concurrentLock");
 const debug = createDebug('chevre-domain:repo:transactionProcess');
 const DEFAULT_LOCK_EXPIRES = 120;
 /**
  * 取引プロセスリポジトリ
  */
 class TransactionProcessRepo {
+    // private readonly redisClient: RedisClientType;
     constructor(redisClient, options) {
-        this.redisClient = redisClient;
+        this.concurrentLockRepo = new concurrentLock_1.ConcurrentLockRepo({ redisClient });
+        // this.redisClient = redisClient;
         this.options = options;
     }
     static CREATE_REDIS_KEY(params) {
-        // 最適化(2024-03-21~)
-        // return `chevre-api:${params.project.id}:transactionProcess:${params.typeOf}:${params.id}`;
         return `chvrapi:lockTxn:${params.id}`;
     }
     lock(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const key = TransactionProcessRepo.CREATE_REDIS_KEY(params);
-            // const ttl = TRANSACTION_RROCESS_LOCK_EXPIRES;
             const ttl = (typeof this.options.lockExpiresInSeconds === 'number') ? this.options.lockExpiresInSeconds : DEFAULT_LOCK_EXPIRES;
-            const results = yield this.redisClient.multi()
-                .setNX(key, '1')
-                .expire(key, ttl)
-                .exec();
-            debug('locked,', params.id, results);
-            if (Array.isArray(results) && (results[0] === 1 || results[0] === true)) {
-                return true;
+            const expires = moment()
+                .add(ttl, 'seconds')
+                .toDate();
+            // reimplement using concurrentLockRepo(2025-05-27~)
+            try {
+                yield this.concurrentLockRepo.lock({
+                    project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                    about: { identifier: key, typeOf: 'Thing' },
+                    expires,
+                    audience: { identifier: '1', typeOf: 'Audience' }
+                });
+                debug('locked,', params.id);
             }
-            else {
+            catch (error) {
                 throw new factory.errors.AlreadyInUse(params.typeOf, [], 'Another transaction process in progress');
             }
+            // const results = await this.redisClient.multi()
+            //     .setNX(key, '1')
+            //     .expire(key, ttl)
+            //     .exec();
+            // debug('locked,', params.id, results);
+            // if (Array.isArray(results) && (results[0] === 1 || (<any>results)[0] === true)) {
+            //     return;
+            // } else {
+            //     throw new factory.errors.AlreadyInUse(params.typeOf, [], 'Another transaction process in progress');
+            // }
         });
     }
     unlock(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const key = TransactionProcessRepo.CREATE_REDIS_KEY(params);
-            yield this.redisClient.del([key]);
+            // reimplement using concurrentLockRepo(2025-05-27~)
+            yield this.concurrentLockRepo.unlock({
+                about: { identifier: key, typeOf: 'Thing' },
+                audience: { identifier: '1', typeOf: 'Audience' }
+            });
+            // await this.redisClient.del([key]);
         });
     }
 }

package/lib/chevre/service/aggregation/event/aggregateOffers.js

@@ -239,6 +239,7 @@ function isHoldByRateLimit(params) {
         const unitInSeconds = (_b = params.offer.validRateLimit) === null || _b === void 0 ? void 0 : _b.unitInSeconds;
         if (typeof scope === 'string' && typeof unitInSeconds === 'number') {
             const rateLimitKey = {
+                project: { id: params.event.project.id },
                 reservedTicket: {
                     ticketType: {
                         validRateLimit: { scope: scope, unitInSeconds: unitInSeconds }

package/lib/chevre/service/assetTransaction/reserve/start.js

@@ -170,6 +170,7 @@ function addReservations(params) {
         let lockedOfferRateLimitKeys = [];
         try {
             lockedOfferRateLimitKeys = yield processLockOfferRateLimit({
+                project: { id: params.event.project.id },
                 reservations: objectSubReservations,
                 reservationFor,
                 reservationNumber
@@ -179,6 +180,7 @@ function addReservations(params) {
             if (lockedOfferRateLimitKeys.length > 0) {
                 yield Promise.all(objectSubReservations.map((reservation) => __awaiter(this, void 0, void 0, function* () {
                     yield (0, cancelReservation_1.processUnlockOfferRateLimit)({
+                        project: { id: params.event.project.id },
                         reservation: {
                             reservationNumber,
                             reservedTicket: reservation.reservedTicket
@@ -469,6 +471,7 @@ function processLockOfferRateLimit(params) {
             const unitInSeconds = (_b = reservation.reservedTicket.ticketType.validRateLimit) === null || _b === void 0 ? void 0 : _b.unitInSeconds;
             if (typeof scope === 'string' && typeof unitInSeconds === 'number') {
                 const rateLimitKey = {
+                    project: { id: params.project.id },
                     reservedTicket: {
                         ticketType: {
                             validRateLimit: {
@@ -489,7 +492,12 @@ function processLockOfferRateLimit(params) {
                 rateLimitKeys.push(rateLimitKey);
             }
         });
-        yield repos.offerRateLimit.lock(rateLimitKeys);
+        if (rateLimitKeys.length > 0) {
+            if (rateLimitKeys.length > 1) {
+                throw new factory.errors.Argument('acceptedOffers', `Number of offers with rateLimit must be less than or equal to 1`);
+            }
+            yield repos.offerRateLimit.lock(rateLimitKeys[0]);
+        }
         return rateLimitKeys;
     });
 }

package/lib/chevre/service/offer/event/checkAvailability.d.ts

@@ -2,7 +2,7 @@ import type { IMinimizedIndividualEvent } from '../../../repo/event';
 import type { OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
 import * as factory from '../../../factory';
 declare function checkAvailability(params: {
-    event: Pick<IMinimizedIndividualEvent<factory.eventType.Event | factory.eventType.ScreeningEvent>, 'startDate'>;
+    event: Pick<IMinimizedIndividualEvent<factory.eventType.Event | factory.eventType.ScreeningEvent>, 'startDate' | 'project'>;
     unitPriceOffer: factory.unitPriceOffer.IUnitPriceOffer;
 }): (repos: {
     offerRateLimit: OfferRateLimitRepo;

package/lib/chevre/service/offer/event/checkAvailability.js

@@ -22,6 +22,7 @@ function checkAvailability(params) {
         const unitInSeconds = (_b = unitPriceOffer.validRateLimit) === null || _b === void 0 ? void 0 : _b.unitInSeconds;
         if (typeof scope === 'string' && typeof unitInSeconds === 'number') {
             const rateLimitKey = {
+                project: { id: params.event.project.id },
                 reservedTicket: {
                     ticketType: {
                         validRateLimit: {

package/lib/chevre/service/reserve/cancelReservation.d.ts

@@ -31,6 +31,9 @@ declare function cancelReservation(actionAttributesList: factory.action.cancel.r
     assetTransaction: AssetTransactionRepo;
 }) => Promise<void>;
 declare function processUnlockOfferRateLimit(params: {
+    project: {
+        id: string;
+    };
     reservation: {
         reservationNumber: string;
         reservedTicket: factory.reservation.ITicket;

package/lib/chevre/service/reserve/cancelReservation.js

@@ -104,6 +104,7 @@ function cancelPengindIfNotYet(params) {
                                             : reserveTransactionId
                                     })(repos);
                                     yield processUnlockOfferRateLimit({
+                                        project: { id: reserveTransaction.project.id },
                                         reservation: {
                                             reservationNumber: reserveTransaction.object.reservationNumber,
                                             reservedTicket: cancelingSubReservation.reservedTicket
@@ -204,6 +205,7 @@ function cancelReservation(actionAttributesList) {
                                         : reserveTransaction.id
                                 })(repos);
                                 yield processUnlockOfferRateLimit({
+                                    project: { id: reserveTransaction.project.id },
                                     reservation: {
                                         reservationNumber: reserveTransaction.object.reservationNumber,
                                         reservedTicket: cancelingSubReservation.reservedTicket
@@ -253,6 +255,7 @@ function cancelReservation(actionAttributesList) {
                             })(repos);
                         }
                         yield processUnlockOfferRateLimit({
+                            project: { id: reservation.project.id },
                             reservation: {
                                 reservationNumber: reservation.reservationNumber,
                                 reservedTicket: reservation.reservedTicket
@@ -401,6 +404,7 @@ function processUnlockOfferRateLimit(params) {
         const unitInSeconds = (_b = reservation.reservedTicket.ticketType.validRateLimit) === null || _b === void 0 ? void 0 : _b.unitInSeconds;
         if (typeof scope === 'string' && typeof unitInSeconds === 'number') {
             const rateLimitKey = {
+                project: { id: params.project.id },
                 reservedTicket: {
                     ticketType: {
                         validRateLimit: {
@@ -420,7 +424,7 @@ function processUnlockOfferRateLimit(params) {
             };
             const holder = yield repos.offerRateLimit.getHolder(rateLimitKey);
             if (holder === rateLimitKey.reservationNumber) {
-                yield repos.offerRateLimit.unlock([rateLimitKey]);
+                yield repos.offerRateLimit.unlock(rateLimitKey);
             }
         }
     });

package/package.json

@@ -113,5 +113,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "22.10.0-alpha.20"
+  "version": "22.10.0-alpha.22"
 }