@chevre/domain 22.9.0-alpha.100 → 22.9.0-alpha.101

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

@@ -8,8 +8,8 @@ import { PendingReservationRepo } from '../../../../lib/chevre/repo/pendingReser
 const today = moment()
     .tz('Asia/Tokyo')
     .format('YYYYMMDD');
-const project = { id: String(process.env.PROJECT_ID) };
-const eventId = `sampleEventId${today}`;
+// const project = { id: String(process.env.PROJECT_ID) };
+const eventId = `sampleEventId${today}:01`;
 const eventStartDate = new Date('2025-05-01T00:00:00Z');
 
 const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
@@ -27,42 +27,54 @@ const client = redis.createClient<redis.RedisDefaultModules, Record<string, neve
 client.connect();
 mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
+const formatter = new Intl.NumberFormat('ja-JP');
+
 // tslint:disable-next-line:max-func-body-length
 async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
     // const stockHolderRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
     const pendingReservationRepo = new PendingReservationRepo(mongoose.connection);
 
-    pendingReservationRepo.countUnavailableOffers({
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
+    result = await pendingReservationRepo.countUnavailableOffers(
+        {
+            event: {
+                id: eventId,
+                startDate: eventStartDate,
+                hasTicketedSeat: true
+            }
         }
-    })
-        .then((result) => {
-            console.log('countUnavailableOffersResult:', result);
-        });
+    );
+    console.log('countUnavailableOffersResult:', result);
 
-    pendingReservationRepo.countUnavailableOffersByNumSeats({
-        event: {
-            id: eventId,
-            startDate: eventStartDate,
-            hasTicketedSeat: true
+    startTime = process.hrtime();
+    result = await pendingReservationRepo.countUnavailableOffersByNumSeats(
+        {
+            event: {
+                id: eventId,
+                startDate: eventStartDate,
+                hasTicketedSeat: true
+            }
+        },
+        {
+            limit: 100
         }
-    })
-        .then((result) => {
-            console.log('countUnavailableOffersByNumSeatsResult:', result);
-        });
+    );
+    diff = process.hrtime(startTime);
+    console.log('countUnavailableOffersByNumSeatsResult:', result);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
 
-    const size = await pendingReservationRepo.getSize({
-        project: {
-            id: project.id
-        },
-        eventId,
-        startDate: eventStartDate,
-        hasTicketedSeat: true
-    });
-    console.log('size:', size);
+    // const size = await pendingReservationRepo.getSize({
+    //     project: {
+    //         id: project.id
+    //     },
+    //     eventId,
+    //     startDate: eventStartDate,
+    //     hasTicketedSeat: true
+    // });
+    // console.log('size:', size);
 }
 
 main()

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

@@ -50,24 +50,18 @@ const formatter = new Intl.NumberFormat('ja-JP');
 // => "1,000"
 
 // tslint:disable-next-line:max-func-body-length
-async function lockSeatsForcibly() {
+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...');
-    // const countUnavailableOffersMustBeZero = await stockHolderRepo.countUnavailableOffers({
-    //     event: {
-    //         id: 'xxxxxxxxx',
-    //         startDate: eventStartDate,
-    //         hasTicketedSeat: true
-    //     }
-    // });
-    // diff = process.hrtime(startTime);
-    // console.log('countUnavailableOffersMustBeZero:', countUnavailableOffersMustBeZero);
-    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
+        client,
+        mongoose.connection,
+        { useMongooseForce: true }
+    );
 
     startTime = process.hrtime();
     console.log('counting unavailableOffers...');
