@chevre/domain 22.10.0-alpha.9 → 22.10.0

package/lib/chevre/repo/orderNumber.js

@@ -12,45 +12,66 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderNumberRepo = 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");
 const ORDER_NUMBER_SEPARATOR = '-';
 /**
  * 注文番号リポジトリ
  */
 class OrderNumberRepo {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    static createKey(params) {
-        return util.format('%s:%s:%s', OrderNumberRepo.REDIS_KEY_PREFIX, params.projectPrefix, 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: {
+    //     orderDate: Date;
+    //     projectPrefix: string;
+    //     timestamp: string;
+    // }): string {
+    //     return util.format(
+    //         '%s:%s:%s',
+    //         OrderNumberRepo.REDIS_KEY_PREFIX,
+    //         params.projectPrefix,
+    //         params.timestamp
+    //     );
+    // }
     /**
      * タイムスタンプから発行する
      */
     publishByTimestamp(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const projectPrefix = params.project.alternateName
-                .toUpperCase();
             const timestamp = moment(params.orderDate)
                 .valueOf()
                 .toString();
-            const now = moment();
-            const TTL = moment(params.orderDate)
-                .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
-                .diff(now, 'seconds');
-            const key = OrderNumberRepo.createKey({ orderDate: params.orderDate, projectPrefix, timestamp });
-            const [incrReply] = yield this.redisClient.multi()
-                .incr(key)
-                .expire(key, TTL)
-                .exec();
-            // tslint:disable-next-line:no-single-line-block-comment
-            /* istanbul ignore if */
-            if (typeof incrReply !== 'number') {
-                // 基本的にありえないフロー
-                throw new factory.errors.Internal('order number not incremented unexpectedly');
+            const projectPrefix = params.project.alternateName
+                .toUpperCase();
+            let dataFeedExpires;
+            const dataFeedIdentifier = `${projectPrefix}:${timestamp}`;
+            let incrReply;
+            const useMongoBySettings = yield this.useMongoBySettings(params);
+            if (useMongoBySettings) {
+                dataFeedExpires = moment(params.orderDate)
+                    .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByMongo({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.orderNumber },
+                    expires: dataFeedExpires
+                });
+            }
+            else {
+                dataFeedExpires = moment(params.orderDate)
+                    .add(1, 'minute') // ミリ秒でカウントしていくので、注文日時後1分で十分
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByRedis({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.orderNumber },
+                    expires: dataFeedExpires
+                });
             }
             let orderNumber = `${timestamp}${incrReply}`;
             // checkdigit
@@ -69,6 +90,32 @@ 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: '*' } }, {
+                _id: 0,
+                useMongo4orderNumberFrom: 1
+            })
+                .lean()
+                .exec();
+            const useMongo4orderNumberFrom = setting === null || setting === void 0 ? void 0 : setting.useMongo4orderNumberFrom;
+            return useMongo4orderNumberFrom instanceof Date
+                && moment(params.orderDate)
+                    .isSameOrAfter(moment(useMongo4orderNumberFrom));
+        });
+    }
 }
 exports.OrderNumberRepo = OrderNumberRepo;
-OrderNumberRepo.REDIS_KEY_PREFIX = 'orderNumber';

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/role.d.ts

