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

package/example/src/chevre/aggregateEventReservation.ts

@@ -22,7 +22,7 @@ async function main() {
         id: String(process.env.EVENT_ID)
     })({
         event: new chevre.repository.Event(mongoose.connection),
-        eventAvailability: new chevre.repository.itemAvailability.ScreeningEvent(client),
+        stockHolder: new chevre.repository.StockHolder(client),
         offer: new chevre.repository.Offer(mongoose.connection),
         offerCatalog: new chevre.repository.OfferCatalog(mongoose.connection),
         offerRateLimit: new chevre.repository.rateLimit.Offer(client),

package/example/src/chevre/countDelayedTasks.ts

@@ -0,0 +1,17 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+export async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const count = await taskRepo.countDelayedTasks({ delayInSeconds: 60 });
+    console.log('count:', count);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/countDelayedTransactions.ts

@@ -0,0 +1,60 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+export async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+
+    for (const typeOf of [
+        chevre.factory.transactionType.PlaceOrder,
+        chevre.factory.transactionType.ReturnOrder,
+        chevre.factory.transactionType.MoneyTransfer
+    ]) {
+        const count = await transactionRepo.count({
+            typeOf,
+            statuses: [
+                chevre.factory.transactionStatusType.Canceled,
+                chevre.factory.transactionStatusType.Confirmed,
+                chevre.factory.transactionStatusType.Expired
+            ],
+            tasksExportationStatuses: [
+                chevre.factory.transactionTasksExportationStatus.Exporting,
+                chevre.factory.transactionTasksExportationStatus.Unexported
+            ],
+            endThrough: new Date()
+        });
+        console.log('count:', count, typeOf);
+    }
+
+    for (const typeOf of [
+        chevre.factory.assetTransactionType.CancelReservation,
+        chevre.factory.assetTransactionType.MoneyTransfer,
+        chevre.factory.assetTransactionType.Pay,
+        chevre.factory.assetTransactionType.Refund,
+        chevre.factory.assetTransactionType.RegisterService,
+        chevre.factory.assetTransactionType.Reserve
+    ]) {
+        const count = await assetTransactionRepo.count({
+            typeOf,
+            statuses: [
+                chevre.factory.transactionStatusType.Canceled,
+                chevre.factory.transactionStatusType.Confirmed,
+                chevre.factory.transactionStatusType.Expired
+            ],
+            tasksExportationStatuses: [
+                chevre.factory.transactionTasksExportationStatus.Exporting,
+                chevre.factory.transactionTasksExportationStatus.Unexported
+            ],
+            endThrough: new Date()
+        });
+        console.log('count:', count, typeOf);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/countMoneyTransferTransaction.ts

@@ -0,0 +1,36 @@
+// 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) };
+
+// tslint:disable-next-line:max-func-body-length
+export async function main() {
+    const now = new Date();
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+
+    const transactions = await transactionRepo.search<chevre.factory.transactionType.MoneyTransfer>(
+        {
+            project: { id: { $eq: project.id } },
+            typeOf: chevre.factory.transactionType.MoneyTransfer,
+            statuses: [chevre.factory.transactionStatusType.Confirmed],
+            startFrom: moment(now)
+                .add(-1, 'year')
+                .toDate(),
+            startThrough: now,
+            inclusion: ['_id', 'startDate', 'typeOf', 'object'],
+            exclusion: []
+        }
+    );
+    const count = transactions.filter((t) => t.object.description === '受け取り')
+        .length;
+    console.log('transactions found', count);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createManyEventsIfNotExist.ts

@@ -197,7 +197,10 @@ async function main() {
         }
     ]);
     console.log(result);
-    console.log('upsertedIds:', (Array.isArray(result?.result.upserted)) ? result?.result.upserted.map((u: any) => u._id) : []);
+    console.log('upsertedIds:', (Array.isArray(result?.getUpsertedIds()))
+        ? result?.getUpsertedIds()
+            .map((u: any) => u._id)
+        : []);
 }
 
 main()

package/example/src/chevre/lockStockHolder.ts

@@ -0,0 +1,48 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+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() {
+    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 startDate = moment('2023-04-18T00:00:00Z');
+
+    const stockHolderRepo = new chevre.repository.StockHolder(client);
+    await stockHolderRepo.lock({
+        eventId: 'sampleEventId',
+        startDate: startDate.toDate(),
+        offers: [
+            {
+                seatSection: 'sampleSeatSection',
+                seatNumber: 'sampleSeatNumber'
+            },
+            {
+                seatSection: 'sampleSeatSection1',
+                seatNumber: 'sampleSeatNumber1'
+            }
+        ],
+        expires: moment(startDate)
+            .add(1, 'month')
+            .toDate(),
+        holder: 'sampleStockHolder'
+    });
+    console.log('locked');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/migrateOrderAdditionalProperties.ts

@@ -0,0 +1,85 @@
+// 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 EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            orderDate: {
+                $gte: moment()
+                    .add(-1, 'months')
+                    .toDate()
+            }
+        },
+        {
+            paymentMethods: 1,
+            project: 1,
+            orderDate: 1
+        }
+    );
+    console.log('movies found');
+
+    const additionalPropertyNames: string[] = [];
+    const projectIds: string[] = [];
+    const unexpextedprojectIds: string[] = [];
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: chevre.factory.order.IOrder = doc.toObject();
+
+        const additionalPropertyNamesOnOrder = order.paymentMethods.reduce<string[]>(
+            (a, b) => {
+                if (Array.isArray(b.additionalProperty)) {
+                    return [...a, ...b.additionalProperty.map((p) => p.name)];
+                } else {
+                    return a;
+                }
+            },
+            []
+        );
+        if (Array.isArray(additionalPropertyNamesOnOrder) && additionalPropertyNamesOnOrder.length > 0) {
+            console.log(
+                additionalPropertyNamesOnOrder.join(','),
+                additionalPropertyNamesOnOrder.length,
+                'additionalPropertyNamesOnOrder found',
+                order.project.id,
+                order.id,
+                order.orderDate
+            );
+            additionalPropertyNames.push(...additionalPropertyNamesOnOrder);
+            projectIds.push(order.project.id);
+            additionalPropertyNamesOnOrder.forEach((name) => {
+                if (!name.match(/^[a-zA-Z]*$/)) {
+                    // throw new Error(`not matched ${creativeWork.project.id} ${creativeWork.id}`);
+                    unexpextedprojectIds.push(order.project.id);
+                }
+                // tslint:disable-next-line:no-magic-numbers
+                if (name.length < 5) {
+                    // throw new Error(`length matched ${creativeWork.project.id} ${creativeWork.id} ${name}`);
+                    unexpextedprojectIds.push(order.project.id);
+                }
+            });
+        }
+    });
+    console.log(i, 'orders checked');
+    console.log('additionalPropertyNames:', [...new Set(additionalPropertyNames)]);
+    console.log('projectIds:', [...new Set(projectIds)]);
+    console.log('unexpextedprojectIds:', [...new Set(unexpextedprojectIds)]);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateStockHolderKeys.ts

