@chevre/domain 22.9.0-alpha.99 → 22.9.0

package/example/src/chevre/offers/checkIncludedInCatalogCount.ts

@@ -0,0 +1,47 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const aggregateOfferRepo = await chevre.repository.AggregateOffer.createInstance(mongoose.connection);
+
+    const cursor = aggregateOfferRepo.getCursor(
+        {
+            'project.id': { $ne: excludedProject.id }
+            // _id: { $eq: 'blyk9q24f' }
+        },
+        {
+            _id: 1,
+            project: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const offer: Pick<chevre.factory.aggregateOffer.IAggregateOffer, 'id' | 'project'> = doc.toObject();
+
+        console.log('count?', offer.project.id, offer.id, i);
+        const result = await aggregateOfferRepo.countIncludedInDataCatalog({
+            id: { $eq: String(offer.id) }
+        });
+        console.log('result:', result, offer.project.id, offer.id, i);
+    });
+
+    console.log(i, 'docs checked');
+
+    const resultMax = await aggregateOfferRepo.maxIncludedInDataCatalogCount();
+    console.log('resultMax:', resultMax);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/offers/createSampleOffers.ts

@@ -0,0 +1,154 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const NUM_CREATE_OFFERS = 300;
+const NUM_CREATE_SUB_CATALOGS = 10;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregateOfferRepo = await chevre.repository.AggregateOffer.createInstance(mongoose.connection);
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+    const offerCatalogItemRepo = await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection);
+
+    const savingOffers: Omit<chevre.factory.unitPriceOffer.IUnitPriceOffer, 'id'>[] =
+        // tslint:disable-next-line:prefer-array-literal
+        [...Array(NUM_CREATE_OFFERS)].map<Omit<chevre.factory.unitPriceOffer.IUnitPriceOffer, 'id'>>((__, i) => {
+            const identifier = `sampleFreeOffer${i}`;
+            const priceSpecification: chevre.factory.unitPriceOffer.IUnitPriceOfferPriceSpecification = {
+                typeOf: chevre.factory.priceSpecificationType.UnitPriceSpecification,
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                valueAddedTaxIncluded: true,
+                price: 0,
+                referenceQuantity: {
+                    value: 1,
+                    typeOf: 'QuantitativeValue',
+                    unitCode: chevre.factory.unitCode.C62
+                },
+                accounting: {
+                    typeOf: 'Accounting',
+                    accountsReceivable: 0
+                }
+            };
+
+            return {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                typeOf: chevre.factory.offerType.Offer,
+                identifier,
+                description: { en: identifier, ja: identifier },
+                alternateName: { ja: identifier },
+                name: { en: identifier, ja: identifier },
+                availability: chevre.factory.itemAvailability.InStock,
+                availableAtOrFrom: [
+                    { id: '51qbjcfr72h62m06vtv5kkhgje' }
+                ],
+                itemOffered: { typeOf: chevre.factory.product.ProductType.EventService },
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                priceSpecification
+            };
+        });
+    const saveOfferResult = await aggregateOfferRepo.upsertByIdentifier(savingOffers);
+    console.log('saveOfferResult:', saveOfferResult);
+
+    const offerIds: string[] = (Array.isArray(saveOfferResult?.modifiedOffers)) ? saveOfferResult.modifiedOffers.map(({ id }) => id) : [];
+    const catalogIdentifier = 'sampleFreeOffersCatalog';
+    const savingOfferCatalog: chevre.factory.offerCatalog.IOfferCatalog = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: 'OfferCatalog',
+        identifier: catalogIdentifier,
+        description: { en: catalogIdentifier, ja: catalogIdentifier },
+        name: { en: catalogIdentifier, ja: catalogIdentifier },
+        itemListElement: offerIds.map((id) => ({ id, typeOf: chevre.factory.offerType.Offer })),
+        itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+    };
+    const saveCatalogResult = await offerCatalogRepo.saveByIdentifier(savingOfferCatalog);
+    console.log('saveCatalogResult:', saveCatalogResult);
+
+    const productId = 'sampleFreeEventService';
+    const savingProduct: chevre.factory.product.IProduct & {
+        offers?: never;
+    } = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: chevre.factory.product.ProductType.EventService,
+        name: { en: productId, ja: productId },
+        productID: productId,
+        hasOfferCatalog: {
+            typeOf: 'OfferCatalog',
+            itemListElement: [{ id: saveCatalogResult.id }]
+        }
+    };
+    const saveProductResult = await productRepo.upsertManyByProductId([{
+        $set: savingProduct
+    }]);
+    console.log('saveProductResult:', saveProductResult);
+
+    // 以下サブカタログ
+    const offerIds4subCatalog: string[] = (Array.isArray(saveOfferResult?.modifiedOffers))
+        // tslint:disable-next-line:no-magic-numbers
+        ? saveOfferResult.modifiedOffers.slice(0, 100)
+            .map(({ id }) => id) :
+        [];
+    const savingSubOfferCatalogs: chevre.factory.offerCatalog.IOfferCatalog[] =
+        // tslint:disable-next-line:prefer-array-literal
+        [...Array(NUM_CREATE_SUB_CATALOGS)].map<chevre.factory.offerCatalog.IOfferCatalog>((__, i) => {
+            const subCatalogIdentifier = `sampleFreeOffersSubCatalog${i}`;
+
+            return {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                typeOf: 'OfferCatalog',
+                identifier: subCatalogIdentifier,
+                description: { en: subCatalogIdentifier, ja: subCatalogIdentifier },
+                name: { en: subCatalogIdentifier, ja: subCatalogIdentifier },
+                itemListElement: offerIds4subCatalog.map((id) => ({ id, typeOf: chevre.factory.offerType.Offer })),
+                itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+            };
+        });
+    const saveSubCatalogResult = await offerCatalogItemRepo.upsertManyByIdentifier(savingSubOfferCatalogs.map((savingSubOfferCatalog) => {
+        return {
+            $set: savingSubOfferCatalog
+        };
+    }));
+    console.log('saveSubCatalogResult:', saveSubCatalogResult);
+
+    const subCatalogIds: string[] =
+        (Array.isArray(saveSubCatalogResult?.modifiedCatalogs)) ? saveSubCatalogResult.modifiedCatalogs.map(({ id }) => id) : [];
+    const catalogBySubCatalogIdentifier = 'sampleFreeOffersCatalogBySub';
+    const savingOfferCatalogBySubCatalog: chevre.factory.offerCatalog.IOfferCatalog = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: 'OfferCatalog',
+        identifier: catalogBySubCatalogIdentifier,
+        description: { en: catalogBySubCatalogIdentifier, ja: catalogBySubCatalogIdentifier },
+        name: { en: catalogBySubCatalogIdentifier, ja: catalogBySubCatalogIdentifier },
+        itemListElement: subCatalogIds.map((id) => ({ id, typeOf: 'OfferCatalog' })),
+        itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+    };
+    const saveCatalogBySubResult = await offerCatalogRepo.saveByIdentifier(savingOfferCatalogBySubCatalog);
+    console.log('saveCatalogBySubResult:', saveCatalogBySubResult);
+
+    const productIdBySubCatalog = 'sampleFreeEventServiceBySub';
+    const savingProductBySubCatalog: chevre.factory.product.IProduct & {
+        offers?: never;
+    } = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: chevre.factory.product.ProductType.EventService,
+        name: { en: productIdBySubCatalog, ja: productIdBySubCatalog },
+        productID: productIdBySubCatalog,
+        hasOfferCatalog: {
+            typeOf: 'OfferCatalog',
+            itemListElement: [{ id: saveCatalogBySubResult.id }]
+        }
+    };
+    const saveProductBySubCatalogResult = await productRepo.upsertManyByProductId([{
+        $set: savingProductBySubCatalog
+    }]);
+    console.log('saveProductBySubCatalogResult:', saveProductBySubCatalogResult);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/offers/projectItemListElement.ts

