@chevre/domain 21.20.0-alpha.6 → 21.20.0-alpha.60

package/example/src/chevre/findTransactionById.ts

@@ -0,0 +1,21 @@
+// 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 transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+
+    const transaction = await transactionRepo.findById({
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        id: '65ab04d5206595479469f50c',
+        inclusion: ['endDate', 'id', 'object', 'project', 'seller', 'startDate', 'status', 'typeOf']
+    });
+    console.log('transaction:', transaction);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/importCategoryCodesFromCOA.ts

@@ -9,7 +9,8 @@ const project = { id: String(process.env.PROJECT_ID) };
 
 const coaAuthClient = new COA.auth.RefreshToken({
     endpoint: chevre.credentials.coa.endpoint,
-    refreshToken: chevre.credentials.coa.refreshToken
+    refreshToken: chevre.credentials.coa.refreshToken,
+    useFetch: chevre.credentials.coa.useFetch
 });
 
 async function main() {

package/example/src/chevre/importOffersFromCOA.ts

@@ -9,7 +9,8 @@ const project = { id: String(process.env.PROJECT_ID) };
 
 const coaAuthClient = new COA.auth.RefreshToken({
     endpoint: chevre.credentials.coa.endpoint,
-    refreshToken: chevre.credentials.coa.refreshToken
+    refreshToken: chevre.credentials.coa.refreshToken,
+    useFetch: chevre.credentials.coa.useFetch
 });
 
 async function main() {

package/example/src/chevre/{migrateOrderPaymentMethodIdentifier.ts → migrateOrderAcceptedOfferSerialNumber.ts}

@@ -10,14 +10,15 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
     const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
     const cursor = orderRepo.getCursor(
         {
-            'paymentMethods.paymentMethodId': { $exists: true },
-            'paymentMethods.paymentMethod.identifier': { $exists: false },
+            // 'acceptedOffers.serialNumber': { $exists: false },
+            'acceptedOffers.itemOffered.reservationNumber': { $exists: true },
             // 'project.id': { $eq: project.id },
-            // orderNumber: { $eq: 'KNR1-3961294-9087043' },
+            // orderNumber: { $eq: 'KOB1-3749861-4732433' },
             orderDate: {
                 $gte: moment()
                     // tslint:disable-next-line:no-magic-numbers
@@ -33,7 +34,7 @@ async function main() {
             orderDate: 1,
             orderNumber: 1,
             project: 1,
-            paymentMethods: 1
+            acceptedOffers: 1
         }
     );
     console.log('orders found');
@@ -45,28 +46,26 @@ async function main() {
         const order: Pick<
             chevre.factory.order.IOrder,
             'orderDate' | 'orderNumber' | 'project' | 'paymentMethods'
-        > = doc.toObject();
+        > & {
+            acceptedOffers: chevre.factory.order.IAcceptedOffer<chevre.factory.order.IReservation>[];
+        } = doc.toObject();
 
-        const noPayment = order.paymentMethods.length === 0;
-        const alreadyMigrated = order.paymentMethods.every((invoice) => {
-            return typeof invoice.paymentMethod?.identifier === 'string'
-                && invoice.paymentMethod?.identifier.length > 0;
-            // && invoice.paymentMethod.identifier === (<any>invoice).typeOf;
+        const alreadyMigrated = order.acceptedOffers.every((offer) => {
+            return typeof offer.serialNumber === 'string'
+                && offer.serialNumber.length > 0
+                && offer.itemOffered.reservationNumber === offer.serialNumber;
         });
 
-        if (noPayment) {
-            console.log('noPayment.', order.project.id, order.orderNumber, order.orderDate, i);
-        } else if (alreadyMigrated) {
+        if (alreadyMigrated) {
             console.log('already exist.', order.project.id, order.orderNumber, order.orderDate, i);
         } else {
-            console.log('updating...', order.project.id, order.orderNumber, order.orderDate, i);
-            for (const invoice of order.paymentMethods) {
-                await orderRepo.fixPaymentMethodIdentifier({
+            for (const offer of order.acceptedOffers) {
+                console.log('updating...', order.project.id, order.orderNumber, order.orderDate, offer.itemOffered.reservationNumber, i);
+                await acceptedOfferRepo.fixSerialNumber({
                     project: { id: order.project.id },
                     orderNumber: order.orderNumber,
-                    invoice: {
-                        paymentMethodId: invoice.paymentMethodId,
-                        paymentMethod: { identifier: (<any>invoice).typeOf }
+                    acceptedOffers: {
+                        serialNumber: offer.itemOffered.reservationNumber
                     }
                 });
             }

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/searchActions.ts

@@ -5,20 +5,26 @@ import * as  mongoose from 'mongoose';
 
 // 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 actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
     const actions = await actionRepo.search(
         {
-            typeOf: { $eq: chevre.factory.actionType.CheckAction },
+            limit: 1,
+            // typeOf: { $eq: chevre.factory.actionType.CheckAction },
             // project: { id: { $eq: project.id } },
-            object: {
-                movieTickets: {
-                    identifier: { $eq: '0947524082' },
-                    serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
-                }
-            }
+            // object: {
+            //     movieTickets: {
+            //         identifier: { $eq: '0947524082' },
+            //         serviceOutput: { reservationFor: { id: { $eq: 'clhvvbpyn' } } }
+            //     }
+            // }
+            instrument: { transactionNumber: { $eq: 'x' } }
         },
         ['_id'],
         []

package/example/src/chevre/searchOrderAcceptedOffers.ts

@@ -5,6 +5,10 @@ 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);
 
@@ -16,10 +20,16 @@ async function main() {
             limit: 10,
             page: 1,
             project: { id: { $eq: project.id } },
-            orderNumber: { $eq: 'CIN3-0760465-8981560' },
-            acceptedOffers: { itemOffered: { typeOf: { $in: [chevre.factory.reservationType.EventReservation] } } }
+            orderNumber: { $eq: 'CIN7-9247770-0699829' },
+            acceptedOffers: {
+                itemOffered: {
+                    typeOf: { $in: [chevre.factory.reservationType.EventReservation] },
+                    reservationFor: { id: { $in: ['blpw1ew8f'] } },
+                    reservedTicket: { ticketedSeat: { seatNumber: { $in: ['A-26', 'xxx'] } } }
+                }
+            }
         },
-        ['itemOffered', 'id']
+        ['itemOffered', 'priceSpecification']
     );
     // tslint:disable-next-line:no-null-keyword
     console.dir(acceptedOffers, { depth: 1 });

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

@@ -71,61 +71,94 @@ async function main() {
         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: 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),
-                    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)
+                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;
+                        }
+
+                        // rl.close();
+                        resolve2();
+                    });
                 });
-                console.log('payment authorized.', authorizeResult.result);
 
                 resolve();
             } catch (error) {

package/lib/chevre/credentials.d.ts

@@ -16,6 +16,7 @@ export declare const credentials: {
         endpoint: string;
         refreshToken: string;
         timeout: number;
+        useFetch: boolean;
     };
     customSearch: {
         engineId: string;
@@ -23,6 +24,7 @@ export declare const credentials: {
     };
     gmo: {
         timeout: number;
+        useFetch: boolean;
     };
     lineNotify: {
         url: string;

package/lib/chevre/credentials.js

@@ -19,7 +19,8 @@ exports.credentials = {
         endpoint: process.env.COA_ENDPOINT,
         refreshToken: process.env.COA_REFRESH_TOKEN,
         // tslint:disable-next-line:no-magic-numbers
-        timeout: (typeof process.env.COA_TIMEOUT === 'string') ? Number(process.env.COA_TIMEOUT) : 20000
+        timeout: (typeof process.env.COA_TIMEOUT === 'string') ? Number(process.env.COA_TIMEOUT) : 20000,
+        useFetch: process.env.COA_USE_FETCH === '1'
     },
     customSearch: {
         engineId: process.env.CUSTOM_SEARCH_ENGINE_ID,
@@ -27,7 +28,8 @@ exports.credentials = {
     },
     gmo: {
         // tslint:disable-next-line:no-magic-numbers
-        timeout: (typeof process.env.GMO_TIMEOUT === 'string') ? Number(process.env.GMO_TIMEOUT) : 10000
+        timeout: (typeof process.env.GMO_TIMEOUT === 'string') ? Number(process.env.GMO_TIMEOUT) : 10000,
+        useFetch: process.env.GMO_USE_FETCH === '1'
     },
     lineNotify: {
         url: process.env.LINE_NOTIFY_URL,

package/lib/chevre/errorHandler.js

@@ -65,6 +65,9 @@ exports.handleMongoError = handleMongoError;
 function handleCOAError(error) {
     var _a;
     let handledError = error;
+    if (error.name === 'AbortError') {
+        handledError = new factory_1.errors.GatewayTimeout(`Gateway Timeout. name:${error.name} code:${error.code} message:${error.message}`);
+    }
     if (error.name === 'COAServiceError') {
         // error.requestOptions.uriを処理
         const uri = (_a = error.requestOptions) === null || _a === void 0 ? void 0 : _a.uri;

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

@@ -1,4 +1,5 @@
 import * as factory from '../factory';
+export declare const POINT_AWARD_IDENTIFIER_NAME = "pointAwardIdentifiers";
 export declare const AWARD_ACCOUNTS_IDENTIFIER_NAME = "awardAccounts";
 export type IMaskedCustomer = factory.order.ICustomer | Pick<factory.order.ICustomer, 'id' | 'typeOf'>;
 /**

package/lib/chevre/factory/order.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMaskedCustomer = exports.AWARD_ACCOUNTS_IDENTIFIER_NAME = void 0;
+exports.createMaskedCustomer = exports.AWARD_ACCOUNTS_IDENTIFIER_NAME = exports.POINT_AWARD_IDENTIFIER_NAME = void 0;
+exports.POINT_AWARD_IDENTIFIER_NAME = 'pointAwardIdentifiers';
 exports.AWARD_ACCOUNTS_IDENTIFIER_NAME = 'awardAccounts';
 const MASKED_PROFILE = '****';
 /**