@@ -1,14 +1,16 @@
-import type { Connection } from 'mongoose';
+import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
-import { IRole } from './mongoose/schemas/role';
+import { IDocType } from './mongoose/schemas/role';
+type IRole = IDocType;
+type IKeyOfProjection = keyof IDocType;
 /**
  * IAMロールリポジトリ
  */
 export declare class RoleRepo {
     private readonly roleModel;
     constructor(connection: Connection);
-    static CREATE_MONGO_CONDITIONS(params: factory.iam.IRoleSearchConditions): any[];
-    projectFields(params: factory.iam.IRoleSearchConditions): Promise<IRole[]>;
+    static CREATE_MONGO_CONDITIONS(params: factory.role.organizationRole.ISearchConditions): FilterQuery<IDocType>[];
+    projectFields(params: factory.role.organizationRole.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IRole[]>;
     aggregatePermissions(params: {
         roleName: {
             $in: string[];
@@ -16,4 +18,16 @@ export declare class RoleRepo {
     }): Promise<{
         _id: string;
     }[]>;
+    addPermissionIfNotExists(params: {
+        roleName: {
+            $eq: factory.role.organizationRole.RoleName;
+        };
+        permission: string;
+    }): Promise<(import("mongoose").FlattenMaps<IDocType> & {
+        _id: import("mongoose").Types.ObjectId;
+    }) | null>;
+    addMember(params: Pick<IRole, 'member' | 'memberOf' | 'roleName'>): Promise<(import("mongoose").FlattenMaps<IDocType> & {
+        _id: import("mongoose").Types.ObjectId;
+    }) | null>;
 }
+export {};

package/lib/chevre/repo/role.js

@@ -15,7 +15,9 @@ const role_1 = require("./mongoose/schemas/role");
 const AVAILABLE_PROJECT_FIELDS = [
     'typeOf',
     'permissions',
-    'roleName'
+    'roleName',
+    'member',
+    'memberOf'
 ];
 /**
  * IAMロールリポジトリ
@@ -25,7 +27,7 @@ class RoleRepo {
         this.roleModel = connection.model(role_1.modelName, (0, role_1.createSchema)());
     }
     static CREATE_MONGO_CONDITIONS(params) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         const andConditions = [];
         if (typeof ((_a = params.roleName) === null || _a === void 0 ? void 0 : _a.$eq) === 'string') {
             andConditions.push({ roleName: { $eq: params.roleName.$eq } });
@@ -38,12 +40,23 @@ class RoleRepo {
         if (typeof permissionsEq === 'string') {
             andConditions.push({ permissions: { $exists: true, $eq: permissionsEq } });
         }
+        const memberTypeOfEq = (_e = (_d = params.member) === null || _d === void 0 ? void 0 : _d.typeOf) === null || _e === void 0 ? void 0 : _e.$eq;
+        if (typeof memberTypeOfEq === 'string') {
+            andConditions.push({ 'member.typeOf': { $eq: memberTypeOfEq } });
+        }
+        const memberOfTypeOfEq = (_g = (_f = params.memberOf) === null || _f === void 0 ? void 0 : _f.typeOf) === null || _g === void 0 ? void 0 : _g.$eq;
+        if (typeof memberOfTypeOfEq === 'string') {
+            andConditions.push({ 'memberOf.typeOf': { $eq: memberOfTypeOfEq } });
+        }
         return andConditions;
     }
-    projectFields(params) {
+    projectFields(params, inclusion) {
         return __awaiter(this, void 0, void 0, function* () {
             const conditions = RoleRepo.CREATE_MONGO_CONDITIONS(params);
-            const positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+            let positiveProjectionFields = AVAILABLE_PROJECT_FIELDS;
+            if (Array.isArray(inclusion) && inclusion.length > 0) {
+                positiveProjectionFields = inclusion.filter((key) => AVAILABLE_PROJECT_FIELDS.includes(key));
+            }
             const projection = Object.assign({ _id: 0 }, Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1]))));
             const query = this.roleModel.find((conditions.length > 0) ? { $and: conditions } : {}, projection);
             if (typeof params.limit === 'number' && params.limit > 0) {
@@ -99,5 +112,41 @@ class RoleRepo {
                 .exec();
         });
     }
+    addPermissionIfNotExists(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.roleModel.findOneAndUpdate({
+                roleName: { $eq: params.roleName.$eq },
+                permissions: { $ne: params.permission }
+            }, {
+                $push: {
+                    permissions: {
+                        $each: [params.permission],
+                        $sort: 1
+                    }
+                }
+            }, {
+                new: true,
+                projection: { _id: 1 }
+            })
+                .lean()
+                .exec();
+        });
+    }
+    addMember(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { roleName, member, memberOf } = params;
+            return this.roleModel.findOneAndUpdate({
+                roleName: { $eq: roleName },
+                'member.typeOf': { $ne: member.typeOf }
+            }, {
+                $set: { member, memberOf }
+            }, {
+                new: true,
+                projection: { _id: 1 }
+            })
+                .lean()
+                .exec();
+        });
+    }
 }
 exports.RoleRepo = RoleRepo;

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

@@ -1,16 +1,20 @@
+import type { Connection } from 'mongoose';
 import { RedisClientType } from 'redis';
 /**
  * サービスアウトプット識別子リポジトリ
  */
 export declare class ServiceOutputIdentifierRepo {
-    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<string>;
+    private useMongoBySettings;
 }

package/lib/chevre/repo/serviceOutputIdentifier.js

@@ -12,20 +12,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceOutputIdentifierRepo = 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 ServiceOutputIdentifierRepo {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    static createKey(params) {
-        return util.format('%s:%s', ServiceOutputIdentifierRepo.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',
+    //         ServiceOutputIdentifierRepo.REDIS_KEY_PREFIX,
+    //         params.timestamp
+    //     );
+    // }
     /**
      * タイムスタンプから発行する
      */
@@ -34,20 +44,29 @@ class ServiceOutputIdentifierRepo {
             const timestamp = moment(params.startDate)
                 .valueOf()
                 .toString();
-            const now = moment();
-            const TTL = moment(params.startDate)
-                .add(1, 'minute') // ミリ秒でカウントしていくので、予約日時後1分で十分
-                .diff(now, 'seconds');
-            const key = ServiceOutputIdentifierRepo.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('serviceOutput identifier 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.serviceOutputIdentifier },
+                    expires: dataFeedExpires
+                });
+            }
+            else {
+                dataFeedExpires = moment(params.startDate)
+                    .add(1, 'minute') // ミリ秒でカウントしていくので、予約日時後1分で十分
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByRedis({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.serviceOutputIdentifier },
+                    expires: dataFeedExpires
+                });
             }
             let identifier = `${timestamp}${incrReply}`;
             // checkdigit
@@ -58,6 +77,19 @@ class ServiceOutputIdentifierRepo {
             return identifier;
         });
     }
+    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.ServiceOutputIdentifierRepo = ServiceOutputIdentifierRepo;
-ServiceOutputIdentifierRepo.REDIS_KEY_PREFIX = 'serviceOutputIdentifier';

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

@@ -8,7 +8,6 @@ export { ILockKey, IOffer, IUnlockKey };
 export declare class StockHolderRepo implements AbstractStockHolderRepo {
     static KEY_PREFIX_NEW: string;
     private readonly redisClient;
-    private readonly settingModel;
     private readonly pendingReservationRepo;
     constructor(redisClient: RedisClientType, connection: Connection);
     private static offer2field;
@@ -75,5 +74,4 @@ export declare class StockHolderRepo implements AbstractStockHolderRepo {
      * 新リポジトリを使用するかどうか
      */
     private useMongoose;
-    private useMongoAsStockHolderBySettings;
 }