@@ -0,0 +1,54 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const offerCatalogItemRepo = await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection);
+
+    // startTime = process.hrtime();
+    // result = await offerCatalogRepo.searchItemListElementById({
+    //     id: 'blpc770py',
+    //     limit: 100,
+    //     page: 1
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    // console.log('result:', result);
+
+    startTime = process.hrtime();
+    result = await offerCatalogRepo.sliceItemListElementById({
+        id: 'blpc770py',
+        limit: 10,
+        page: 1
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log('result:', result);
+
+    startTime = process.hrtime();
+    result = await offerCatalogItemRepo.sliceItemListElementById({
+        id: '65669285c7b871dba60ed72e',
+        limit: 10,
+        page: 1
+    });
+    diff = process.hrtime(startTime);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+    console.log('result:', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{searchOfferCatalogItemAvailability.ts → offers/searchAvaialbleAppliesToMovieTicketByOfferCatalogId.ts}

@@ -1,7 +1,9 @@
 // tslint:disable:no-console
 import * as mongoose from 'mongoose';
 
-import { chevre } from '../../../lib/index';
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
 
 // const PROJECT_ID = process.env.PROJECT_ID;
 mongoose.Model.on('index', (...args) => {
@@ -9,29 +11,39 @@ mongoose.Model.on('index', (...args) => {
 });
 
 async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const eventSeriesRepo = await chevre.repository.EventSeries.createInstance(mongoose.connection);
     const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
     const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
     const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
 
-    const result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+    startTime = process.hrtime();
+    result = await (await chevre.service.offer.createService()).event.searchOfferAppliesToMovieTicket({
         event: {
-            id: 'bm0f0cadh'
+            id: 'cm8dwc74k'
         },
         limit: 10,
         page: 1,
-        availableAtOrFrom: { id: '3eo6okferrsdpfd9j2ce1iv9k7' },
-        options: { considerUnacceptedPaymentMethod: true }
+        store: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+        onlyValid: true,
+        options: { useIncludeInDataCatalog: false }
     })({
         event: eventRepo,
+        eventSeries: eventSeriesRepo,
         offer: offerRepo,
         offerCatalog: offerCatalogRepo,
         product: productRepo
     });
+    diff = process.hrtime(startTime);
     console.log(result);
     console.log(result.length);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
 }
 
 main()

package/example/src/chevre/offers/searchByOfferCatalogIdWithSortIndex.ts

@@ -0,0 +1,44 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
+
+    const result = await offerRepo.searchByOfferCatalogIdWithSortIndex({
+        offerCatalog: { id: '65669285c7b871dba60ed72e', isOfferCatalogItem: true },
+        // availableAtOrFrom: { id: params.store?.id },
+        // unacceptedPaymentMethod: params.unacceptedPaymentMethod,
+        excludeAppliesToMovieTicket: false,
+        priceSpecification: {
+            appliesToMovieTicket: {
+                // serviceOutput: {
+                //     typeOf: {
+                //         ...(typeof req.query.priceSpecification?.appliesToMovieTicket?.serviceOutput?.typeOf?.$eq === 'string')
+                //             ? { $eq: req.query.priceSpecification.appliesToMovieTicket.serviceOutput.typeOf.$eq }
+                //             : undefined
+                //     }
+                // },
+                serviceType: {
+                    $exists: false
+                }
+            }
+        },
+        onlyValid: false,
+        useIncludeInDataCatalog: true,
+        limit: 10,
+        page: 1
+    });
+    console.log('result:', result);
+    console.log(result.offers.map(({ name }) => name));
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/offers/searchOfferCatalogItemAvailability.ts

@@ -0,0 +1,68 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+// const PROJECT_ID = process.env.PROJECT_ID;
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+
+    // startTime = process.hrtime();
+    // result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+    //     event: {
+    //         id: 'cm8dwc74j'
+    //     },
+    //     limit: 10,
+    //     page: 1,
+    //     availableAtOrFrom: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+    //     options: { considerUnacceptedPaymentMethod: true, useIncludeInDataCatalog: true }
+    // })({
+    //     event: eventRepo,
+    //     offer: offerRepo,
+    //     offerCatalog: offerCatalogRepo,
+    //     product: productRepo
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log(result);
+    // console.log(result.length);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+
+    startTime = process.hrtime();
+    result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+        event: {
+            id: 'cm8dwc74j'
+        },
+        limit: 10,
+        page: 1,
+        availableAtOrFrom: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+        options: { considerUnacceptedPaymentMethod: true, useIncludeInDataCatalog: false }
+    })({
+        event: eventRepo,
+        offer: offerRepo,
+        offerCatalog: offerCatalogRepo,
+        product: productRepo
+    });
+    diff = process.hrtime(startTime);
+    console.log(result);
+    console.log(result.length);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/reIndex.ts

@@ -11,7 +11,7 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.AggregateOffer.createInstance(mongoose.connection);
+    await chevre.repository.Note.createInstance(mongoose.connection);
     console.log('success!');
 }
 

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

@@ -0,0 +1,76 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+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
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
+        client,
+        mongoose.connection
+    );
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': { $ne: excludedProject.id },
+            startDate: {
+                $gte: moment()
+                    .add(-1, 'days')
+                    .toDate()
+            },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
+            // _id: { $eq: 'blyk9q24f' }
+        },
+        {
+            _id: 1,
+            // offers: 1,
+            startDate: 1,
+            project: 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' | 'startDate' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'conflicted?', event.project.id, event.typeOf, event.id, event.startDate, i);
+        await stockHolderRepo.checkIfConflicted({
+            eventId: event.id,
+            startDate: event.startDate
+        });
+    });
+
+    console.log(i, 'events checked');
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -0,0 +1,100 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+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
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
+    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(
+        client,
+        mongoose.connection
+    );
+
+    const setting = await settingRepo.findOne(
+        { project: { id: { $eq: '*' } } },
+        ['useMongoAsStockHolderProjects']
+    );
+    const useMongoAsStockHolderProjects =
+        (Array.isArray(setting?.useMongoAsStockHolderProjects)) ? setting?.useMongoAsStockHolderProjects : [];
+
+    if (useMongoAsStockHolderProjects.length === 0) {
+        return;
+    }
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': {
+                $eq: 'toei-production',
+                $in: useMongoAsStockHolderProjects
+            },
+            startDate: {
+                $gte: moment()
+                    .add(0, 'days')
+                    .toDate()
+            },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent }
+            // _id: { $eq: 'blyk9q24f' }
+        },
+        {
+            _id: 1,
+            // offers: 1,
+            startDate: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let redisKeyCount = 0;
+    const eventsWithRedis: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent,
+            'id' | 'startDate' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log('redisKeyExists?', event.project.id, event.typeOf, event.id, event.startDate, i);
+        const redisKeyExists = await stockHolderRepo.redisKeyExists({
+            eventId: event.id,
+            startDate: event.startDate
+        });
+        console.log('redisKeyExists:', redisKeyExists, event.project.id, event.typeOf, event.id, event.startDate, i);
+
+        if (redisKeyExists) {
+            redisKeyCount += 1;
+            eventsWithRedis.push(event.id);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(redisKeyCount, 'redisKeys found');
+    console.log('useMongoAsStockHolderProjects:', useMongoAsStockHolderProjects);
+    // console.log('eventsWithRedis:', eventsWithRedis);
+}
+
+main()
+    .then()
+    .catch(console.error);