@chevre/domain 22.11.0-alpha.31 → 22.11.0-alpha.33

package/example/src/chevre/checkCustomerAttributesLength.ts

@@ -0,0 +1,109 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const MAX_LENGTH = 50;
+const CHECK_DAYS = 60;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.order.OrderType.Order },
+            orderDate: {
+                $gte: moment()
+                    .add(-CHECK_DAYS, 'days')
+                    .toDate()
+            }
+            // _id: { $eq: '67de46777ec0510590b68922' }
+        },
+        {
+            customer: 1,
+            project: 1,
+            orderDate: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let exceededCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: Pick<
+            chevre.factory.order.IOrder,
+            'customer' | 'project' | 'orderDate'
+        > = doc.toObject();
+
+        const attributesNames: (keyof chevre.factory.order.ICustomer)[] = [
+            'address',
+            'age',
+            'email',
+            'givenName',
+            'familyName',
+            'gender',
+            'name',
+            'url',
+            'telephone'
+        ];
+
+        const maxLengthNotExceeded = attributesNames.every((attributesName) => {
+            const attributesValue = order.customer[attributesName];
+            if (attributesValue === undefined) {
+                return true;
+            }
+            if (typeof attributesValue !== 'string') {
+                throw new Error(`${attributesName}: ${attributesValue} must be string. ${order.project.id}`);
+            }
+
+            return attributesValue.length <= MAX_LENGTH;
+        });
+
+        if (maxLengthNotExceeded) {
+            // no op
+            process.stdout.write('-');
+        } else {
+            exceededCount += 1;
+            console.log('\n');
+            console.log('maxLengthExceeded.', order.project.id, order.customer, order.orderDate, i);
+        }
+    });
+
+    console.log('\n');
+    console.log(i, 'docs checked');
+    console.log(exceededCount, 'docs exceeded');
+
+    // let result: any;
+    // const attributesNames = [
+    //     // 'customer.address',
+    //     // 'customer.age',
+    //     'customer.email',
+    //     'customer.givenName',
+    //     'customer.familyName'
+    //     // 'customer.gender',
+    //     // 'customer.name',
+    //     // 'customer.url',
+    // ];
+    // for (const attributesName of attributesNames) {
+    //     console.log('how is', attributesName, '?');
+    //     result = await orderRepo.checkCustomerAttributesLength({
+    //         attributesName,
+    //         length: MAX_LENGTH
+    //     });
+    //     // tslint:disable-next-line:no-null-keyword
+    //     console.dir(result, { depth: null });
+    //     console.log('how is', attributesName, '?', result.length, 'results found');
+    // }
+}
+
+main()
+    .then(() => {
+        console.log('\n');
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/searchEventSeats.ts

@@ -17,7 +17,7 @@ async function main() {
     });
     await client.connect();
 
-    const itemAvailabilityRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
+    const itemAvailabilityRepo = await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection });
 
     const result = await itemAvailabilityRepo.searchHolders({
         project,

package/example/src/chevre/stockHolder/checkRedisKeyCount.ts

@@ -93,10 +93,10 @@ async function main() {
     const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
     const projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
     // const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
-        client,
-        mongoose.connection
-    );
+    const stockHolderRepo = await chevre.repository.StockHolder.createInstance({
+        redisClient: client,
+        connection: mongoose.connection
+    });
 
     let checkingProjects: string[] = [];
     // 全プロジェクト

package/example/src/chevre/{deleteRunsAtPassedCertainPeriod.ts → task/deleteRunsAtPassedCertainPeriod.ts}

@@ -2,9 +2,10 @@
 import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
-import { chevre } from '../../../lib/index';
+import { chevre } from '../../../../lib/index';
 
-const TASK_STORAGE_PERIOD_IN_MINUTES = 43200; // 30*24*60
+// const TASK_STORAGE_PERIOD_IN_MINUTES = 43200; // 30*24*60
+const TASK_STORAGE_PERIOD_IN_MINUTES = 28800; // 20*24*60
 
 async function main() {
     const now = new Date();
@@ -12,7 +13,7 @@ async function main() {
 
     const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
 
-    let taskInMinutes = 57600; // 40*24*60
+    let taskInMinutes = 44640; // 31*24*60
     // let taskInMinutes = 172800; // 120*24*60
     // tslint:disable-next-line:no-magic-numbers
     while (taskInMinutes > TASK_STORAGE_PERIOD_IN_MINUTES) {

package/example/src/chevre/task/deleteUnexpectedTasks.ts

@@ -0,0 +1,23 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+    const result = await taskRepo.taskModel.deleteMany({
+        $or: [
+            { name: { $exists: false } },
+            { status: { $exists: false } }
+        ]
+    })
+        .exec();
+
+    console.log('success!', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/lib/chevre/repo/pendingReservation.js

@@ -587,6 +587,7 @@ class PendingReservationRepo {
                         throw new factory.errors.AlreadyInUse(factory.reservationType.EventReservation, ['ticketedSeat'], 'Already hold');
                     }
                 }
+                throw error;
             }
         });
     }

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

@@ -9,7 +9,10 @@ export declare class StockHolderRepo implements AbstractStockHolderRepo {
     static KEY_PREFIX_NEW: string;
     private readonly redisClient;
     private readonly pendingReservationRepo;
-    constructor(redisClient: RedisClientType, connection: Connection);
+    constructor(params: {
+        redisClient?: RedisClientType;
+        connection: Connection;
+    });
     private static offer2field;
     private static createKey;
     /**
@@ -54,10 +57,6 @@ export declare class StockHolderRepo implements AbstractStockHolderRepo {
         eventId: string;
         startDate: Date;
     }): Promise<boolean>;
-    checkIfConflicted(params: {
-        eventId: string;
-        startDate: Date;
-    }): Promise<void>;
     /**
      * 万が一に備えて、保留予約をredis->mongo移行
      */

package/lib/chevre/repo/stockHolder.js

@@ -13,18 +13,16 @@ exports.StockHolderRepo = void 0;
 const createDebug = require("debug");
 const moment = require("moment");
 const factory = require("../factory");
-// 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;
-const USE_STOCK_HOLDER_CHECK_CONFLICT = process.env.USE_STOCK_HOLDER_CHECK_CONFLICT === '1';
 /**
  * イベントストックホルダーリポジトリ
  */
 class StockHolderRepo {
-    constructor(redisClient, connection) {
+    constructor(params) {
+        const { redisClient, connection } = params;
         this.redisClient = redisClient;
-        // this.settingModel = connection.model(modelName, createSchema());
         this.pendingReservationRepo = new pendingReservation_1.PendingReservationRepo(connection);
     }
     static offer2field(params, hasTicketedSeat) {
@@ -61,15 +59,15 @@ class StockHolderRepo {
                 hasTicketedSeat: lockKey.hasTicketedSeat
             });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.lockIfNotLimitExceeded(lockKey, maximum);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
                 yield this.redisClient.watch(key);
                 const hashCount = yield this.redisClient.hLen(key);
-                // Process result
-                // Heavy and time consuming operation here
                 debug('checking hash count...hashCount:', hashCount);
                 if (hashCount + lockKey.offers.length > maximum) {
                     throw new factory.errors.Argument('Event', 'maximumAttendeeCapacity exceeded');
@@ -96,10 +94,12 @@ class StockHolderRepo {
             const key = StockHolderRepo.createKey({ eventId: lockKey.eventId, startDate: lockKey.startDate });
             // await this.checkIfConflicted({ key, eventId: lockKey.eventId, useMongoose });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.lock(lockKey);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const value = lockKey.holder;
                 const multi = this.redisClient.multi();
                 const fields = lockKey.offers.map((offer) => StockHolderRepo.offer2field(offer, lockKey.hasTicketedSeat));
@@ -160,10 +160,12 @@ class StockHolderRepo {
             const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
             // await this.checkIfConflicted({ key, eventId: params.eventId, useMongoose });
             if (useMongoose) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.unlock(params);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
                 yield this.redisClient.multi()
                     .hDel(key, field)
@@ -182,10 +184,12 @@ class StockHolderRepo {
                 startDate: params.event.startDate,
                 hasTicketedSeat: params.event.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.countUnavailableOffers(params);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const key = StockHolderRepo.createKey({ eventId: params.event.id, startDate: params.event.startDate });
                 const reply = yield this.redisClient.hLen(key);
                 let fieldCount = 0;
@@ -207,10 +211,12 @@ class StockHolderRepo {
                 startDate: params.startDate,
                 hasTicketedSeat: params.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.getHolder(params);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
                 const field = StockHolderRepo.offer2field(params.offer, params.hasTicketedSeat);
                 return this.redisClient.hGet(key, field);
@@ -229,10 +235,12 @@ class StockHolderRepo {
                 startDate: params.startDate,
                 hasTicketedSeat: params.hasTicketedSeat
             })) {
-                // throw new factory.errors.NotImplemented('new stock holder repository not implemented');
                 return this.pendingReservationRepo.searchHolders(params);
             }
             else {
+                if (this.redisClient === undefined) {
+                    throw new factory.errors.Internal('redisClient required');
+                }
                 const key = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
                 const fields = params.offers.map((o) => {
                     return StockHolderRepo.offer2field(o, params.hasTicketedSeat);
@@ -249,6 +257,9 @@ class StockHolderRepo {
     }
     redisKeyExists(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.redisClient === undefined) {
+                throw new factory.errors.Internal('redisClient required');
+            }
             const key = StockHolderRepo.createKey(params);
             const existingRedisKeyCount = yield this.redisClient.exists(key);
             if (typeof existingRedisKeyCount !== 'number') {
@@ -257,20 +268,24 @@ class StockHolderRepo {
             return existingRedisKeyCount > 0;
         });
     }
-    checkIfConflicted(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisKeyExists = yield this.redisKeyExists(params);
-            const mongoDocExists = yield this.pendingReservationRepo.docExists(params);
-            if (redisKeyExists && mongoDocExists) {
-                throw new factory.errors.Internal(`repository conflicted. eventId:${params.eventId}`);
-            }
-        });
-    }
+    // public async checkIfConflicted(params: {
+    //     eventId: string;
+    //     startDate: Date;
+    // }): Promise<void> {
+    //     const redisKeyExists = await this.redisKeyExists(params);
+    //     const mongoDocExists = await this.pendingReservationRepo.docExists(params);
+    //     if (redisKeyExists && mongoDocExists) {
+    //         throw new factory.errors.Internal(`repository conflicted. eventId:${params.eventId}`);
+    //     }
+    // }
     /**
      * 万が一に備えて、保留予約をredis->mongo移行
      */
     migrate2mongoJustInCase(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.redisClient === undefined) {
+                throw new factory.errors.Internal('redisClient required');
+            }
             const redisKey = StockHolderRepo.createKey({ eventId: params.eventId, startDate: params.startDate });
             return {
                 expireTime: yield this.redisClient.expireTime(redisKey),
@@ -281,26 +296,27 @@ class StockHolderRepo {
     /**
      * 新リポジトリを使用するかどうか
      */
+    // tslint:disable-next-line:prefer-function-over-method
     useMongoose(params) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!(params.startDate instanceof Date)) {
                 throw new factory.errors.Argument('startDate', 'must be Date');
             }
-            let useMongoose = false;
-            // 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) {
-                yield this.checkIfConflicted(params);
-            }
-            return useMongoose;
+            // always use mongo(2025-08-17~)
+            return true;
+            // let useMongoose = false;
+            // const redisKeyExists = await this.redisKeyExists(params);
+            // if (redisKeyExists) {
+            //     useMongoose = false;
+            // } else {
+            //     // redis keyが存在しなければmongo利用
+            //     useMongoose = true;
+            // }
+            // // check confliction for test
+            // if (USE_STOCK_HOLDER_CHECK_CONFLICT) {
+            //     await this.checkIfConflicted(params);
+            // }
+            // return useMongoose;
         });
     }
 }

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

@@ -119,12 +119,15 @@ export declare class TaskRepo {
      * 実行日時を一定期間過ぎたReadyタスクについて、Runningスタータスに変更した上で、Runningイベントを発生させる
      */
     emitRunningIfExists(params: {
-        name?: {
-            $eq?: factory.taskName;
-            $in?: factory.taskName[];
-        };
-        executor: {
-            name: string;
+        /**
+         * 必ずタスク名指定で実行する
+         */
+        name: {
+            $eq: factory.taskName;
+            $in?: never;
+        } | {
+            $eq?: never;
+            $in: factory.taskName[];
         };
         runsAt: {
             $lt: Date;
@@ -133,6 +136,10 @@ export declare class TaskRepo {
             numberOfTried?: factory.sortType;
             runsAt?: factory.sortType;
         };
+        executor: {
+            name: string;
+        };
+        nameFilterBeforeRunsAt: boolean;
     }, next?: INextFunction): Promise<Pick<factory.task.ITask<factory.taskName>, 'id' | 'name'> | null>;
     /**
      * Readyのままで期限切れのタスクをExpiredに変更する

package/lib/chevre/repo/task.js

@@ -460,7 +460,7 @@ class TaskRepo {
     emitRunningIfExists(params, next // support next function(2025-08-02~)
     ) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             if (!(params.runsAt.$lt instanceof Date)) {
                 throw new factory.errors.Argument('runsAt.$lt', 'must be Date');
             }
@@ -471,12 +471,20 @@ class TaskRepo {
             };
             const nameEq = (_a = params.name) === null || _a === void 0 ? void 0 : _a.$eq;
             // const nameNin = params.name?.$nin;
-            const nameIn = (_b = params.name) === null || _b === void 0 ? void 0 : _b.$in;
-            const doc = yield this.taskModel.findOneAndUpdate(Object.assign({ status: { $eq: factory.taskStatus.Ready }, runsAt: { $lt: params.runsAt.$lt } }, (typeof nameEq === 'string' || Array.isArray(nameIn))
-                ? {
-                    name: Object.assign(Object.assign({}, (typeof nameEq === 'string') ? { $eq: nameEq } : undefined), (Array.isArray(nameIn)) ? { $in: nameIn } : undefined)
-                }
-                : undefined), {
+            // const nameIn = params.name?.$in;
+            const { nameFilterBeforeRunsAt } = params;
+            const filter = Object.assign(Object.assign(Object.assign({ status: { $eq: factory.taskStatus.Ready } }, (nameFilterBeforeRunsAt) ? { name: params.name } : undefined), { runsAt: { $lt: params.runsAt.$lt } }), (!nameFilterBeforeRunsAt) ? { name: params.name } : undefined
+            // ...(typeof nameEq === 'string' || Array.isArray(nameIn))
+            //     ? {
+            //         name: {
+            //             ...(typeof nameEq === 'string') ? { $eq: nameEq } : undefined,
+            //             // ...(Array.isArray(nameNin)) ? { $nin: nameNin } : undefined
+            //             ...(Array.isArray(nameIn)) ? { $in: nameIn } : undefined
+            //         }
+            //     }
+            //     : undefined
+            );
+            const doc = yield this.taskModel.findOneAndUpdate(filter, {
                 $set: {
                     status: factory.taskStatus.Running, // 実行中に変更
                     lastTriedAt: new Date(),

package/lib/chevre/service/task/aggregateOffers.js

@@ -32,7 +32,7 @@ function call(data) {
         yield (0, aggregateOffers_1.aggregateOffers)(data)({
             aggregateReservation: new aggregateReservation_1.AggregateReservationRepo(connection),
             event: new event_1.EventRepo(connection),
-            stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection),
+            stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection }),
             offer: new unitPriceInCatalog_1.OfferRepo(connection),
             offerCatalog: new offerCatalog_1.OfferCatalogRepo(connection),
             offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),

package/lib/chevre/service/task/aggregateScreeningEvent.js

@@ -32,7 +32,7 @@ function call(data) {
         }
         yield AggregationService.event.aggregateScreeningEvent(data)({
             event: new event_1.EventRepo(connection),
-            stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection),
+            stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection }),
             offer: new unitPriceInCatalog_1.OfferRepo(connection),
             offerCatalog: new offerCatalog_1.OfferCatalogRepo(connection),
             offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),

package/lib/chevre/service/task/cancelPendingReservation.js

@@ -43,7 +43,7 @@ function call(params) {
             yield (0, cancelReservation_1.cancelPendingReservation)({ purpose: data.purpose })({
                 action: new action_1.ActionRepo(connection),
                 assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
-                stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection),
+                stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection }),
                 offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),
                 reservation: new reservation_1.ReservationRepo(connection),
                 setting: new setting_1.SettingRepo(connection),

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

@@ -34,7 +34,7 @@ function call(data) {
             task: new task_1.TaskRepo(connection),
             assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
             offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),
-            stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection)
+            stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection })
         }
         // settings
         );

package/lib/chevre/service/task/checkResource.js

@@ -59,7 +59,7 @@ function call(data) {
                         project: { id: data.project.id }
                     })({
                         event: new event_1.EventRepo(connection),
-                        stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection)
+                        stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection })
                     });
                     break;
                 default:

package/lib/chevre/service/task/voidReserveTransaction.js

@@ -64,7 +64,7 @@ function call(params) {
             yield (0, voidTransaction_1.voidTransaction)(Object.assign(Object.assign({}, params.data), { project: { id: params.project.id }, sameAs: { id: params.id } }))({
                 action: new action_1.ActionRepo(connection),
                 assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
-                stockHolder: new stockHolder_1.StockHolderRepo(redisClient, connection),
+                stockHolder: new stockHolder_1.StockHolderRepo({ redisClient, connection }),
                 offerRateLimit: new offer_1.OfferRateLimitRepo(redisClient),
                 orderInTransaction: new orderInTransaction_1.OrderInTransactionRepo(connection),
                 reservation: new reservation_1.ReservationRepo(connection),

package/lib/chevre/service/validation/validateEvent.d.ts

@@ -1,11 +1,11 @@
 import type { EventRepo } from '../../repo/event';
 import type { StockHolderRepo } from '../../repo/stockHolder';
-export declare function validateEvent(params: {
+export declare function validateEvent(__: {
     id: string;
     project: {
         id: string;
     };
-}): (repos: {
+}): (__2: {
     event: EventRepo;
     stockHolder: StockHolderRepo;
 }) => Promise<void>;

package/lib/chevre/service/validation/validateEvent.js

@@ -1,4 +1,5 @@
 "use strict";
+// import * as createDebug from 'debug';
 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) {
@@ -10,15 +11,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEvent = validateEvent;
-const createDebug = require("debug");
-const debug = createDebug('chevre-domain:service:validation');
-function validateEvent(params) {
-    return (repos) => __awaiter(this, void 0, void 0, function* () {
-        const event = yield repos.event.projectEventFieldsById({ id: params.id }, ['startDate']);
-        debug('validateEvent: conflicted?', params.project.id, event.id, event.startDate);
-        yield repos.stockHolder.checkIfConflicted({
-            eventId: event.id,
-            startDate: event.startDate
-        });
+// import * as factory from '../../factory';
+// const debug = createDebug('chevre-domain:service:validation');
+function validateEvent(__) {
+    return (__2) => __awaiter(this, void 0, void 0, function* () {
+        // const event: Pick<factory.event.screeningEvent.IEvent, 'id' | 'startDate'> =
+        //     await repos.event.projectEventFieldsById<factory.eventType.ScreeningEvent>(
+        //         { id: params.id },
+        //         ['startDate']
+        //     );
+        // discontinue redis(2025-08-17~)
+        // debug('validateEvent: conflicted?', params.project.id, event.id, event.startDate);
+        // await repos.stockHolder.checkIfConflicted({
+        //     eventId: event.id,
+        //     startDate: event.startDate
+        // });
     });
 }

package/package.json

@@ -115,5 +115,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "22.11.0-alpha.31"
+  "version": "22.11.0-alpha.33"
 }

package/example/src/chevre/stockHolder/checkIfConflicted.ts

@@ -1,76 +0,0 @@
-// 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 excludedProject = { id: String(process.env.EXCLUDED_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();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
-        client,
-        mongoose.connection
-    );
-
-    const cursor = eventRepo.getCursor(
-        {
-            'project.id': { $ne: excludedProject.id },
-            startDate: {
-                $gte: moment()
-                    .add(-1, 'days')
-                    .toDate()
-            },
-            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
-            // _id: { $eq: 'blyk9q24f' }
-        },
-        {
-            _id: 1,
-            // offers: 1,
-            startDate: 1,
-            project: 1,
-            typeOf: 1
-        }
-    );
-    console.log('events found');
-
-    let i = 0;
-    await cursor.eachAsync(async (doc) => {
-        i += 1;
-        const event: Pick<
-            chevre.factory.event.screeningEvent.IEvent,
-            'id' | 'startDate' | 'project' | 'typeOf'
-        > = doc.toObject();
-
-        console.log(
-            'conflicted?', event.project.id, event.typeOf, event.id, event.startDate, i);
-        await stockHolderRepo.checkIfConflicted({
-            eventId: event.id,
-            startDate: event.startDate
-        });
-    });
-
-    console.log(i, 'events checked');
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/stockHolder/migratePendingReservations.ts

@@ -1,96 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-import { ILockKey } from '../../../../lib/chevre/repo/stockHolderAbstract';
-import { chevre } from '../../../../lib/index';
-
-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();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-const EVENT_ID = 'cm8dwc74c';
-
-async function main() {
-    // 万が一に備えて、保留予約をredis->mongo移行するスクリプト
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
-    // const pendingReservationRepo = await chevre.repository.PendingReservation.createInstance(mongoose.connection);
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
-
-    const event = await eventRepo.projectEventFieldsById(
-        { id: EVENT_ID },
-        ['startDate', 'organizer', 'project', 'offers']
-    );
-    const hasTicketedSeat = event.offers.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat?.typeOf === chevre.factory.placeType.Seat;
-    const { expireTime, hash } = await stockHolderRepo.migrate2mongoJustInCase({
-        eventId: EVENT_ID,
-        startDate: event.startDate
-        // project: { id: event.project.id },
-        // provider: { id: event.organizer.id }
-    });
-    console.log(expireTime, hash);
-
-    const lockKeys: ILockKey[] = [];
-    const reservationNumbers: string[] = [...new Set(Object.values(hash))];
-    const expires: Date = moment.unix(expireTime)
-        .toDate();
-    console.log('reservationNumbers:', reservationNumbers);
-    console.log('expires:', expires);
-
-    // 予約番号ごとにlockKeyを作成する
-    for (const reservationNumber of reservationNumbers) {
-        const reserveTransaction = (await assetTransactionRepo.search<chevre.factory.assetTransactionType.Reserve>(
-            {
-                limit: 1,
-                page: 1,
-                transactionNumber: { $eq: reservationNumber },
-                typeOf: chevre.factory.assetTransactionType.Reserve,
-                status: { $in: [chevre.factory.transactionStatusType.Confirmed] }
-            },
-            ['object', 'startDate']
-        )).shift();
-        if (reserveTransaction === undefined) {
-            throw new Error(`reserveTransaction not found ${reservationNumber}`);
-        }
-
-        const fields: string[] = Object.keys(hash)
-            .filter((field) => hash[field] === reservationNumber);
-        const lockKey: ILockKey = {
-            project: { id: event.project.id },
-            provider: { id: event.organizer.id },
-            eventId: EVENT_ID,
-            startDate: event.startDate,
-            hasTicketedSeat,
-            offers: fields.map((field) => {
-                const splitedField = field.split(':');
-
-                return {
-                    seatSection: splitedField[0],
-                    seatNumber: splitedField[1]
-                };
-            }),
-            expires,
-            holder: reservationNumber,
-            bookingTime: reserveTransaction.startDate
-        };
-        console.log('lockKey:', lockKey);
-        lockKeys.push(lockKey);
-        // await pendingReservationRepo.lock(lockKey);
-    }
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/stockHolder/playAroundStockHolder.ts

@@ -1,256 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-import { chevre } from '../../../../lib/index';
-
-const today = moment()
-    .tz('Asia/Tokyo')
-    .format('YYYYMMDD');
-const project = { id: String(process.env.PROJECT_ID) };
-const providerId = 'sampleProviderId';
-const eventId = `sampleEventId${today}:03`;
-const eventStartDate = new Date('2025-05-01T00:00:00Z');
-const expires = moment(eventStartDate)
-    .add(1, 'week')
-    .toDate();
-const seatSection = 'SampleSectionNameXXXXXXXXXXXXXXXXXXX';
-// tslint:disable-next-line:no-magic-numbers prefer-array-literal
-const allSeatNumbers = [...Array(10000)].map((__, seatKey) => `SampleSeatNumber-${seatKey}`);
-const OPERATION_INTERVAL = 2000;
-// const MAXIMUM_CAPACITY = 10002;
-
-mongoose.Model.on('index', (...args) => {
-    console.error('******** index event emitted. ********\n', args);
-});
-
-async function sleep(waitTime: number): Promise<void> {
-    return new Promise<void>((resolve) => {
-        setTimeout(
-            () => {
-                resolve();
-            },
-            waitTime
-        );
-    });
-}
-
-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();
-mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-const formatter = new Intl.NumberFormat('ja-JP');
-// => "1,000"
-
-// tslint:disable-next-line:max-func-body-length
-async function lockSeatsForcibly(params: {
-    maximumCapacity?: number;
-}) {
-    const { maximumCapacity } = params;
-    let startTime: [number, number] = process.hrtime();
-    let diff: [number, number] = process.hrtime(startTime);
-
-    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
-        client,
-        mongoose.connection
-    );
-
-    startTime = process.hrtime();
-    console.log('counting unavailableOffers...');
-    let countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
-        project: { id: project.id },
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
-        }
-    });
-    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
-    console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-    await sleep(OPERATION_INTERVAL);
-    startTime = process.hrtime();
-    console.log('counting searching holders...');
-    const searchHoldersResult = await stockHolderRepo.searchHolders({
-        project: { id: project.id },
-        eventId,
-        startDate: eventStartDate,
-        hasTicketedSeat: true,
-        offers: [
-            // tslint:disable-next-line:no-magic-numbers
-            ...allSeatNumbers.slice(0, 100)
-                .map((seatNumber) => ({ seatSection, seatNumber }))
-        ]
-    });
-    diff = process.hrtime(startTime);
-    console.log('searchHoldersResult.length:', searchHoldersResult.length);
-    console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-    // select 2 seats
-    // tslint:disable-next-line:insecure-random
-    const seatNumber1 = allSeatNumbers[Math.floor(allSeatNumbers.length * Math.random())];
-    const seatNumber2 = allSeatNumbers.filter((seatNumber) => seatNumber !== seatNumber1)[
-        // tslint:disable-next-line:insecure-random
-        Math.floor((allSeatNumbers.length - 1) * Math.random())
-    ];
-
-    const seatNumbers = [seatNumber1, seatNumber2];
-    console.log('seats selected.', seatNumbers);
-
-    let locked = false;
-    while (!locked) {
-        await sleep(OPERATION_INTERVAL);
-        startTime = process.hrtime();
-        const currentHolders: string[] = [];
-        for (const seatNumber of seatNumbers) {
-            const currentHolder = await stockHolderRepo.getHolder({
-                project: { id: project.id },
-                eventId,
-                startDate: eventStartDate,
-                hasTicketedSeat: true,
-                offer: { seatSection, seatNumber }
-            });
-            if (typeof currentHolder === 'string') {
-                currentHolders.push(currentHolder);
-            }
-        }
-        diff = process.hrtime(startTime);
-        console.log('currentHolders:', currentHolders);
-        console.log('diff:', [diff[0], formatter.format(diff[1])]);
-
-        try {
-            await sleep(OPERATION_INTERVAL);
-            const newHolder = Date.now()
-                .toString();
-            const bookingTime = new Date();
-            startTime = process.hrtime();
-            console.log('locking...', newHolder, seatSection, seatNumbers);
-            if (typeof maximumCapacity === 'number') {
-                try {
-                    await stockHolderRepo.lockIfNotLimitExceeded(
-                        {
-                            project: { id: project.id },
-                            provider: { id: providerId },
-                            eventId,
-                            startDate: eventStartDate,
-                            hasTicketedSeat: true,
-                            offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-                            expires,
-                            holder: newHolder,
-                            bookingTime
-                        },
-                        maximumCapacity
-                    );
-                } catch (error) {
-                    if (error.message === 'maximumAttendeeCapacity exceeded') {
-                        // ok
-                    } else {
-                        throw error;
-                    }
-                }
-            } else {
-                await stockHolderRepo.lock({
-                    project: { id: project.id },
-                    provider: { id: providerId },
-                    eventId,
-                    startDate: eventStartDate,
-                    hasTicketedSeat: true,
-                    offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-                    expires,
-                    holder: newHolder,
-                    bookingTime
-                });
-            }
-            diff = process.hrtime(startTime);
-            console.log('locked.', newHolder);
-            console.log('diff:', [diff[0], formatter.format(diff[1])]);
-            locked = true;
-        } catch (error) {
-            if (error instanceof chevre.factory.errors.AlreadyInUse) {
-                console.log('lockResult:', error.name, error.message);
-            } else {
-                console.error(error);
-            }
-        }
-
-        await sleep(OPERATION_INTERVAL);
-        for (const currentHolder of currentHolders) {
-            for (const seatNumber of seatNumbers) {
-                startTime = process.hrtime();
-                console.log('unlocking...', currentHolder, seatSection, seatNumber);
-                const unlockResult = await stockHolderRepo.unlock({
-                    project: { id: project.id },
-                    eventId,
-                    startDate: eventStartDate,
-                    hasTicketedSeat: true,
-                    offer: { seatSection, seatNumber },
-                    holder: currentHolder
-                });
-                diff = process.hrtime(startTime);
-                console.log('unlockResult:', unlockResult);
-                console.log('diff:', [diff[0], formatter.format(diff[1])]);
-            }
-        }
-    }
-
-    await sleep(OPERATION_INTERVAL);
-    countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
-        project: { id: project.id },
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
-        }
-    });
-    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
-
-}
-
-async function main() {
-    // tslint:disable-next-line:no-magic-numbers
-    const numLock = (typeof process.argv[2] === 'string') ? Number(process.argv[2]) : 1;
-    // tslint:disable-next-line:no-magic-numbers
-    const maximumCapacity = (typeof process.argv[3] === 'string') ? Number(process.argv[3]) : undefined;
-
-    const LOCK_INTERVAL = 300;
-    let i = 0;
-    let lockedCount = 0;
-    let timeout: NodeJS.Timeout;
-    const processStartDate = new Date();
-    function onSeatsLocked() {
-        lockedCount += 1;
-        console.log(lockedCount, 'lockSeatsForcibly executed!');
-        console.log('processed.', processStartDate, '~', new Date());
-    }
-
-    timeout = setInterval(
-        () => {
-            if (i >= numLock) {
-                clearInterval(timeout);
-
-                return;
-            }
-
-            i += 1;
-            lockSeatsForcibly({ maximumCapacity })
-                .then(onSeatsLocked)
-                .catch(console.error);
-        },
-        LOCK_INTERVAL
-    );
-}
-
-main()
-    .then()
-    .catch(console.error);