@chevre/domain 21.20.0-alpha.2 → 21.20.0-alpha.20

package/example/src/chevre/onAssetTransactionStatusChanged.ts

@@ -0,0 +1,36 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    (await chevre.service.order.createService())
+        .onAssetTransactionStatusChanged({
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            object: {
+                typeOf: chevre.factory.assetTransactionType.Reserve,
+                transactionNumber: '863918387495116',
+                status: chevre.factory.transactionStatusType.Confirmed
+            },
+            purpose: {
+                confirmationNumber: '',
+                orderNumber: 'CIN1-3748070-2008463',
+                typeOf: chevre.factory.order.OrderType.Order
+            },
+            useOnOrderStatusChanged: true
+        })({
+            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
+            acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
+            order: await chevre.repository.Order.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+        });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/retryTasks.ts

@@ -0,0 +1,39 @@
+// tslint:disable:no-implicit-dependencies no-console
+import { chevre } from '../../../lib/index';
+
+import * as  moment from 'moment';
+import * as  mongoose from 'mongoose';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+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.updateMany(
+        {
+            status: { $eq: chevre.factory.taskStatus.Aborted },
+            lastTriedAt: {
+                $gt: moment()
+                    .add(-1, 'day')
+                    .toDate()
+            },
+            name: { $eq: chevre.factory.taskName.TriggerWebhook },
+            'project.id': { $eq: project.id }
+        },
+        {
+            $set: {
+                status: chevre.factory.taskStatus.Ready,
+                remainingNumberOfTries: 20
+            }
+        }
+    )
+        .exec();
+    console.log('result:', result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/searchOrders.ts

@@ -5,21 +5,19 @@ import { chevre } from '../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
 
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const indexes = await mongoose.connection.db.collection('orders')
+        .indexes();
+    // console.log(indexes);
+    console.log(indexes.length, 'indexes found');
 
-    const order = await orderRepo.findByOrderNumber({
-        orderNumber: 'CIN4-3943271-4221863',
-        project: { id: project.id },
-        inclusion: [
-            // 'project', 'typeOf', 'orderNumber', 'dateReturned', 'id',
-            // 'customer', 'returner', 'seller', 'price', 'priceCurrency', 'orderDate'
-        ],
-        exclusion: ['acceptedOffers']
-    });
-    console.log(order);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
     const orders = await orderRepo.search(
         {
@@ -30,10 +28,10 @@ async function main() {
                 //     itemOffered: {
                 //         issuedThrough: { typeOf: { $eq: chevre.factory.product.ProductType.MembershipService } }
                 //     }
-            },
-            orderedItem: {
-                $size: 3
             }
+            // orderedItem: {
+            //     $size: 3
+            // }
             // paymentMethods: {
             //     paymentMethod: { identifier: { $in: ['Cash'] } }
             //     additionalProperty: {
@@ -49,7 +47,7 @@ async function main() {
             customer: 1
         }
     );
-    console.log('orders found', orders);
+    // console.log('orders found', orders);
     console.log(orders.length, 'orders found');
 }
 

package/example/src/chevre/searchSlicedAcceptedOffersByOrderNumber.ts

@@ -0,0 +1,28 @@
+// 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);
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+
+    const result = await acceptedOfferRepo.searchSlicedAcceptedOffersByOrderNumber(
+        {
+            orderNumber: { $eq: 'CIN1-3748070-2008463' },
+            project: { id: { $eq: String(process.env.PROJECT_ID) } },
+            // tslint:disable-next-line:no-magic-numbers
+            $slice: [0, 2]
+        }
+    );
+    console.log(result);
+    console.log(result.acceptedOffers.map((offer) => {
+        return `${(<any>offer.itemOffered).id}`;
+    }));
+    console.log(result.acceptedOffers.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/sendOrder.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    (await chevre.service.order.createService())
+        .sendOrder({
+            agent: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            project: { id: project.id },
+            object: {
+                confirmationNumber: '57761',
+                orderNumber: 'CIN1-3748070-2008463',
+                previousOrderStatus: chevre.factory.orderStatus.OrderInTransit,
+                acceptedOffers: {
+                    limit: 1,
+                    page: 1
+                }
+            },
+            useOnOrderStatusChanged: false
+        })({
+            acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
+            action: await chevre.repository.Action.createInstance(mongoose.connection),
+            order: await chevre.repository.Order.createInstance(mongoose.connection),
+            ownershipInfo: await chevre.repository.OwnershipInfo.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+        });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/transaction/processAcceptOffer.ts

@@ -0,0 +1,48 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+    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
+    });
+    await client.connect();
+
+    const orderInTransactionRepo = await chevre.repository.OrderInTransaction.createInstance(mongoose.connection);
+
+    const orderNumber: string = 'sampleOrderNumber';
+    const reservationNumber: string = 'sampleReservationNumber';
+    const acceptedOffers: chevre.factory.order.IAcceptedOffer<chevre.factory.order.IReservation>[] = [
+        {
+            typeOf: chevre.factory.offerType.Offer,
+            id: 'xxx',
+            itemOffered: <any>{ reservationNumber },
+            priceSpecification: <any>{}
+        }
+    ];
+    let result: any = await orderInTransactionRepo.acceptOffer({
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        orderNumber,
+        acceptedOffers
+    });
+    console.log(result);
+    result = await orderInTransactionRepo.voidAcceptedOfferByReservationNumber({
+        orderNumber,
+        acceptedOffers: { reservationNumber: { $in: [reservationNumber] } }
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/transaction/processPlaceOrder.ts

@@ -11,6 +11,13 @@ const paymentMethodType = 'CreditCard';
 const paymentServiceId = '5f9a4fed4f3709000abe6415';
 // const paymentMethodType = 'PayPay';
 // const paymentServiceId = '60e9560176a391000b23e20b';
+const AMOUNT: number = 1;
+const creditCard: chevre.factory.paymentMethod.paymentCard.creditCard.IUncheckedCardRaw = {
+    cardNo: '4100000000000100',
+    expire: '2812',
+    cardPass: '123',
+    holderName: 'AA AA'
+};
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -43,16 +50,13 @@ async function main() {
         agent: { id: CLIENT_ID },
         object: {
             typeOf: chevre.factory.action.authorize.paymentMethod.any.ResultType.Payment,
-            amount: 1,
+            amount: AMOUNT,
             paymentMethod: paymentMethodType,
             issuedThrough: { id: paymentServiceId },
             method: '1',
             creditCard: {
-                retUrl: String(process.env.SECURE_TRAN_RET_URL),
-                cardNo: '4100000000000100',
-                expire: '2812',
-                cardPass: '123',
-                holderName: 'AA AA'
+                ...creditCard,
+                retUrl: String(process.env.SECURE_TRAN_RET_URL)
             }
         },
         purpose: { id: transaction.id, typeOf: transaction.typeOf },
@@ -61,75 +65,100 @@ async function main() {
             typeOf: chevre.factory.creativeWorkType.WebApplication,
             id: CLIENT_ID
         }
-        // options: {
-        //     use3DS: true
-        // }
     })({
         assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
         paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
         paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
         paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
         person: await chevre.repository.Person.createInstance({ userPoolId: '' }),
-        project: await chevre.repository.Project.createInstance(mongoose.connection),
         transactionNumber: await chevre.repository.TransactionNumber.createInstance(client),
         transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
     });
     console.log(publishPaymentUrlResult);
 
     // wait callback...
+    // tslint:disable-next-line:max-func-body-length
     await new Promise<void>((resolve, reject) => {
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
         });
 
+        // tslint:disable-next-line:max-func-body-length
         rl.question('callback received?:\n', async () => {
             try {
-                const authorizeResult = await (await chevre.service.payment.any.createService()).authorize({
-                    project: { id: project.id },
-                    agent: { id: CLIENT_ID },
-                    object: {
-                        typeOf: chevre.factory.action.authorize.paymentMethod.any.ResultType.Payment,
-                        amount: 1,
-                        paymentMethodId: publishPaymentUrlResult.paymentMethodId,
-                        paymentMethod: paymentMethodType,
-                        issuedThrough: { id: paymentServiceId },
-                        method: '1',
-                        creditCard: {
-                            cardNo: '4100000000000100',
-                            expire: '2812',
-                            cardPass: '123',
-                            holderName: 'AA AA'
+                await new Promise<void>(async (resolve2, reject2) => {
+                    const rl2 = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout
+                    });
+
+                    rl2.question('VOID or AUTH?:\n', async (jobCd) => {
+                        if (jobCd === 'AUTH') {
+                            const authorizeResult = await (await chevre.service.payment.any.createService()).authorize({
+                                project: { id: project.id },
+                                agent: { id: CLIENT_ID },
+                                object: {
+                                    typeOf: chevre.factory.action.authorize.paymentMethod.any.ResultType.Payment,
+                                    amount: AMOUNT,
+                                    paymentMethodId: publishPaymentUrlResult.paymentMethodId,
+                                    paymentMethod: paymentMethodType,
+                                    issuedThrough: { id: paymentServiceId },
+                                    method: '1',
+                                    creditCard
+                                },
+                                purpose: { id: transaction.id, typeOf: transaction.typeOf },
+                                paymentServiceType: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
+                                location: {
+                                    typeOf: chevre.factory.creativeWorkType.WebApplication,
+                                    id: CLIENT_ID
+                                },
+                                options: {
+                                    useCancelPayTransactionOnFailed: false,
+                                    useCheckMovieTicketBeforePay: false,
+                                    useCheckByIdentifierIfNotYet: false,
+                                    useSearchTrade4accountId: false
+                                }
+                            })({
+                                accountingReport: await chevre.repository.AccountingReport.createInstance(mongoose.connection),
+                                action: await chevre.repository.Action.createInstance(mongoose.connection),
+                                assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
+                                event: await chevre.repository.Event.createInstance(mongoose.connection),
+                                paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
+                                paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
+                                paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
+                                person: await chevre.repository.Person.createInstance({ userPoolId: '' }),
+                                product: await chevre.repository.Product.createInstance(mongoose.connection),
+                                task: await chevre.repository.Task.createInstance(mongoose.connection),
+                                transactionNumber: await chevre.repository.TransactionNumber.createInstance(client),
+                                transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+                            });
+                            console.log('payment authorized.', authorizeResult.id);
+                        } else if (jobCd === 'VOID') {
+                            await (await chevre.service.payment.any.createService()).invalidatePaymentUrl({
+                                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                                purpose: { id: transaction.id, typeOf: transaction.typeOf }
+                            })({
+                                accountingReport: await chevre.repository.AccountingReport.createInstance(mongoose.connection),
+                                action: await chevre.repository.Action.createInstance(mongoose.connection),
+                                assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
+                                paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
+                                paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
+                                paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
+                                task: await chevre.repository.Task.createInstance(mongoose.connection),
+                                transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+                            });
+                            console.log('payment voided.');
+                        } else {
+                            reject2(`jobCd ${jobCd} not implemented`);
+
+                            return;
                         }
-                    },
-                    purpose: { id: transaction.id, typeOf: transaction.typeOf },
-                    paymentServiceType: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
-                    location: {
-                        typeOf: chevre.factory.creativeWorkType.WebApplication,
-                        id: CLIENT_ID
-                    },
-                    options: {
-                        useCancelPayTransactionOnFailed: false,
-                        useCheckMovieTicketBeforePay: false,
-                        useCheckByIdentifierIfNotYet: false,
-                        useSearchTrade4accountId: false
-                    }
-                })({
-                    accountingReport: await chevre.repository.AccountingReport.createInstance(mongoose.connection),
-                    action: await chevre.repository.Action.createInstance(mongoose.connection),
-                    assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
-                    event: await chevre.repository.Event.createInstance(mongoose.connection),
-                    paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
-                    paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-                    paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
-                    person: await chevre.repository.Person.createInstance({ userPoolId: '' }),
-                    product: await chevre.repository.Product.createInstance(mongoose.connection),
-                    project: await chevre.repository.Project.createInstance(mongoose.connection),
-                    task: await chevre.repository.Task.createInstance(mongoose.connection),
-                    transactionNumber: await chevre.repository.TransactionNumber.createInstance(client),
-                    transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
+
+                        // rl.close();
+                        resolve2();
+                    });
                 });
-                console.log(authorizeResult);
 
                 resolve();
             } catch (error) {

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

@@ -6,6 +6,11 @@ type IProjection4searchWithUnwoundAcceptedOffers = {
     _id?: 0 | 1;
 };
 type IDistinctField = 'acceptedOffers.id' | 'acceptedOffers.itemOffered.reservationNumber' | 'acceptedOffers.itemOffered.reservationFor.id' | 'acceptedOffers.itemOffered.issuedThrough.id' | 'acceptedOffers.offeredThrough.identifier' | 'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode';
+type IAcceptedOffer = factory.order.IAcceptedOffer<factory.order.IItemOffered>;
+interface ISearchSlicedAcceptedOffersResult {
+    acceptedOffers: IAcceptedOffer[];
+    numAcceptedOffers: number;
+}
 /**
  * 注文オファーリポジトリ
  */
@@ -29,6 +34,7 @@ export declare class MongoRepository {
     searchAcceptedOffersByOrderNumber(filter: {
         limit?: number;
         page?: number;
+        $slice?: [number, number];
         orderNumber: {
             $eq: string;
         };
@@ -47,7 +53,21 @@ export declare class MongoRepository {
                 };
             };
         };
-    }, inclusion?: (keyof factory.order.IAcceptedOffer<factory.order.IItemOffered>)[]): Promise<factory.order.IAcceptedOffer<factory.order.IItemOffered>[]>;
+    }, inclusion?: (keyof IAcceptedOffer)[]): Promise<IAcceptedOffer[]>;
+    /**
+     * 注文オファーをsliceして検索する(2024-01-10~)
+     */
+    searchSlicedAcceptedOffersByOrderNumber(filter: {
+        $slice: [number, number];
+        orderNumber: {
+            $eq: string;
+        };
+        project: {
+            id: {
+                $eq: string;
+            };
+        };
+    }): Promise<ISearchSlicedAcceptedOffersResult>;
     /**
      * 特定のフィールド値リストを検索する
      */

package/lib/chevre/repo/acceptedOffer.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoRepository = void 0;
+const factory = require("../factory");
 const order_1 = require("./mongoose/schemas/order");
 const order_2 = require("./order");
 const settings_1 = require("../settings");
@@ -61,6 +62,7 @@ class MongoRepository {
                     }
                 },
                 { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
+                { $match: { typeOf: { $eq: factory.order.OrderType.Order } } },
                 {
                     $project: {
                         _id: 0,
@@ -86,8 +88,9 @@ class MongoRepository {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const matchStages = [
+                { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
                 { $match: { 'project.id': { $eq: filter.project.id.$eq } } },
-                { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } }
+                { $match: { typeOf: { $eq: factory.order.OrderType.Order } } }
             ];
             const itemOfferedTypeOfIn = (_c = (_b = (_a = filter.acceptedOffers) === null || _a === void 0 ? void 0 : _a.itemOffered) === null || _b === void 0 ? void 0 : _b.typeOf) === null || _c === void 0 ? void 0 : _c.$in;
             if (Array.isArray(itemOfferedTypeOfIn)) {
@@ -137,6 +140,32 @@ class MongoRepository {
                 .exec();
         });
     }
+    /**
+     * 注文オファーをsliceして検索する(2024-01-10~)
+     */
+    searchSlicedAcceptedOffersByOrderNumber(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aggregate = this.orderModel.aggregate([
+                { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
+                { $match: { 'project.id': { $eq: filter.project.id.$eq } } },
+                { $match: { typeOf: { $eq: factory.order.OrderType.Order } } },
+                {
+                    $project: {
+                        _id: 0,
+                        acceptedOffers: { $slice: ['$acceptedOffers', ...filter.$slice] },
+                        numAcceptedOffers: { $size: '$acceptedOffers' }
+                    }
+                }
+            ]);
+            const result = (yield aggregate
+                .option({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+                .exec()).shift();
+            if (result === undefined) {
+                throw new factory.errors.NotFound(factory.order.OrderType.Order);
+            }
+            return result;
+        });
+    }
     /**
      * 特定のフィールド値リストを検索する
      */
@@ -146,7 +175,8 @@ class MongoRepository {
                 return [];
             }
             const filterQuery = {
-                orderNumber: { $in: filter.orderNumber.$in }
+                orderNumber: { $in: filter.orderNumber.$in },
+                typeOf: { $eq: factory.order.OrderType.Order }
             };
             filterQuery[field] = { $exists: true };
             return this.orderModel.distinct(field, filterQuery)

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

@@ -78,10 +78,10 @@ export declare class MongoRepository {
     /**
      * アクション取消
      */
-    cancel<T extends factory.actionType>(params: {
-        typeOf: T;
+    cancelWithVoid(params: {
+        typeOf: factory.actionType;
         id: string;
-    }): Promise<IAction<T>>;
+    }): Promise<void>;
     /**
      * アクション失敗
      */

package/lib/chevre/repo/action.js

@@ -511,18 +511,16 @@ class MongoRepository {
     /**
      * アクション取消
      */
-    cancel(params) {
+    cancelWithVoid(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const doc = yield this.actionModel.findOneAndUpdate({
-                typeOf: params.typeOf,
-                _id: params.id
-            }, { actionStatus: factory.actionStatusType.CanceledActionStatus }, { new: true })
-                .select({ __v: 0, createdAt: 0, updatedAt: 0 })
+                _id: { $eq: params.id },
+                typeOf: { $eq: params.typeOf }
+            }, { actionStatus: factory.actionStatusType.CanceledActionStatus }, { new: false, projection: { _id: 1 } })
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.actionModel.modelName);
             }
-            return doc.toObject();
         });
     }
     /**

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

@@ -1,5 +1,5 @@
 import { IndexDefinition, IndexOptions, Schema } from 'mongoose';
 declare const modelName = "Order";
-declare function createSchema(): Schema;
 declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): Schema;
 export { modelName, indexes, createSchema };

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

@@ -60,17 +60,6 @@ const schemaOptions = {
         versionKey: false
     }
 };
-/**
- * 注文スキーマ
- */
-let schema;
-function createSchema() {
-    if (schema === undefined) {
-        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
-    }
-    return schema;
-}
-exports.createSchema = createSchema;
 const indexes = [
     [
         { createdAt: 1 },
@@ -456,6 +445,26 @@ const indexes = [
                 additionalProperty: { $exists: true }
             }
         }
+    ],
+    [
+        { typeOf: 1, orderDate: -1 },
+        { name: 'searchByTypeOf' }
     ]
 ];
 exports.indexes = indexes;
+/**
+ * 注文スキーマ
+ */
+let schema;
+function createSchema() {
+    if (schema === undefined) {
+        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
+        if (settings_1.MONGO_AUTO_INDEX) {
+            indexes.forEach((indexParams) => {
+                schema === null || schema === void 0 ? void 0 : schema.index(...indexParams);
+            });
+        }
+    }
+    return schema;
+}
+exports.createSchema = createSchema;