@chevre/domain 21.2.0-alpha.3 → 21.2.0-alpha.30

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

@@ -0,0 +1,30 @@
+// tslint:disable:no-console
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const tasks = <chevre.factory.task.ITask<chevre.factory.taskName.Pay>[]>await taskRepo.search({
+        // limit: 100,
+        // page: 1,
+        name: chevre.factory.taskName.Pay,
+        statuses: [chevre.factory.taskStatus.Aborted],
+        runsFrom: moment('2023-04-27T00:00:00Z')
+            .toDate(),
+        sort: { runsAt: chevre.factory.sortType.Ascending }
+    });
+    console.log(tasks.map((task) => `${task.project.id},${task.id},${moment(task.runsAt)
+        .tz('Asia/Tokyo')
+        .format('YYYY-MM-DDTHH:mm:ssZ')},"${task.data.object[0].paymentMethod.paymentMethodId}"`)
+        .join('\n'));
+    console.log(tasks.length);
+}
+
+main()
+    .then(console.log)
+    .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/credentials.d.ts

@@ -27,6 +27,7 @@ export declare const credentials: {
     lineNotify: {
         url: string;
         accessToken: string;
+        accessTokenAlert: string;
     };
     movieticketReserve: {
         timeout: number;

package/lib/chevre/credentials.js

@@ -31,7 +31,8 @@ exports.credentials = {
     },
     lineNotify: {
         url: process.env.LINE_NOTIFY_URL,
-        accessToken: process.env.LINE_NOTIFY_ACCESS_TOKEN
+        accessToken: process.env.LINE_NOTIFY_ACCESS_TOKEN,
+        accessTokenAlert: process.env.LINE_NOTIFY_ACCESS_TOKEN_ALERT
     },
     movieticketReserve: {
         // tslint:disable-next-line:no-magic-numbers

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import * as factory from '../factory';
+interface IListenArgsOnAssetTransactionStatusChanged {
+    /**
+     * 取引ID
+     */
+    id: string;
+    typeOf: factory.assetTransactionType;
+    status: factory.transactionStatusType;
+}
+type IOnAssetTransactionStatusChangedListener = (listenArgs: IListenArgsOnAssetTransactionStatusChanged) => void;
+/**
+ * 資産取引イベントエミッター
+ */
+declare class AssetTransactionEventEmitter extends EventEmitter {
+    onAssetTransactionStatusChanged(listner: IOnAssetTransactionStatusChangedListener): void;
+    emitAssetTransactionStatusChanged(args: IListenArgsOnAssetTransactionStatusChanged): void;
+}
+declare const assetTransactionEventEmitter: AssetTransactionEventEmitter;
+export { IListenArgsOnAssetTransactionStatusChanged, assetTransactionEventEmitter };

package/lib/chevre/eventEmitter/assetTransaction.js

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

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,4 @@
+import { assetTransactionEventEmitter } from './eventEmitter/assetTransaction';
+import { taskEventEmitter } from './eventEmitter/task';
+import { transactionEventEmitter } from './eventEmitter/transaction';
+export { assetTransactionEventEmitter as assetTransaction, taskEventEmitter as task, transactionEventEmitter as transaction };

package/lib/chevre/eventEmitter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transaction = exports.task = exports.assetTransaction = void 0;
+const assetTransaction_1 = require("./eventEmitter/assetTransaction");
+Object.defineProperty(exports, "assetTransaction", { enumerable: true, get: function () { return assetTransaction_1.assetTransactionEventEmitter; } });
+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 };