@@ -143,35 +137,45 @@ async function lockSeatsForcibly() {
             await sleep(OPERATION_INTERVAL);
             const newHolder = Date.now()
                 .toString();
+            const bookingTime = new Date();
             startTime = process.hrtime();
             console.log('locking...', newHolder, seatSection, seatNumbers);
-            const lockResult = await stockHolderRepo.lock({
-                project: {
-                    id: project.id
-                },
-                eventId,
-                startDate: eventStartDate,
-                hasTicketedSeat: true,
-                offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-                expires: new Date(),
-                holder: newHolder
-            });
-            // const lockResult = await stockHolderRepo.lockIfNotLimitExceeded(
-            //     {
-            //         project: {
-            //             id: project.id
-            //         },
-            //         eventId,
-            //         startDate: eventStartDate,
-            //         hasTicketedSeat: true,
-            //         offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
-            //         expires: new Date(),
-            //         holder: newHolder
-            //     },
-            //     MAXIMUM_CAPACITY
-            // );
+            if (typeof maximumCapacity === 'number') {
+                try {
+                    await stockHolderRepo.lockIfNotLimitExceeded(
+                        {
+                            project: { id: project.id },
+                            eventId,
+                            startDate: eventStartDate,
+                            hasTicketedSeat: true,
+                            offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
+                            expires: bookingTime,
+                            holder: newHolder,
+                            bookingTime
+                        },
+                        maximumCapacity
+                    );
+                } catch (error) {
+                    if (error.message === 'maximumAttendeeCapacity exceeded') {
+                        // ok
+                    } else {
+                        throw error;
+                    }
+                }
+            } else {
+                await stockHolderRepo.lock({
+                    project: { id: project.id },
+                    eventId,
+                    startDate: eventStartDate,
+                    hasTicketedSeat: true,
+                    offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
+                    expires: bookingTime,
+                    holder: newHolder,
+                    bookingTime
+                });
+            }
             diff = process.hrtime(startTime);
-            console.log('lockResult:', lockResult, newHolder);
+            console.log('locked.', newHolder);
             console.log('diff:', [diff[0], formatter.format(diff[1])]);
             locked = true;
         } catch (error) {
@@ -183,11 +187,10 @@ async function lockSeatsForcibly() {
         }
 
         await sleep(OPERATION_INTERVAL);
-        const holder = currentHolders[0];
-        if (typeof holder === 'string') {
+        for (const currentHolder of currentHolders) {
             for (const seatNumber of seatNumbers) {
                 startTime = process.hrtime();
-                console.log('unlocking...', holder, seatSection, seatNumber);
+                console.log('unlocking...', currentHolder, seatSection, seatNumber);
                 const unlockResult = await stockHolderRepo.unlock({
                     project: {
                         id: project.id
@@ -196,7 +199,7 @@ async function lockSeatsForcibly() {
                     startDate: eventStartDate,
                     hasTicketedSeat: true,
                     offer: { seatSection, seatNumber },
-                    holder
+                    holder: currentHolder
                 });
                 diff = process.hrtime(startTime);
                 console.log('unlockResult:', unlockResult);
@@ -217,31 +220,63 @@ async function lockSeatsForcibly() {
 
 }
 
-// const NUM_LOCK = 1;
-const NUM_LOCK = 1000;
-const LOCK_INTERVAL = 1000;
-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());
-}
+async function main() {
+    // const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
+    //     client,
+    //     mongoose.connection,
+    //     { useMongooseForce: true }
+    // );
+    // const newHolder = Date.now()
+    //     .toString();
+    // // tslint:disable-next-line:no-magic-numbers
+    // const seatNumbers = allSeatNumbers.slice(0, 1000);
+    // const lockResult = await stockHolderRepo.lock({
+    //     project: {
+    //         id: project.id
+    //     },
+    //     eventId,
+    //     startDate: eventStartDate,
+    //     hasTicketedSeat: true,
+    //     offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
+    //     expires: new Date(),
+    //     holder: newHolder
+    // });
+    // console.log(lockResult);
+    // return;
 
-timeout = setInterval(
-    () => {
-        if (i >= NUM_LOCK) {
-            clearInterval(timeout);
+    // tslint:disable-next-line:no-magic-numbers
+    const maximumCapacity = (typeof process.argv[2] === 'string') ? Number(process.argv[2]) : undefined;
 
-            return;
-        }
+    // const NUM_LOCK = 1;
+    const NUM_LOCK = 2000;
+    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());
+    }
 
-        i += 1;
-        lockSeatsForcibly()
-            .then(onSeatsLocked)
-            .catch(console.error);
-    },
-    LOCK_INTERVAL
-);
+    timeout = setInterval(
+        () => {
+            if (i >= NUM_LOCK) {
+                clearInterval(timeout);
+
+                return;
+            }
+
+            i += 1;
+            lockSeatsForcibly({ maximumCapacity })
+                .then(onSeatsLocked)
+                .catch(console.error);
+        },
+        LOCK_INTERVAL
+    );
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -34,7 +34,7 @@ export declare class AssetTransactionRepo {
      * 取引を開始する
      */
     start<T extends factory.assetTransactionType>(params: factory.assetTransaction.IStartParams<T>): Promise<factory.assetTransaction.ITransaction<T>>;
-    startWithMinimalResponse<T extends factory.assetTransactionType>(params: factory.assetTransaction.IStartParams<T>): Promise<Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id'>>;
+    startWithMinimalResponse<T extends factory.assetTransactionType>(params: factory.assetTransaction.IStartParams<T>): Promise<Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id' | 'startDate'>>;
     findById<T extends factory.assetTransactionType>(params: {
         typeOf: T;
         id: string;

package/lib/chevre/repo/assetTransaction.js

@@ -313,7 +313,8 @@ class AssetTransactionRepo {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const { typeOf } = params;
-            const creatingTransaction = Object.assign(Object.assign({}, params), { typeOf, status: factory.transactionStatusType.InProgress, startDate: new Date(), 
+            const startDate = new Date();
+            const creatingTransaction = Object.assign(Object.assign({}, params), { typeOf, status: factory.transactionStatusType.InProgress, startDate, 
                 // endDate: undefined,
                 tasksExportAction: {
                     actionStatus: factory.actionStatusType.PotentialActionStatus
@@ -323,7 +324,7 @@ class AssetTransactionRepo {
             if (typeof id !== 'string') {
                 throw new factory.errors.Internal('assetTransaction not saved');
             }
-            return { id };
+            return { id, startDate };
         });
     }
     findById(params, inclusion) {

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

@@ -10,6 +10,8 @@ interface IReservationPackage {
     };
     typeOf: factory.reservationType.ReservationPackage;
     bookingTime: Date;
+    dateCreated: Date;
+    dateModified?: Date;
     numSeats: number;
     reservationFor: {
         id: string;

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

@@ -10,12 +10,14 @@ exports.modelName = modelName;
 const schemaDefinition = {
     project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     typeOf: { type: String, required: true },
-    bookingTime: { type: Date, required: true },
-    expires: { type: Date, required: true },
     numSeats: { type: Number, required: true },
     reservationFor: { type: mongoose_1.SchemaTypes.Mixed, required: true },
     reservationNumber: { type: String, required: true },
-    subReservation: [mongoose_1.SchemaTypes.Mixed]
+    subReservation: [mongoose_1.SchemaTypes.Mixed],
+    bookingTime: { type: Date, required: true },
+    expires: { type: Date, required: true },
+    dateCreated: { type: Date, required: true },
+    dateModified: { type: Date, required: false }
 };
 const schemaOptions = {
     autoIndex: settings_1.MONGO_AUTO_INDEX,
@@ -46,21 +48,32 @@ const indexes = [
         { bookingTime: -1 },
         { name: 'bookingTime' }
     ],
+    // [
+    //     { 'reservationFor.id': 1, bookingTime: -1 },
+    //     { name: 'reservationForId' }
+    // ],
+    // [
+    //     { 'project.id': 1, bookingTime: -1 },
+    //     { name: 'projectId' }
+    // ],
+    // [
+    //     { reservationNumber: 1, bookingTime: -1 },
+    //     { name: 'reservationNumber' }
+    // ],
+    // [
+    //     { 'subReservation.identifier': 1, bookingTime: -1 },
+    //     { name: 'subReservationIdentifier' }
+    // ],
+    // [
+    //     { 'subReservation.identifier': 1 },
+    //     { name: 'subReservationIdentifier' }
+    // ],
     [
-        { 'project.id': 1, bookingTime: -1 },
-        { name: 'projectId' }
-    ],
-    [
-        { 'reservationFor.id': 1, bookingTime: -1 },
-        { name: 'reservationForId' }
-    ],
-    [
-        { reservationNumber: 1, bookingTime: -1 },
-        { name: 'reservationNumber' }
-    ],
-    [
-        { 'subReservation.identifier': 1, bookingTime: -1 },
-        { name: 'subReservationIdentifier' }
+        { reservationNumber: 1 },
+        {
+            unique: true,
+            name: 'uniqueReservationNumber'
+        }
     ],
     [
         { 'reservationFor.id': 1, 'subReservation.identifier': 1 },
@@ -73,24 +86,36 @@ const indexes = [
         }
     ],
     [
-        { reservationNumber: 1 },
         {
-            unique: true,
-            name: 'uniqueReservationNumber'
+            'reservationFor.id': 1,
+            reservationNumber: 1,
+            'subReservation.identifier': 1
+        },
+        {
+            name: 'deleteReservationIfExists',
+            partialFilterExpression: {
+                'subReservation.identifier': { $exists: true }
+            }
         }
     ],
     [
         {
             'reservationFor.id': 1,
-            reservationNumber: 1,
-            'subReservation.identifier': 1
+            'subReservation.identifier': 1,
+            bookingTime: 1,
+            dateCreated: 1
         },
-        { name: 'unlock' }
+        {
+            name: 'aggregateNumSeats',
+            partialFilterExpression: {
+                'subReservation.identifier': { $exists: true }
+            }
+        }
     ]
 ];
 exports.indexes = indexes;
 /**
- * 在庫保持者スキーマ
+ * 保留予約スキーマ
  */
 let schema;
 function createSchema() {

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

@@ -44,18 +44,22 @@ const indexes = [
         { expires: -1 },
         { name: 'expires' }
     ],
-    [
-        { 'project.id': 1, expires: -1 },
-        { name: 'projectId' }
-    ],
-    [
-        { reservationCount: 1, expires: -1 },
-        { name: 'reservationCount' }
-    ],
-    [
-        { 'reservationFor.id': 1, expires: -1 },
-        { name: 'reservationForId' }
-    ],
+    // [
+    //     { 'project.id': 1, expires: -1 },
+    //     { name: 'projectId' }
+    // ],
+    // [
+    //     { 'reservationFor.id': 1, expires: -1 },
+    //     { name: 'reservationForId' }
+    // ],
+    // [
+    //     { reservationIds: 1, expires: -1 },
+    //     { name: 'reservationIds' }
+    // ], // このindexで性能下がる？
+    // [
+    //     { reservationIds: 1 },
+    //     { name: 'reservationIds' }
+    // ], // このindexで性能下がる？
     [
         { 'reservationFor.id': 1 },
         {
@@ -75,16 +79,12 @@ const indexes = [
             'reservationFor.id': 1,
             reservationIds: 1
         },
-        { name: 'unlock' }
-    ],
-    [
-        { reservationIds: 1 },
-        { name: 'reservationIds' }
+        { name: 'decreaseReservationCount' }
     ]
 ];
 exports.indexes = indexes;
 /**
- * 在庫保持者スキーマ
+ * 保留予約集計スキーマ
  */
 let schema;
 function createSchema() {

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

@@ -1,18 +1,19 @@
 import type { Connection } from 'mongoose';
 import { AbstractStockHolderRepo, IGetHolderResult, ILockKey, IOffer, IUnlockKey } from './stockHolderAbstract';
 /**
- * イベントストックホルダーリポジトリ
+ * 保留予約リポジトリ
  */
 export declare class PendingReservationRepo implements AbstractStockHolderRepo {
-    private readonly aggregateModel;
     private readonly pendingReservationModel;
     constructor(connection: Connection);
     private static offer2identifier;
-    private static lockKey2aggregateReservation;
     private static lockKey2reservationPackage;
     lockIfNotLimitExceeded(lockKey: ILockKey, maximumReservationCount: number): Promise<void>;
     lock(lockKey: ILockKey): Promise<void>;
     unlock(params: IUnlockKey): Promise<void>;
+    /**
+     * 現時点での保留予約数を集計する
+     */
     countUnavailableOffers(params: {
         event: {
             id: string;
@@ -26,6 +27,8 @@ export declare class PendingReservationRepo implements AbstractStockHolderRepo {
             startDate: Date;
             hasTicketedSeat: boolean;
         };
+    }, options?: {
+        limit?: number;
     }): Promise<number>;
     getHolder(params: Omit<IUnlockKey, 'holder'>): Promise<string | null | undefined>;
     searchHolders(params: {
@@ -37,11 +40,8 @@ export declare class PendingReservationRepo implements AbstractStockHolderRepo {
         hasTicketedSeat: boolean;
         offers: IOffer[];
     }): Promise<IGetHolderResult[]>;
-    getSize(params: Omit<IUnlockKey, 'holder' | 'offer'>): Promise<any[]>;
-    private createIfNotExist;
+    private aggregateNumSeats;
     private createReservationPackageIfPossible;
     private deleteReservationPackage;
-    private increaseReservationCount;
     private deleteReservationIfExists;
-    private decreaseReservationCount;
 }