@chevre/domain 24.0.0-alpha.4 → 24.0.0-alpha.40

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-type IDocType = factory.schedule.IEventWithSchedule;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.schedule.IEventWithSchedule, 'id'>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Schedule";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.seller.ISeller, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Seller";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.sellerReturnPolicy.ISellerReturnPolicy, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "SellerReturnPolicy";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

package/lib/chevre/repo/mongoose/schemas/service/availableHour.d.ts

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../../virtuals';
 /**
  * The place is open if the opens property is specified, and closed otherwise.
  */
@@ -9,9 +10,9 @@ interface IOpeningHoursSpecification {
     validThrough: Date;
 }
 type IDocType = IOpeningHoursSpecification;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Service.AvailableHour";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-type IDocType = factory.permit.IPermit;
-type IModel = Model<IDocType>;
+type IDocType = Omit<factory.permit.IPermit, 'id'>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "ServiceOutput";
 declare function createSchema(): ISchema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,6 +1,7 @@
 import type { Algorithm } from 'jsonwebtoken';
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
 import * as factory from '../../../factory';
+import { IVirtuals } from '../virtuals';
 interface IOnOrderStatusChanged {
     /**
      * AggService通知先
@@ -182,10 +183,10 @@ export interface ISetting {
     useMongo4transactionNumberFrom?: Date;
 }
 type IDocType = ISetting;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Setting";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.task.ITask<factory.taskName>, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Task";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -215,6 +215,7 @@ const indexes = [
             }
         }
     ]
+    // eslint-disable-next-line no-warning-comments
     // TODO add unique index(2025-03-28~)
     // [
     //     { identifier: 1 },

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

@@ -1,4 +1,5 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 export interface ITicketIssuedBy {
     id: string;
@@ -19,10 +20,10 @@ export interface ITicket {
     issuedBy: ITicketIssuedBy;
 }
 type IDocType = Omit<ITicket, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Ticket";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,13 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
-type IDocType = factory.transaction.ITransaction<factory.transactionType>;
-type IModel = Model<IDocType>;
+type IPlaceOrder = Omit<factory.transaction.placeOrder.ITransaction, 'id'>;
+type IReturnOrder = Omit<factory.transaction.returnOrder.ITransaction, 'id'>;
+type IDocType = IPlaceOrder | IReturnOrder;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Transaction";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -163,6 +163,37 @@ const indexes = [
             }
         }
     ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber20260221',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true },
+                startDate: { $gte: new Date('2026-02-21T11:00:00Z') }
+            }
+        }
+    ],
+    [
+        // 注文取引のobject.orderNumberも発行されている場合ユニークなはず(2026-02-21~)
+        {
+            typeOf: 1,
+            'object.orderNumber': 1
+        },
+        {
+            name: 'uniquePlacingOrderNumber',
+            unique: true,
+            partialFilterExpression: {
+                typeOf: factory.transactionType.PlaceOrder,
+                'object.orderNumber': { $exists: true }
+            }
+        }
+    ],
     [
         // ひとつの注文取引に対する確定返品取引はユニークなはず
         { 'object.order.orderNumber': 1 },

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

@@ -1,4 +1,5 @@
 import { Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 declare enum DataCatalogIdentifier {
     confirmationNumber = "confirmationNumber",
@@ -31,9 +32,9 @@ interface IDataFeed {
     };
 }
 type IDocType = IDataFeed;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "TransactionNumber";
 declare function createSchema(): ISchema;
 export { createSchema, IDocType, IModel, modelName, DataCatalogIdentifier };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.trip.ITrip<factory.tripType>, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "Trip";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

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

@@ -1,10 +1,11 @@
 import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../virtuals';
 import * as factory from '../../../factory';
 type IDocType = Omit<factory.creativeWork.certification.webSite.ICertification, 'id'>;
-type IModel = Model<IDocType>;
+type IModel = Model<IDocType, {}, {}, IVirtuals>;
 type ISchemaDefinition = SchemaDefinition<IDocType>;
-type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, IVirtuals, {}, ISchemaDefinition, IDocType>;
 declare const modelName = "WebSite";
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
 declare function createSchema(): ISchema;
-export { createSchema, IModel, indexes, modelName };
+export { createSchema, IDocType, IModel, indexes, modelName };

package/lib/chevre/repo/mongoose/virtuals.d.ts

@@ -0,0 +1,3 @@
+export interface IVirtuals {
+    id: string;
+}

package/lib/chevre/repo/mongoose/virtuals.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,7 +4,7 @@ import * as factory from '../factory';
 type IUnset = {
     [key in keyof Pick<IDocType, 'color' | 'image'>]?: 1;
 };
-type IKeyOfProjection = keyof IDocType;
+type IKeyOfProjection = keyof IDocType | 'id';
 /**
  * 決済カード区分リポジトリ
  */
@@ -35,6 +35,7 @@ export declare class MovieTicketTypeRepo {
         id?: string;
         attributes: IDocType & {
             $unset?: IUnset;
+            id?: string;
         };
     }): Promise<{
         id: string;

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

@@ -29,11 +29,11 @@ export declare class NoteRepo {
          */
         update: boolean;
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedNotes: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedNotes?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * 主題リソースから全メモを削除する
      */

package/lib/chevre/repo/note.js

@@ -234,6 +234,7 @@ class NoteRepo {
                 .exec();
             return { bulkWriteResult, modifiedNotes };
         }
+        return {};
     }
     // /**
     //  * 既知のメモIDリストからメモを削除する

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

@@ -21,7 +21,7 @@ export declare class NoteAboutOrderRepo {
      */
     upsertOrderNoteByIdentifier(params: Pick<INoteAboutOrder, 'about' | 'creator' | 'identifier' | 'project' | 'provider' | 'text' | 'version'>[], options: {
         overwrite: boolean;
-    }): Promise<BulkWriteResult | void>;
+    }): Promise<BulkWriteResult | undefined>;
     updateById(params: {
         id: string;
         attributes: Pick<INoteAboutOrder, 'text' | 'editor'>;

package/lib/chevre/repo/noteAboutOrder.js

@@ -173,6 +173,7 @@ class NoteAboutOrderRepo {
         if (bulkWriteOps.length > 0) {
             return this.noteModel.bulkWrite(bulkWriteOps, { ordered: false });
         }
+        return;
     }
     async updateById(params) {
         const updateFields = {

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

@@ -1,5 +1,5 @@
 import type { BulkWriteResult } from 'mongodb';
-import type { Connection, Document, FilterQuery } from 'mongoose';
+import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
 import { IDocType } from './mongoose/schemas/offerCatalog';
 export type IAggregatedOfferCatalog = Pick<factory.offerCatalog.IOfferCatalog, 'id' | 'name' | 'description' | 'project' | 'typeOf' | 'identifier' | 'itemOffered' | 'additionalProperty'> & {
@@ -49,11 +49,11 @@ export declare class OfferCatalogRepo {
          */
         itemListElementType: factory.offerCatalog.IItemListElement['typeOf'];
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedCatalogs: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedCatalogs?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * 同期日時を更新する
      */
@@ -169,19 +169,23 @@ export declare class OfferCatalogRepo {
             id: string;
         };
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<Document<unknown, {}, IDocType> & factory.offerCatalog.IOfferCatalog & {
+    }> & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.offerCatalog.IOfferCatalog, "id"> & {
         _id: string;
         alternateName?: any;
         dateSynced?: Date;
     } & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.offerCatalog.IOfferCatalog>;
         $unset: any;

package/lib/chevre/repo/offerCatalog.js

@@ -270,6 +270,7 @@ class OfferCatalogRepo {
                 .exec();
             return { bulkWriteResult, modifiedCatalogs };
         }
+        return {};
     }
     /**
      * 同期日時を更新する

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

@@ -42,11 +42,11 @@ export declare class OfferCatalogItemRepo {
          */
         productType: factory.product.ProductType;
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedCatalogs: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedCatalogs?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * 同期日時を更新する
      */

package/lib/chevre/repo/offerCatalogItem.js

@@ -223,6 +223,7 @@ class OfferCatalogItemRepo {
                 .exec();
             return { bulkWriteResult, modifiedCatalogs };
         }
+        return {};
     }
     /**
      * 同期日時を更新する

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

@@ -1,5 +1,6 @@
 import type { Connection, FilterQuery } from 'mongoose';
 import * as factory from '../factory';
+import { IDocType } from './mongoose/schemas/order';
 type IOrderWithoutAcceptedOffers = factory.order.IOrder;
 type IKeyOfProjection = Extract<keyof IOrderWithoutAcceptedOffers, 'broker' | 'confirmationNumber' | 'customer' | 'dateReturned' | 'identifier' | 'name' | 'orderDate' | 'orderNumber' | 'orderStatus' | 'orderedItem' | 'paymentMethods' | 'previousOrderStatus' | 'price' | 'priceCurrency' | 'project' | 'returner' | 'seller' | 'typeOf' | 'url'> | 'paymentMethods.accountId' | 'paymentMethods.name' | 'paymentMethods.paymentMethod' | 'paymentMethods.paymentMethodId' | 'paymentMethods.totalPaymentDue' | 'paymentMethods.additionalProperty' | 'paymentMethods.issuedThrough' | 'customer.id' | 'customer.typeOf';
 export type IReturnedOrder = Pick<IOrderWithoutAcceptedOffers, 'project' | 'typeOf' | 'orderNumber' | 'dateReturned' | 'id' | 'customer' | 'returner' | 'seller' | 'price' | 'priceCurrency' | 'orderDate'> & {
@@ -142,19 +143,19 @@ export declare class OrderRepo {
     }): Promise<(IOrderWithoutAcceptedOffers & {
         id: string;
     })[]>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
-        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }> & Omit<factory.order.IOrder, "id"> & {
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }, import("mongoose").QueryOptions<import("mongoose").Document<unknown, {}, Omit<factory.order.IOrder, "id"> & {
-        acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
-    }> & Omit<factory.order.IOrder, "id"> & {
+    } & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, {}, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<Omit<factory.order.IOrder, "id"> & {
         acceptedOffers?: factory.order.IAcceptedOffer<factory.order.IItemOffered>[];
     } & {
         _id: import("mongoose").Types.ObjectId;
-    }>>;
+    } & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.order.IOrder>;
         $unset: any;

package/lib/chevre/repo/order.js

@@ -853,6 +853,7 @@ class OrderRepo {
         }, {
             $set: {
                 'paymentMethods.$[invoice].paymentMethod.identifier': params.invoice.paymentMethod.identifier,
+                // eslint-disable-next-line no-warning-comments
                 // TODO 互換性維持対応としてtypeOfも変更しているが、そのうち廃止(2023-08-30)
                 'paymentMethods.$[invoice].typeOf': params.invoice.paymentMethod.identifier
             }
@@ -949,7 +950,8 @@ class OrderRepo {
             typeOf: { $eq: factory.order.OrderType.Order },
             acceptedOffers: {
                 $elemMatch: {
-                    'itemOffered.typeOf': { $in: [factory.reservationType.BusReservation, factory.reservationType.EventReservation] },
+                    // 'itemOffered.typeOf': { $in: [factory.reservationType.BusReservation, factory.reservationType.EventReservation] },
+                    'itemOffered.typeOf': { $in: [factory.reservationType.EventReservation] },
                     'itemOffered.id': { $eq: params.reservationId }
                 }
             },

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

@@ -28,6 +28,10 @@ export declare class OrderInTransactionRepo {
      * 注文を受注する
      */
     placeOrder(order: IPlacingOrder): Promise<void>;
+    /**
+     * 注文documentがなければ作成し、受け入れられたオファーを追加する
+     * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
+     */
     acceptOffer(params: Pick<IOrderInTransaction, 'acceptedOffers' | 'orderNumber' | 'project'>): Promise<import("mongoose").UpdateWriteOpResult | undefined>;
     /**
      * serialNumberからオファーを除外する
@@ -45,6 +49,10 @@ export declare class OrderInTransactionRepo {
     setCustomer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project'> & {
         customer: factory.order.ICustomer;
     }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
+     */
     findCustomerByOrderNumber(params: {
         orderNumber: {
             $eq: string;

package/lib/chevre/repo/orderInTransaction.js

@@ -66,6 +66,10 @@ class OrderInTransactionRepo {
         }, { $set: setFields }, {})
             .exec();
     }
+    /**
+     * 注文documentがなければ作成し、受け入れられたオファーを追加する
+     * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
+     */
     async acceptOffer(params) {
         if (!Array.isArray(params.acceptedOffers) || params.acceptedOffers.length === 0) {
             return;
@@ -78,7 +82,10 @@ class OrderInTransactionRepo {
         };
         return this.orderModel.updateOne({
             typeOf: { $eq: factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: params.orderNumber }
+            orderNumber: { $eq: params.orderNumber },
+            // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
+            // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
+            'project.id': { $eq: params.project.id }
         }, {
             $setOnInsert: setOnInsert,
             $push: {
@@ -130,7 +137,10 @@ class OrderInTransactionRepo {
         const { customer, orderNumber, project } = params;
         const filter = {
             typeOf: { $eq: factory.transactionType.PlaceOrder },
-            orderNumber: { $eq: orderNumber }
+            orderNumber: { $eq: orderNumber },
+            // プロジェクトでもフィルター(注文番号重複バグがあったため)(2026-02-21~)
+            // 万が一異なるプロジェクトで同じ注文番号でオファーを受け入れようとしても、DBにインデックスによってDuplicateKey
+            'project.id': { $eq: project.id }
         };
         const setOnInsert = {
             typeOf: factory.transactionType.PlaceOrder,
@@ -145,6 +155,10 @@ class OrderInTransactionRepo {
         }, { upsert: true })
             .exec();
     }
+    /**
+     * 注文ドキュメントからcustomer属性を参照する
+     * customer未設定であれば、NotFound
+     */
     async findCustomerByOrderNumber(params) {
         const doc = await this.orderModel.findOne({
             orderNumber: { $eq: params.orderNumber.$eq }

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

@@ -9,9 +9,10 @@ export declare class OrderNumberRepo {
         connection: Connection;
     });
     /**
-     * タイムスタンプから発行する
+     * 注文日時から新しい注文番号を発行する
+     * グローバルユニークである前提
      */
-    publishByTimestamp(params: {
+    issueOrderNumber(params: {
         project: {
             alternateName: string;
         };