@chevre/domain 21.2.0-alpha.15 → 21.2.0-alpha.150

package/example/src/chevre/searchEventSeats.ts

@@ -1,9 +1,10 @@
 // tslint:disable:no-console
+import * as  mongoose from 'mongoose';
 import * as redis from 'redis';
 
 import { chevre } from '../../../lib/index';
 
-// const project = { id: String(process.env.PROJECT_ID) };
+const project = { id: String(process.env.PROJECT_ID) };
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -16,11 +17,13 @@ async function main() {
     });
     await client.connect();
 
-    const itemAvailabilityRepo = new chevre.repository.StockHolder(client);
+    const itemAvailabilityRepo = new chevre.repository.StockHolder(client, mongoose.connection);
 
     const result = await itemAvailabilityRepo.searchHolders({
+        project,
         eventId: 'alckc9mlx',
         startDate: new Date(),
+        hasTicketedSeat: true,
         offers: [
             {
                 seatSection: 'Default',

package/example/src/chevre/searchHoldReservations.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+// import * as redis from 'redis';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: true });
+    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();
+
+    const stockHolderRepo = new chevre.repository.StockHolder(client, mongoose.connection);
+
+    const holdReservations = await stockHolderRepo.search({
+        limit: 2,
+        page: 2,
+        sort: { 'reservationFor.startDate': chevre.factory.sortType.Ascending }
+    });
+    console.log(holdReservations);
+    console.log(holdReservations.length);
+
+    // const aggregations = await stockHolderRepo.aggregateByReservationFor({
+    //     limit: 100,
+    //     page: 1
+    // });
+    // console.log(aggregations);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchPaymentServiceProviders.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = process.env.PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const productRepo = new chevre.repository.Product(mongoose.connection);
+
+    const providers = await productRepo.searchProviders({
+        project: { id: { $eq: PROJECT_ID } },
+        id: 'xxx'
+    });
+    console.log(providers);
+    console.log(providers[0]?.credentials);
+    console.log(providers.length);
+
+    const paymentServices = await productRepo.searchPaymentServicesByProvider(
+        {
+            limit: 10,
+            page: 1,
+            sort: { productID: chevre.factory.sortType.Descending },
+            project: { id: { $eq: PROJECT_ID } },
+            typeOf: { $eq: chevre.factory.service.paymentService.PaymentServiceType.CreditCard },
+            provider: { id: { $eq: 'xxx' } }
+        }
+    );
+    console.log(paymentServices);
+    console.log(paymentServices[0]?.provider?.credentials);
+    console.log(paymentServices.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchPermissions.ts

@@ -0,0 +1,54 @@
+// 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 memberId = 'xxx';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const memberRepo = new chevre.repository.Member(mongoose.connection);
+    const roleRepo = new chevre.repository.Role(mongoose.connection);
+
+    let now: Date;
+
+    // let now = new Date();
+    // const aggregateRoleNamesResult = await memberRepo.aggregateRoleNames({
+    //     project: { id: { $eq: PROJECT_ID } },
+    //     member: { id: { $eq: memberId } }
+    // });
+
+    // const aggregatePermissionsResult = await roleRepo.aggregatePermissions({
+    //     roleName: {
+    //         $in: aggregateRoleNamesResult.map((r) => r.roleName)
+    //     }
+    // });
+    // console.log('time cost:', moment()
+    //     .diff(now));
+
+    now = new Date();
+    const searchPermissionsResult = await chevre.service.iam.searchPermissions({
+        project: { id: PROJECT_ID },
+        member: { id: memberId }
+    })({
+        member: memberRepo,
+        role: roleRepo
+    });
+    console.log('time cost:', moment()
+        .diff(now));
+
+    console.log(searchPermissionsResult);
+    console.log(searchPermissionsResult.permissions.length);
+
+    // console.log(aggregateRoleNamesResult);
+    // console.log(aggregateRoleNamesResult.length);
+    // console.log(aggregatePermissionsResult);
+    // console.log(aggregatePermissionsResult.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchReservationNumbersByOrderNumbers.ts

@@ -4,17 +4,53 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 // const project = { id: String(process.env.PROJECT_ID) };
+const orderNumbers = ['TTT9-4703865-8892744', 'TTT9-4703865-8398074', 'SSK6-4815238-3010844'];
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
     const orderRepo = new chevre.repository.Order(mongoose.connection);
 
+    const reservatioForIds = await orderRepo.searchReservationForIdsByOrderNumbers({
+        orderNumber: { $in: orderNumbers }
+    });
+    console.log('reservatioForIds found', reservatioForIds);
+    console.log(reservatioForIds.length, 'reservatioForIds found');
+
     const reservationNumbers = await orderRepo.searchReservationNumbersByOrderNumbers({
-        orderNumber: { $in: ['CIN5-8118459-9364668', 'CIN7-9119652-8987979', 'SSK1-3992448-6733563'] }
+        orderNumber: { $in: orderNumbers }
     });
     console.log('reservationNumbers found', reservationNumbers);
     console.log(reservationNumbers.length, 'reservationNumbers found');
+
+    const offers = await orderRepo.searchAcceptedOffersByOrderNumbers({
+        orderNumber: { $in: orderNumbers }
+    });
+    console.log('offers found', offers);
+    console.log(offers.length, 'offers found');
+
+    const movieTickets: any[] = [];
+    offers.forEach((offer) => {
+        const movieTicketTypeChargeSpecExists = offer.priceSpecification.priceComponent.some((component) => {
+            return component.typeOf === chevre.factory.priceSpecificationType.MovieTicketTypeChargeSpecification;
+        });
+        if (movieTicketTypeChargeSpecExists) {
+            offer.priceSpecification.priceComponent.forEach((component) => {
+                if (component.typeOf === chevre.factory.priceSpecificationType.UnitPriceSpecification) {
+                    if (Array.isArray(component.appliesToMovieTicket)) {
+                        component.appliesToMovieTicket.forEach((appliesToMovieTicket) => {
+                            movieTickets.push({
+                                identifier: appliesToMovieTicket.identifier,
+                                paymentMethodType: appliesToMovieTicket.serviceOutput.typeOf,
+                                offerId: offer.id
+                            });
+                        });
+                    }
+                }
+            });
+        }
+    });
+    console.log('movieTickets found', movieTickets);
 }
 
 main()

package/example/src/chevre/searchScreeningRooms.ts

@@ -0,0 +1,35 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const PROJECT_ID = String(process.env.PROJECT_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const rooms = await placeRepo.searchScreeningRooms(
+        {
+            limit: 10,
+            page: 1,
+            $projection: { sectionCount: 1 }
+        },
+        true
+    );
+    console.log('place found', rooms);
+    const filteredRooms = rooms.filter((room) => typeof room.sectionCount === 'number' && room.sectionCount > 1);
+    console.log(filteredRooms.length, 'filteredRooms found');
+
+    const screeningRoom = await placeRepo.findScreeningRoomsByBranchCode({
+        branchCode: { $eq: rooms[0].branchCode },
+        containedInPlace: { id: { $eq: String(rooms[0].containedInPlace?.id) } },
+        useScreeningRoomType: true
+    });
+    console.log('screeningRoom found', screeningRoom);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchSendEmailActions.ts

@@ -0,0 +1,44 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+
+    const actions = <chevre.factory.action.transfer.send.message.email.IAction[]>await actionRepo.search(
+        {
+            limit: 1000,
+            page: 1,
+            typeOf: { $eq: chevre.factory.actionType.SendAction },
+            object: {
+                typeOf: { $eq: chevre.factory.creativeWorkType.EmailMessage }
+            }
+            // startFrom: moment()
+            //     .add(-20, 'days')
+            //     .toDate(),
+            // startThrough: moment()
+            //     .add(-19, 'days')
+            //     .toDate(),
+        },
+        ['project', '_id', 'object', 'purpose'],
+        []
+    );
+    const maxLenght = Math.max(...actions.map((action) => {
+        return (Array.isArray(action.object)) ? action.object[0].text?.length : action.object.text?.length;
+    }));
+    actions.forEach((action) => {
+        const length = (Array.isArray(action.object)) ? action.object[0].text?.length : action.object.text?.length;
+        if (typeof length !== 'number') {
+            throw new Error(`${action.project.id},${action.id},${action.purpose?.typeOf},${action.purpose?.orderNumber},${action.object.text?.length}`);
+        }
+    });
+    console.log('maxLenght:', maxLenght);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/syncScreeningRooms.ts

@@ -0,0 +1,21 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const PROJECT_ID = String(process.env.PROJECT_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    await placeRepo.syncScreeningRooms({
+        id: '60409176f60a46000a7a3787'
+    });
+    console.log('synced');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/syncScreeningRoomsAll.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const PROJECT_ID = String(process.env.PROJECT_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = placeRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.placeType.MovieTheater }
+        },
+        {
+            _id: 1,
+            name: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('places found');
+
+    let i = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const { id, name, project, typeOf } = <Pick<chevre.factory.place.movieTheater.IPlace, 'id' | 'name' | 'project' | 'typeOf'>>
+            doc.toObject();
+
+        console.log('syncing...', project.id, typeOf, id, name.ja, i);
+        await placeRepo.syncScreeningRooms({ id });
+        console.log('synced.', project.id, typeOf, id, name.ja, i);
+    });
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/task/executeTasks.ts

@@ -0,0 +1,26 @@
+// 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 taskRepo = new chevre.repository.Task(mongoose.connection);
+    const result = await taskRepo.executeTasks({
+        now: new Date(),
+        delayInSeconds: 60,
+        limit: 1,
+        name: {
+            $nin: [
+                chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                chevre.factory.taskName.ImportEventsFromCOA
+            ]
+        }
+    });
+    console.log(result);
+}
+
+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/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/processReturnOrder.ts

@@ -0,0 +1,40 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const result = await chevre.service.transaction.returnOrder.start({
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        expiresInSeconds: 60,
+        agent: { id: 'xxx', typeOf: chevre.factory.creativeWorkType.WebApplication },
+        object: {
+            order: [{
+                confirmationNumber: '99916',
+                orderNumber: 'TTT2-8507485-9273468'
+            }],
+            reason: chevre.factory.transaction.returnOrder.Reason.Customer
+        },
+        seller: {
+            id: 'xxx'
+        }
+    })({
+        event: new chevre.repository.Event(mongoose.connection),
+        merchantReturnPolicy: new chevre.repository.MerchantReturnPolicy(mongoose.connection),
+        offer: new chevre.repository.Offer(mongoose.connection),
+        offerItemCondition: new chevre.repository.OfferItemCondition(mongoose.connection),
+        order: new chevre.repository.Order(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        seller: new chevre.repository.Seller(mongoose.connection),
+        transaction: new chevre.repository.Transaction(mongoose.connection)
+    });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

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

@@ -9,7 +9,8 @@ async function main() {
     const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
     const result = await transactionRepo.startExportTasks({
         typeOf: { $in: [chevre.factory.transactionType.PlaceOrder] },
-        status: chevre.factory.transactionStatusType.Confirmed
+        status: chevre.factory.transactionStatusType.Confirmed,
+        tasksExportAction: { agent: { name: 'xxx' } }
     });
     console.log(result);
 }

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/example/src/playOnMoment.ts

@@ -0,0 +1,24 @@
+// tslint:disable:no-console
+import * as moment from 'moment-timezone';
+
+const startDate = moment('2023-05-27T00:00:00Z')
+    .toDate();
+const gracePeriodBeforeStartInDaysMin = {
+    timezone: 'Asia/Tokyo',
+    time: '09:38:00',
+    period: { value: 3 }
+};
+const returningDate = new Date();
+
+const minDate: string = moment(startDate)
+    .tz(gracePeriodBeforeStartInDaysMin.timezone)
+    .startOf('days')
+    .subtract(gracePeriodBeforeStartInDaysMin.period.value, 'days')
+    .format('YYYY-MM-DD');
+console.log('minDate:', minDate);
+
+const returnMaxDate = moment(`${minDate}T${gracePeriodBeforeStartInDaysMin.time}`)
+    .tz(gracePeriodBeforeStartInDaysMin.timezone);
+console.log(returnMaxDate);
+
+console.log(returnMaxDate.isSameOrAfter(moment(returningDate)));

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,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetTransactionEventEmitter = void 0;
+const events_1 = require("events");
+var EventName;
+(function (EventName) {
+    EventName["OnAssetTransactionStatusChanged"] = "OnAssetTransactionStatusChanged";
+})(EventName || (EventName = {}));
+/**
+ * 資産取引イベントエミッター
+ */
+class AssetTransactionEventEmitter extends events_1.EventEmitter {
+    onAssetTransactionStatusChanged(listner) {
+        this.on(EventName.OnAssetTransactionStatusChanged, listner);
+    }
+    emitAssetTransactionStatusChanged(args) {
+        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

@@ -3,6 +3,7 @@ import { EventEmitter } from 'events';
 import * as factory from '../factory';
 interface IListenArgsOnTaskStatusChanged {
     id: string;
+    name?: factory.taskName;
     status: factory.taskStatus;
 }
 type IOnTaskStatusChangedListener = (listenArgs: IListenArgsOnTaskStatusChanged) => void;
@@ -14,4 +15,4 @@ declare class TaskEventEmitter extends EventEmitter {
     emitTaskStatusChanged(args: IListenArgsOnTaskStatusChanged): void;
 }
 declare const taskEventEmitter: TaskEventEmitter;
-export { taskEventEmitter };
+export { IOnTaskStatusChangedListener, taskEventEmitter };

package/lib/chevre/eventEmitter/task.js

@@ -2,7 +2,6 @@
 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";
@@ -15,9 +14,7 @@ class TaskEventEmitter extends events_1.EventEmitter {
         this.on(EventName.OnTaskStatusChanged, listner);
     }
     emitTaskStatusChanged(args) {
-        if (settings_1.USE_EVENT_EMITTERS) {
-            this.emit(EventName.OnTaskStatusChanged, args);
-        }
+        this.emit(EventName.OnTaskStatusChanged, args);
     }
 }
 const taskEventEmitter = new TaskEventEmitter();

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

@@ -18,4 +18,4 @@ declare class TransactionEventEmitter extends EventEmitter {
     emitTransactionStatusChanged(args: IListenArgsOnTransactionStatusChanged): void;
 }
 declare const transactionEventEmitter: TransactionEventEmitter;
-export { transactionEventEmitter };
+export { IListenArgsOnTransactionStatusChanged, transactionEventEmitter };

package/lib/chevre/eventEmitter/transaction.js

@@ -2,7 +2,6 @@
 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";
@@ -15,9 +14,7 @@ class TransactionEventEmitter extends events_1.EventEmitter {
         this.on(EventName.OnTransactionStatusChanged, listner);
     }
     emitTransactionStatusChanged(args) {
-        if (settings_1.USE_EVENT_EMITTERS) {
-            this.emit(EventName.OnTransactionStatusChanged, args);
-        }
+        this.emit(EventName.OnTransactionStatusChanged, args);
     }
 }
 const transactionEventEmitter = new TransactionEventEmitter();

package/lib/chevre/eventEmitter.d.ts

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

package/lib/chevre/eventEmitter.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transaction = exports.task = void 0;
+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");

package/lib/chevre/index.d.ts

@@ -11,5 +11,5 @@ import * as factory from './factory';
 import * as pecorinoapi from './pecorinoapi';
 import * as repository from './repository';
 import * as service from './service';
-import { settings } from './settings';
+import * as settings from './settings';
 export { credentials, errorHandler, eventEmitter, factory, repository, service, settings, surfrock, pecorinoapi, COA, GMO };

package/lib/chevre/index.js

@@ -24,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;