@@ -0,0 +1,89 @@
+// 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 EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+async function main() {
+    const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+        socket: {
+            host: process.env.REDIS_HOST,
+            port: Number(process.env.REDIS_PORT)
+        },
+        password: process.env.REDIS_KEY
+    });
+    await client.connect();
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const stockHolderRepo = new chevre.repository.StockHolder(client);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent },
+            startDate: {
+                $gte: moment('2023-04-23T15:00:00Z')
+                    .toDate()
+            }
+            // _id: { $eq: 'al6aff83w' }
+        },
+        {
+            // _id: 1,
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: chevre.factory.event.screeningEvent.IEvent = doc.toObject();
+
+        const oldKey = chevre.repository.StockHolder.GET_KEY({
+            eventId: event.id,
+            startDate: new Date()
+        });
+        const newKey = chevre.repository.StockHolder.GET_KEY({
+            eventId: event.id,
+            startDate: moment(event.startDate)
+                .toDate()
+        });
+
+        let conflicted = false;
+        try {
+            await stockHolderRepo.checkIfConflicted({
+                key: newKey,
+                eventId: event.id
+            });
+        } catch (error) {
+            conflicted = true;
+        }
+
+        if (conflicted) {
+            updateCount += 1;
+            await stockHolderRepo.migrateKey({
+                key: newKey,
+                eventId: event.id
+            });
+            console.log(
+                'updated...', event.project.id, event.id, event.startDate, i);
+        } else {
+            console.log(
+                'already exist...', event.project.id, event.id, event.startDate, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/processReserve.ts

@@ -30,7 +30,7 @@ async function main() {
     const priceSpecRepo = new chevre.repository.PriceSpecification(mongoose.connection);
     const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
-    const itemAvailabilityRepo = new chevre.repository.itemAvailability.ScreeningEvent(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
 
     const identifier = `CIN${(new Date()).valueOf()}`;
@@ -70,7 +70,7 @@ async function main() {
         validateEventOfferPeriod: false,
         validateAppliesToMovieTicket: true
     })({
-        eventAvailability: itemAvailabilityRepo,
+        stockHolder: itemAvailabilityRepo,
         event: eventRepo,
         offer: offerRepo,
         offerCatalog: offerCatalogRepo,

package/example/src/chevre/searchEventSeats.ts

@@ -0,0 +1,42 @@
+// tslint:disable:no-console
+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() {
+    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 itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+
+    const result = await itemAvailabilityRepo.searchHolders({
+        eventId: 'alckc9mlx',
+        startDate: new Date(),
+        offers: [
+            {
+                seatSection: 'Default',
+                seatNumber: 'B-10'
+            },
+            {
+                seatSection: 'xxx',
+                seatNumber: 'xxx'
+            }
+        ]
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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

@@ -11,7 +11,7 @@ async function main() {
 
     const projectRepo = new chevre.repository.Project(mongoose.connection);
     const productRepo = new chevre.repository.Product(mongoose.connection);
-    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.userPoolIdNew });
+    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.settings.userPoolIdNew });
 
     const result = await findCreditCard({
         project: { id: project.id },

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

@@ -0,0 +1,18 @@
+// 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 = new chevre.repository.Transaction(mongoose.connection);
+    const result = await transactionRepo.makeExpired({
+        expires: new Date()
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

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

@@ -19,7 +19,7 @@ async function main() {
     });
     await redisClient.connect();
 
-    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.userPoolIdNew });
+    const personRepo = new chevre.repository.Person({ userPoolId: chevre.settings.settings.userPoolIdNew });
     const actionRepo = new chevre.repository.Action(mongoose.connection);
     const accountRepo = new chevre.repository.Account(mongoose.connection);
     const accountingReportRepo = new chevre.repository.AccountingReport(mongoose.connection);

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

@@ -0,0 +1,19 @@
+// 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 = new chevre.repository.Transaction(mongoose.connection);
+    const result = await transactionRepo.startExportTasks({
+        typeOf: { $in: [chevre.factory.transactionType.PlaceOrder] },
+        status: chevre.factory.transactionStatusType.Confirmed
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/updateTransaction.ts

@@ -14,7 +14,7 @@ async function main() {
     };
 
     let now = moment();
-    await transactionRepo.findByIdAndUpdate({
+    await transactionRepo.findByIdAndUpdateInProgress({
         id: transactionId,
         update
     });

package/lib/chevre/eventEmitter/task.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import * as factory from '../factory';
+interface IListenArgsOnTaskStatusChanged {
+    id?: string;
+    name: factory.taskName;
+    status: factory.taskStatus;
+}
+type IOnTaskStatusChangedListener = (listenArgs: IListenArgsOnTaskStatusChanged) => void;
+/**
+ * タスクイベントエミッター
+ */
+declare class TaskEventEmitter extends EventEmitter {
+    onTaskStatusChanged(listner: IOnTaskStatusChangedListener): void;
+    emitTaskStatusChanged(args: IListenArgsOnTaskStatusChanged): void;
+}
+declare const taskEventEmitter: TaskEventEmitter;
+export { IOnTaskStatusChangedListener, taskEventEmitter };

package/lib/chevre/eventEmitter/task.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskEventEmitter = void 0;
+const events_1 = require("events");
+const settings_1 = require("../settings");
+var EventName;
+(function (EventName) {
+    EventName["OnTaskStatusChanged"] = "OnTaskStatusChanged";
+})(EventName || (EventName = {}));
+/**
+ * タスクイベントエミッター
+ */
+class TaskEventEmitter extends events_1.EventEmitter {
+    onTaskStatusChanged(listner) {
+        this.on(EventName.OnTaskStatusChanged, listner);
+    }
+    emitTaskStatusChanged(args) {
+        if (settings_1.USE_EVENT_EMITTERS) {
+            this.emit(EventName.OnTaskStatusChanged, args);
+        }
+    }
+}
+const taskEventEmitter = new TaskEventEmitter();
+exports.taskEventEmitter = taskEventEmitter;
+taskEventEmitter.on('error', (err) => {
+    // tslint:disable-next-line:no-console
+    console.error('taskEventEmitter listened an error.', err);
+});

package/lib/chevre/eventEmitter/transaction.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import * as factory from '../factory';
+interface IListenArgsOnTransactionStatusChanged {
+    /**
+     * 取引ID
+     */
+    id: string;
+    typeOf: factory.transactionType;
+    status: factory.transactionStatusType;
+}
+type IOnTransactionStatusChangedListener = (listenArgs: IListenArgsOnTransactionStatusChanged) => void;
+/**
+ * 取引イベントエミッター
+ */
+declare class TransactionEventEmitter extends EventEmitter {
+    onTransactionStatusChanged(listner: IOnTransactionStatusChangedListener): void;
+    emitTransactionStatusChanged(args: IListenArgsOnTransactionStatusChanged): void;
+}
+declare const transactionEventEmitter: TransactionEventEmitter;
+export { IListenArgsOnTransactionStatusChanged, transactionEventEmitter };

package/lib/chevre/eventEmitter/transaction.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionEventEmitter = void 0;
+const events_1 = require("events");
+const settings_1 = require("../settings");
+var EventName;
+(function (EventName) {
+    EventName["OnTransactionStatusChanged"] = "OnTransactionStatusChanged";
+})(EventName || (EventName = {}));
+/**
+ * 取引イベントエミッター
+ */
+class TransactionEventEmitter extends events_1.EventEmitter {
+    onTransactionStatusChanged(listner) {
+        this.on(EventName.OnTransactionStatusChanged, listner);
+    }
+    emitTransactionStatusChanged(args) {
+        if (settings_1.USE_EVENT_EMITTERS) {
+            this.emit(EventName.OnTransactionStatusChanged, args);
+        }
+    }
+}
+const transactionEventEmitter = new TransactionEventEmitter();
+exports.transactionEventEmitter = transactionEventEmitter;
+transactionEventEmitter.on('error', (err) => {
+    // tslint:disable-next-line:no-console
+    console.error('transactionEventEmitter listened an error.', err);
+});

package/lib/chevre/eventEmitter.d.ts

@@ -0,0 +1,3 @@
+import { taskEventEmitter } from './eventEmitter/task';
+import { transactionEventEmitter } from './eventEmitter/transaction';
+export { taskEventEmitter as task, transactionEventEmitter as transaction };

package/lib/chevre/eventEmitter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transaction = exports.task = void 0;
+const task_1 = require("./eventEmitter/task");
+Object.defineProperty(exports, "task", { enumerable: true, get: function () { return task_1.taskEventEmitter; } });
+const transaction_1 = require("./eventEmitter/transaction");
+Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return transaction_1.transactionEventEmitter; } });

package/lib/chevre/index.d.ts

@@ -6,9 +6,10 @@ import * as GMO from '@motionpicture/gmo-service';
 import * as surfrock from '@surfrock/sdk';
 import { credentials } from './credentials';
 import * as errorHandler from './errorHandler';
+import * as eventEmitter from './eventEmitter';
 import * as factory from './factory';
 import * as pecorinoapi from './pecorinoapi';
 import * as repository from './repository';
 import * as service from './service';
-import { settings } from './settings';
-export { credentials, errorHandler, factory, repository, service, settings, surfrock, pecorinoapi, COA, GMO };
+import * as settings from './settings';
+export { credentials, errorHandler, eventEmitter, factory, repository, service, settings, surfrock, pecorinoapi, COA, GMO };

package/lib/chevre/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMO = exports.COA = exports.pecorinoapi = exports.surfrock = exports.settings = exports.service = exports.repository = exports.factory = exports.errorHandler = exports.credentials = void 0;
+exports.GMO = exports.COA = exports.pecorinoapi = exports.surfrock = exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = exports.credentials = void 0;
 /**
  * index module
  */
@@ -14,6 +14,8 @@ const credentials_1 = require("./credentials");
 Object.defineProperty(exports, "credentials", { enumerable: true, get: function () { return credentials_1.credentials; } });
 const errorHandler = require("./errorHandler");
 exports.errorHandler = errorHandler;
+const eventEmitter = require("./eventEmitter");
+exports.eventEmitter = eventEmitter;
 const factory = require("./factory");
 exports.factory = factory;
 const pecorinoapi = require("./pecorinoapi");
@@ -22,5 +24,5 @@ const repository = require("./repository");
 exports.repository = repository;
 const service = require("./service");
 exports.service = service;
-const settings_1 = require("./settings");
-Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
+const settings = require("./settings");
+exports.settings = settings;

package/lib/chevre/repo/account.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoRepository = void 0;
-const onIndexCreated_1 = require("./mongoose/onIndexCreated");
 const account_1 = require("./mongoose/schemas/account");
 const factory = require("../factory");
 /**
@@ -19,9 +18,6 @@ const factory = require("../factory");
 class MongoRepository {
     constructor(connection) {
         this.accountModel = connection.model(account_1.modelName, account_1.schema);
-        if (connection.get('autoIndex') === true) {
-            this.accountModel.on(onIndexCreated_1.INDEX_EVENT, onIndexCreated_1.onIndexCreated);
-        }
     }
     // tslint:disable-next-line:cyclomatic-complexity max-func-body-length
     static CREATE_MONGO_CONDITIONS(params) {