@chevre/domain 23.0.0-alpha.9 → 23.0.0

package/example/src/chevre/assetTransaction/processReserve.ts

@@ -6,8 +6,16 @@ import * as redis from 'redis';
 import { chevre } from '../../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_ID, OFFER_ID, APPLICATION_ID, OFFER_TOKEN } = process.env;
 
+// tslint:disable-next-line:max-func-body-length
 async function main() {
+    if (typeof EVENT_ID !== 'string'
+        || typeof OFFER_ID !== 'string'
+        || typeof APPLICATION_ID !== 'string') {
+        throw new Error('environment variables required');
+    }
+
     const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
         socket: {
             port: Number(<string>process.env.REDIS_PORT),
@@ -21,59 +29,113 @@ async function main() {
     const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
         connection: mongoose.connection
     });
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-
     const { transactionNumber } = await transactionNumberRepo.publishByTimestamp({ startDate: new Date() });
     const provider: chevre.factory.reservation.IProvider = {
         id: '59d20831e53ebc2b4e774466',
         typeOf: chevre.factory.organizationType.Corporation
     };
-    const reserveTransaction = await assetTransactionRepo.start<chevre.factory.assetTransactionType.Reserve>({
-        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-        typeOf: chevre.factory.assetTransactionType.Reserve,
-        transactionNumber,
-        agent: { ...provider, name: 'sample agent name' },
-        object: {
-            provider,
-            reservationNumber: transactionNumber,
-            reservationStatus: chevre.factory.reservationStatusType.ReservationPending,
-            disablePendingReservations: true,
-            useHoldStockByTransactionNumber: true,
-            typeOf: chevre.factory.reservationType.ReservationPackage
-        },
-        expires: moment()
-            .add(1, 'minute')
-            .toDate()
-    });
-    let cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
-    cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
 
-    let transaction = await assetTransactionRepo.findById<chevre.factory.assetTransactionType.Reserve>(
+    const { transaction } = await (await chevre.service.assetTransaction.createService()).reserve.start(
         {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
             typeOf: chevre.factory.assetTransactionType.Reserve,
-            id: reserveTransaction.id
+            transactionNumber,
+            agent: { ...provider, name: 'sample agent name' },
+            object: {
+                acceptedOffer: [{
+                    /**
+                     * オファーID
+                     */
+                    id: OFFER_ID,
+                    /**
+                     * アイテム情報
+                     * 予約の詳細指定など
+                     */
+                    itemOffered: {
+                        serviceOutput: {
+                            typeOf: chevre.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                /**
+                                 * チケット識別子
+                                 * 指定された場合、決済カードの対象チケット識別子と関連付けされます
+                                 * /^[0-9a-zA-Z]{8,16}$/
+                                 */
+                                // identifier?: string;
+                                // issuedBy?: ReservationFactory.IUnderName;
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: chevre.factory.placeType.Seat,
+                                    seatNumber: 'A-01',
+                                    seatRow: '',
+                                    seatSection: 'Default'
+                                }
+                            }
+                        }
+                    }
+                }],
+                reservationFor: {
+                    id: EVENT_ID,
+                    offers: {
+                        token: OFFER_TOKEN,
+                        identifier: 'LegacyReservation'
+                    }
+                }
+            },
+            expires: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(5, 'seconds')
+                .toDate(),
+            validateEvent: false,
+            validateEventOfferPeriod: true,
+            validateAppliesToMovieTicket: true,
+            instrument: [],
+            availableAtOrFrom: { id: APPLICATION_ID }
+            // stockHoldUntilDaysAfterEventEnd: STOCK_HOLD_UNTIL_DAYS_AFTER_EVENT_END
         },
-        ['status', 'transactionNumber', 'project', 'typeOf']
-    );
-    console.log('transaction:', transaction);
-
-    transaction = await assetTransactionRepo.findByTransactionNumber<chevre.factory.assetTransactionType.Reserve>(
+        { maxReservationGracePeriodInDays: 93 }
+    )(
         {
-            typeOf: chevre.factory.assetTransactionType.Reserve,
-            transactionNumber
+            advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
+            project: await chevre.repository.Project.createInstance(mongoose.connection),
+            stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
+            event: await chevre.repository.Event.createInstance(mongoose.connection),
+            eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
+            issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
+            memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
+            offer: await chevre.repository.Offer.createInstance(mongoose.connection),
+            offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
+            offerCatalogItem: await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection),
+            offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(redisClient),
+            paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
+            priceSpecification: await chevre.repository.PriceSpecification.createInstance(mongoose.connection),
+            product: await chevre.repository.Product.createInstance(mongoose.connection),
+            productOffer: await chevre.repository.ProductOffer.createInstance(mongoose.connection),
+            seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
+            setting: await chevre.repository.Setting.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection)
         },
-        ['status']
+        new chevre.settings.Settings({
+            abortedTasksWithoutReport: [],
+            numTryConfirmReserveTransaction: 10,
+            deliverOrderLimit: 1,
+            coa: { timeout: 20000 },
+            gmo: {
+                timeout: 5000,
+                timeoutBackground: 5000,
+                useFetch: true
+            },
+            movieticketReserve: {
+                timeout: 5000,
+                timeoutCheck: 5000,
+                minIntervalBetweenPayAndRefund: 1,
+                credentialsExpireInSeconds: 300
+            },
+            // useAssetTransactionSyncProcessing: process.env.USE_ASSET_TRANSACTION_SYNC_PROCESSING === '1',
+            useExperimentalFeature: false
+        })
     );
     console.log('transaction:', transaction);
-
 }
 
 main()

package/example/src/chevre/categoryCode/checkUniqueness.ts

@@ -0,0 +1,69 @@
+// tslint:disable:no-console no-magic-numbers
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
+
+    const cursor = categoryCodeRepo.getCursor(
+        {
+            // _id: { $eq: '68f5d32176b5f6b689ff24a6' },
+            // 'project.id': { $eq: project.id },
+            // 'additionalProperty.name': { $exists: true, $eq: PROPERTY_NAME }
+            'inCodeSet.identifier': { $ne: chevre.factory.movieTicketType.CategorySetIdentifier.MovieTicketType }
+        },
+        {
+            _id: 1,
+            codeValue: 1,
+            project: 1,
+            inCodeSet: 1,
+            name: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let notUniqueCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const categoryCode: Pick<
+            chevre.factory.categoryCode.ICategoryCode,
+            'codeValue' | 'id' | 'inCodeSet' | 'name' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        // console.log('unique?', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
+
+        const sameCodeValues = (await categoryCodeRepo.projectCategoryCodeFields(
+            {
+                project: { id: { $eq: categoryCode.project.id } },
+                codeValue: { $eq: categoryCode.codeValue }
+                // inCodeSet:{identifier:{$}}
+            },
+            ['codeValue', 'inCodeSet']
+        )).filter(
+            ({ inCodeSet }) => <unknown>inCodeSet.identifier !== chevre.factory.movieTicketType.CategorySetIdentifier.MovieTicketType
+        );
+        // console.log(sameCodeValues, 'sameCodeValues found', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
+
+        const isUnique = sameCodeValues.length === 1;
+        if (isUnique) {
+            // console.log(
+            //     'unique.', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
+        } else {
+            notUniqueCount += 1;
+            console.log('not unique.', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(notUniqueCount, 'docs not unique');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/event/checkEventAdditionalPropertyUniqueness.ts

@@ -0,0 +1,108 @@
+// tslint:disable:no-console no-magic-numbers
+import { webcrypto } from 'crypto';
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const PROPERTY_NAME = 'createId';
+
+async function additionalProperty2identifier(raw: string) {
+    const data = new TextEncoder().encode(raw);
+    const hashBuffer = await webcrypto.subtle.digest('SHA-256', data);
+    const bytes = Array.from(new Uint8Array(hashBuffer));
+
+    // 0-9 + a-z の36文字セット
+    const chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+    // tslint:disable-next-line:no-magic-numbers
+    const id = bytes.map((b) => chars[b % 36])
+        .join('');
+
+    // tslint:disable-next-line:no-magic-numbers
+    return id.slice(0, 16);
+}
+
+const identifierMustMatch = /^[0-9a-zA-Z]+$/;
+function validateIdentifier(identifier: string) {
+    if (!identifierMustMatch.test(identifier)) {
+        throw new Error(`not matched ${identifier}`);
+    }
+
+    if (identifier.length < 8 || identifier.length > 32) {
+        throw new Error(`invalid length ${identifier}`);
+    }
+}
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // _id: { $eq: '68f5d32176b5f6b689ff24a6' },
+            // 'project.id': { $eq: project.id },
+            'additionalProperty.name': { $exists: true, $eq: PROPERTY_NAME },
+            startDate: {
+                $gte: moment()
+                    .add(-1, 'days')
+                    .toDate()
+            }
+        },
+        {
+            _id: 1,
+            startDate: 1,
+            project: 1,
+            identifier: 1,
+            additionalProperty: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent,
+            'id' | 'identifier' | 'startDate' | 'project' | 'additionalProperty' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', event.project.id, event.id, event.startDate, i);
+        const eventIdentifier = event.identifier;
+        const additionalPropertyValue = event.additionalProperty?.find(({ name }) => name === PROPERTY_NAME)?.value;
+        if (typeof additionalPropertyValue !== 'string') {
+            throw new Error('additionalPropertyValue not found');
+        }
+        const identifierMustBe = await additionalProperty2identifier(additionalPropertyValue);
+        validateIdentifier(identifierMustBe);
+
+        // const alreadyMigrated = typeof eventIdentifier === 'string' && eventIdentifier.length > 0;
+        // const alreadyMigrated = typeof eventIdentifier === 'string' && eventIdentifier === identifierMustBe;
+
+        console.log(
+            'checking...',
+            identifierMustBe, event.project.id, eventIdentifier, additionalPropertyValue, event.id, event.startDate, i);
+        const existingEvents = await eventRepo.findByAdditionalProperty(
+            {
+                // limit: 2,
+                // page: 1,
+                project: { id: event.project.id },
+                additionalProperty: { name: PROPERTY_NAME, value: additionalPropertyValue }
+            }
+        );
+        console.log('existingEvents found.', existingEvents.length, existingEvents);
+        if (existingEvents.length !== 1 || existingEvents[0]._id !== event.id) {
+            throw new Error(`not unique! ${event.id} ${additionalPropertyValue}`);
+        }
+    });
+
+    console.log(i, 'events checked');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/event/migrateEventAdditionalProperty2identifier.ts

@@ -0,0 +1,121 @@
+// tslint:disable:no-console no-magic-numbers
+import { webcrypto } from 'crypto';
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const PROPERTY_NAME = 'createId';
+
+async function additionalProperty2identifier(raw: string) {
+    const data = new TextEncoder().encode(raw);
+    const hashBuffer = await webcrypto.subtle.digest('SHA-256', data);
+    const bytes = Array.from(new Uint8Array(hashBuffer));
+
+    // 0-9 + a-z の36文字セット
+    const chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+    // tslint:disable-next-line:no-magic-numbers
+    const id = bytes.map((b) => chars[b % 36])
+        .join('');
+
+    // tslint:disable-next-line:no-magic-numbers
+    return id.slice(0, 16);
+}
+
+const identifierMustMatch = /^[0-9a-zA-Z]+$/;
+function validateIdentifier(identifier: string) {
+    if (!identifierMustMatch.test(identifier)) {
+        throw new Error(`not matched ${identifier}`);
+    }
+
+    if (identifier.length < 8 || identifier.length > 32) {
+        throw new Error(`invalid length ${identifier}`);
+    }
+}
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // _id: { $eq: '68f5d32176b5f6b689ff24a6' },
+            // 'project.id': { $eq: project.id },
+            // startDate: {
+            //     $lte: moment('2025-05-01T10:00:00Z')
+            //         .toDate()
+            // },
+            'additionalProperty.name': { $exists: true, $eq: PROPERTY_NAME }
+        },
+        {
+            _id: 1,
+            startDate: 1,
+            project: 1,
+            identifier: 1,
+            additionalProperty: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent,
+            'id' | 'identifier' | 'startDate' | 'project' | 'additionalProperty' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', event.project.id, event.id, event.startDate, i);
+        const eventIdentifier = event.identifier;
+        const additionalPropertyValue = event.additionalProperty?.find(({ name }) => name === PROPERTY_NAME)?.value;
+        if (typeof additionalPropertyValue !== 'string') {
+            throw new Error('additionalPropertyValue not found');
+        }
+        const identifierMustBe = await additionalProperty2identifier(additionalPropertyValue);
+        validateIdentifier(identifierMustBe);
+
+        const alreadyMigrated = typeof eventIdentifier === 'string' && eventIdentifier.length > 0;
+        // const alreadyMigrated = typeof eventIdentifier === 'string' && eventIdentifier === identifierMustBe;
+
+        if (alreadyMigrated) {
+            validateIdentifier(eventIdentifier);
+            // 追加特性から生成された識別子に一致するはず
+            if (identifierMustBe !== eventIdentifier) {
+                throw new Error(`${identifierMustBe} !== ${eventIdentifier} ${event.id}, ${i}`);
+            }
+            console.log(
+                'already migrated.', event.project.id, eventIdentifier, additionalPropertyValue, event.id, event.startDate, i);
+        } else {
+            console.log(
+                'updating...',
+                identifierMustBe, event.project.id, eventIdentifier, additionalPropertyValue, event.id, event.startDate, i);
+            await eventRepo.updatePartiallyById({
+                project: { id: event.project.id },
+                id: event.id,
+                attributes: {
+                    typeOf: event.typeOf,
+                    ...{
+                        identifier: identifierMustBe
+                    }
+                }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.',
+                event.project.id, eventIdentifier, event.id, event.startDate, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/event/updateSellerMakesOffersByIdentifier.ts

@@ -0,0 +1,106 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_IDENTTIFIER } = process.env;
+
+async function main() {
+    if (typeof EVENT_IDENTTIFIER !== 'string') {
+        throw new Error('environment variables required');
+    }
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventSellerMakesOfferRepo = await chevre.repository.EventSellerMakesOffer.createInstance(mongoose.connection);
+    const availabilityEnds = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const availabilityStarts = moment('2025-10-23T15:00:00.000Z')
+        .toDate();
+    const validFrom = moment('2025-10-12T15:00:00.000Z')
+        .toDate();
+    const validThrough = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const result = await eventSellerMakesOfferRepo.updateSellerMakesOffersByEventIdentifier([
+        {
+            $set: {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                identifier: EVENT_IDENTTIFIER,
+                offers: {
+                    seller: {
+                        makesOffer: [
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '3eo6okferrsdpfd9j2ce1iv9k7'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '51qbjcfr72h62m06vtv5kkhgje'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '5h3gs22mu9j3ok7o63uog9o9i3'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '66e7p2g713675v96nrhdm975kg'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: '7divuoimobsfgq95tp1csorjqq'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            },
+                            {
+                                typeOf: chevre.factory.offerType.Offer,
+                                availableAtOrFrom: {
+                                    id: 'ckevmf3fueqcunnideu6artt'
+                                },
+                                availabilityEnds,
+                                availabilityStarts,
+                                validFrom,
+                                validThrough
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    ]);
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/offerCatalog/updateManyOfferCatalogsByIds.ts

@@ -0,0 +1,49 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const PROJECT_ID = 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 offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+
+    try {
+        await offerCatalogRepo.updateManyOfferCatalogsByIds({
+            id: {
+                $in: ['xxx']
+            },
+            itemOffered: {
+                typeOf: {
+                    $eq: chevre.factory.product.ProductType.EventService
+                }
+            },
+            $push: {
+                itemListElement: {
+                    $each: [{ id: 'xxx', typeOf: chevre.factory.offerType.Offer }],
+                    $slice: 300
+                }
+            },
+            $pull: {
+                itemListElement: {
+                    $elemMatch: {
+                        id: {
+                            $in: ['xxx']
+                        }
+                    }
+                }
+            }
+        });
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/paymentServices/findPaymentServices.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-implicit-dependencies no-console
+import * as  mongoose from 'mongoose';
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    try {
+        await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+        const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+        const limit = 10;
+        const page = 1;
+        const docs = await paymentServiceRepo.projectFields(
+            {
+                limit,
+                page,
+                project: { id: { $eq: project.id } },
+                availableChannel: { id: { $eq: 'xxx' } },
+                id: { $eq: 'xxx' }
+            },
+            ['availableChannel', 'productID']
+        );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(docs, { depth: null });
+        console.log(docs.length, 'docs found');
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);