@chevre/domain 21.13.0-alpha.1 → 21.13.0-alpha.3

package/lib/chevre/service.d.ts

@@ -5,49 +5,85 @@ import * as AccountTransactionIdentifierFactory from './factory/accountTransacti
 import * as EventFactory from './factory/event';
 import * as OrderFactory from './factory/order';
 import * as ReservedAgentIdentifireNamesFactory from './factory/reservedAgentIdentifireNames';
-import * as AccountService from './service/account';
-import * as AccountTransactionService from './service/accountTransaction';
-import * as AggregationService from './service/aggregation';
-import * as AssetTransactionService from './service/assetTransaction';
-import * as CodeService from './service/code';
-import * as DeliveryService from './service/delivery';
-import * as EventService from './service/event';
-import * as IAMService from './service/iam';
-import * as NotificationService from './service/notification';
-import * as OfferService from './service/offer';
-import * as OrderService from './service/order';
-import * as AnyPaymentService from './service/payment/any';
-import * as PermitService from './service/permit';
-import * as ProjectService from './service/project';
-import * as ReportService from './service/report';
-import * as ReserveService from './service/reserve';
-import * as TaskService from './service/task';
-import * as TransactionService from './service/transaction';
-import * as UtilService from './service/util';
-export import account = AccountService;
-export import accountTransaction = AccountTransactionService;
-export import aggregation = AggregationService;
-export import assetTransaction = AssetTransactionService;
-export import code = CodeService;
-export import delivery = DeliveryService;
-export import event = EventService;
-export import iam = IAMService;
-export import notification = NotificationService;
-export import offer = OfferService;
-export import order = OrderService;
+import * as TransactionFactory from './factory/transaction';
+import type * as AccountService from './service/account';
+import type * as AccountTransactionService from './service/accountTransaction';
+import type * as AggregationService from './service/aggregation';
+import type * as AssetTransactionService from './service/assetTransaction';
+import type * as CodeService from './service/code';
+import type * as DeliveryService from './service/delivery';
+import type * as EventService from './service/event';
+import type * as IAMService from './service/iam';
+import type * as NotificationService from './service/notification';
+import type * as OfferService from './service/offer';
+import type * as OrderService from './service/order';
+import type * as AnyPaymentService from './service/payment/any';
+import type * as PermitService from './service/permit';
+import type * as ProjectService from './service/project';
+import type * as ReportService from './service/report';
+import type * as ReserveService from './service/reserve';
+import type * as TaskService from './service/task';
+import type * as TransactionService from './service/transaction';
+export declare namespace account {
+    function createService(): Promise<typeof AccountService>;
+}
+export declare namespace accountTransaction {
+    function createService(): Promise<typeof AccountTransactionService>;
+}
+export declare namespace aggregation {
+    function createService(): Promise<typeof AggregationService>;
+}
+export declare namespace assetTransaction {
+    function createService(): Promise<typeof AssetTransactionService>;
+}
+export declare namespace code {
+    function createService(): Promise<typeof CodeService>;
+}
+export declare namespace delivery {
+    function createService(): Promise<typeof DeliveryService>;
+}
+export declare namespace event {
+    function createService(): Promise<typeof EventService>;
+}
+export declare namespace iam {
+    function createService(): Promise<typeof IAMService>;
+}
+export declare namespace notification {
+    function createService(): Promise<typeof NotificationService>;
+}
+export declare namespace offer {
+    function createService(): Promise<typeof OfferService>;
+}
+export declare namespace order {
+    function createService(): Promise<typeof OrderService>;
+}
 export declare namespace payment {
-    export import any = AnyPaymentService;
-}
-export import permit = PermitService;
-export import project = ProjectService;
-export import report = ReportService;
-export import reserve = ReserveService;
-export import task = TaskService;
-export import transaction = TransactionService;
-export import util = UtilService;
+    namespace any {
+        function createService(): Promise<typeof AnyPaymentService>;
+    }
+}
+export declare namespace permit {
+    function createService(): Promise<typeof PermitService>;
+}
+export declare namespace project {
+    function createService(): Promise<typeof ProjectService>;
+}
+export declare namespace report {
+    function createService(): Promise<typeof ReportService>;
+}
+export declare namespace reserve {
+    function createService(): Promise<typeof ReserveService>;
+}
+export declare namespace task {
+    function createService(): Promise<typeof TaskService>;
+}
+export declare namespace transaction {
+    function createService(): Promise<typeof TransactionService>;
+}
 export declare namespace factory {
     export import accountTransactionIdentifier = AccountTransactionIdentifierFactory;
     export import event = EventFactory;
     export import order = OrderFactory;
     export import reservedAgentIdentifireNames = ReservedAgentIdentifireNamesFactory;
+    export import transaction = TransactionFactory;
 }

package/lib/chevre/service.js

@@ -1,6 +1,15 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = exports.util = exports.transaction = exports.task = exports.reserve = exports.report = exports.project = exports.permit = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.delivery = exports.code = exports.assetTransaction = exports.aggregation = exports.accountTransaction = exports.account = void 0;
+exports.factory = exports.transaction = exports.task = exports.reserve = exports.report = exports.project = exports.permit = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.delivery = exports.code = exports.assetTransaction = exports.aggregation = exports.accountTransaction = exports.account = void 0;
 /**
  * service module
  */
@@ -8,47 +17,255 @@ const AccountTransactionIdentifierFactory = require("./factory/accountTransactio
 const EventFactory = require("./factory/event");
 const OrderFactory = require("./factory/order");
 const ReservedAgentIdentifireNamesFactory = require("./factory/reservedAgentIdentifireNames");
-const AccountService = require("./service/account");
-const AccountTransactionService = require("./service/accountTransaction");
-const AggregationService = require("./service/aggregation");
-const AssetTransactionService = require("./service/assetTransaction");
-const CodeService = require("./service/code");
-const DeliveryService = require("./service/delivery");
-const EventService = require("./service/event");
-const IAMService = require("./service/iam");
-const NotificationService = require("./service/notification");
-const OfferService = require("./service/offer");
-const OrderService = require("./service/order");
-const AnyPaymentService = require("./service/payment/any");
-const PermitService = require("./service/permit");
-const ProjectService = require("./service/project");
-const ReportService = require("./service/report");
-const ReserveService = require("./service/reserve");
-const TaskService = require("./service/task");
-const TransactionService = require("./service/transaction");
-const UtilService = require("./service/util");
-exports.account = AccountService;
-exports.accountTransaction = AccountTransactionService;
-exports.aggregation = AggregationService;
-exports.assetTransaction = AssetTransactionService;
-exports.code = CodeService;
-exports.delivery = DeliveryService;
-exports.event = EventService;
-exports.iam = IAMService;
-exports.notification = NotificationService;
-exports.offer = OfferService;
-exports.order = OrderService;
+const TransactionFactory = require("./factory/transaction");
+// import type * as UtilService from './service/util';
+// import all lazily(2023-10-11~)
+var account;
+(function (account) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/account'));
+            }
+            return service;
+        });
+    }
+    account.createService = createService;
+})(account = exports.account || (exports.account = {}));
+var accountTransaction;
+(function (accountTransaction) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/accountTransaction'));
+            }
+            return service;
+        });
+    }
+    accountTransaction.createService = createService;
+})(accountTransaction = exports.accountTransaction || (exports.accountTransaction = {}));
+var aggregation;
+(function (aggregation) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/aggregation'));
+            }
+            return service;
+        });
+    }
+    aggregation.createService = createService;
+})(aggregation = exports.aggregation || (exports.aggregation = {}));
+var assetTransaction;
+(function (assetTransaction) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/assetTransaction'));
+            }
+            return service;
+        });
+    }
+    assetTransaction.createService = createService;
+})(assetTransaction = exports.assetTransaction || (exports.assetTransaction = {}));
+var code;
+(function (code) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/code'));
+            }
+            return service;
+        });
+    }
+    code.createService = createService;
+})(code = exports.code || (exports.code = {}));
+var delivery;
+(function (delivery) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/delivery'));
+            }
+            return service;
+        });
+    }
+    delivery.createService = createService;
+})(delivery = exports.delivery || (exports.delivery = {}));
+var event;
+(function (event) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/event'));
+            }
+            return service;
+        });
+    }
+    event.createService = createService;
+})(event = exports.event || (exports.event = {}));
+var iam;
+(function (iam) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/iam'));
+            }
+            return service;
+        });
+    }
+    iam.createService = createService;
+})(iam = exports.iam || (exports.iam = {}));
+var notification;
+(function (notification) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/notification'));
+            }
+            return service;
+        });
+    }
+    notification.createService = createService;
+})(notification = exports.notification || (exports.notification = {}));
+var offer;
+(function (offer) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/offer'));
+            }
+            return service;
+        });
+    }
+    offer.createService = createService;
+})(offer = exports.offer || (exports.offer = {}));
+var order;
+(function (order) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/order'));
+            }
+            return service;
+        });
+    }
+    order.createService = createService;
+})(order = exports.order || (exports.order = {}));
 var payment;
 (function (payment) {
-    payment.any = AnyPaymentService;
+    let any;
+    (function (any) {
+        let service;
+        function createService() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (service === undefined) {
+                    service = yield Promise.resolve().then(() => require('./service/payment/any'));
+                }
+                return service;
+            });
+        }
+        any.createService = createService;
+    })(any = payment.any || (payment.any = {}));
 })(payment = exports.payment || (exports.payment = {}));
-exports.permit = PermitService;
-exports.project = ProjectService;
-exports.report = ReportService;
-exports.reserve = ReserveService;
-exports.task = TaskService;
-exports.transaction = TransactionService;
-exports.util = UtilService;
+var permit;
+(function (permit) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/permit'));
+            }
+            return service;
+        });
+    }
+    permit.createService = createService;
+})(permit = exports.permit || (exports.permit = {}));
+var project;
+(function (project) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/project'));
+            }
+            return service;
+        });
+    }
+    project.createService = createService;
+})(project = exports.project || (exports.project = {}));
+var report;
+(function (report) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/report'));
+            }
+            return service;
+        });
+    }
+    report.createService = createService;
+})(report = exports.report || (exports.report = {}));
+var reserve;
+(function (reserve) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/reserve'));
+            }
+            return service;
+        });
+    }
+    reserve.createService = createService;
+})(reserve = exports.reserve || (exports.reserve = {}));
+var task;
+(function (task) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/task'));
+            }
+            return service;
+        });
+    }
+    task.createService = createService;
+})(task = exports.task || (exports.task = {}));
+var transaction;
+(function (transaction) {
+    let service;
+    function createService() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (service === undefined) {
+                service = yield Promise.resolve().then(() => require('./service/transaction'));
+            }
+            return service;
+        });
+    }
+    transaction.createService = createService;
+})(transaction = exports.transaction || (exports.transaction = {}));
+// export namespace util {
+//     let service: typeof UtilService | undefined;
+//     export async function createService() {
+//         if (service === undefined) {
+//             service = await import('./service/util');
+//         }
+//         return service;
+//     }
+// }
 var factory;
 (function (factory) {
     factory.accountTransactionIdentifier = AccountTransactionIdentifierFactory;
@@ -57,4 +274,6 @@ var factory;
     // tslint:disable-next-line:no-shadowed-variable
     factory.order = OrderFactory;
     factory.reservedAgentIdentifireNames = ReservedAgentIdentifireNamesFactory;
+    // tslint:disable-next-line:no-shadowed-variable
+    factory.transaction = TransactionFactory;
 })(factory = exports.factory || (exports.factory = {}));

package/package.json

@@ -115,5 +115,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "21.13.0-alpha.1"
+  "version": "21.13.0-alpha.3"
 }

package/example/src/chevre/searchSendEmailActions.ts

@@ -1,44 +0,0 @@
-// 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/searchTasks.ts

@@ -1,31 +0,0 @@
-// 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: true });
-
-    const taskRepo = new chevre.repository.Task(mongoose.connection);
-
-    const tasks = await taskRepo.search(
-        {
-            limit: 1,
-            project: { id: { $eq: project.id } },
-            name: { $in: [chevre.factory.taskName.SendOrder] },
-            data: {
-                object: {
-                    orderNumber: { $eq: 'xxx' }
-                }
-            }
-        }
-    );
-    console.log('tasks found', tasks);
-    console.log(tasks.length, 'tasks found');
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/searchTransactions.ts

@@ -1,25 +0,0 @@
-// 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);
-
-    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
-
-    const transactions = await transactionRepo.search({
-        limit: 100,
-        page: 1,
-        typeOf: chevre.factory.transactionType.PlaceOrder,
-        result: { order: { confirmationNumber: { $eq: '96275' } } },
-        inclusion: ['result'],
-        exclusion: []
-    });
-    console.log(transactions);
-    console.log(transactions.length);
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/sendEmailMessage.ts

@@ -1,80 +0,0 @@
-// 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 SENDER_EMAIL = String(process.env.SENDER_EMAIL);
-const RECIPIENT_EMAIL = String(process.env.RECIPIENT_EMAIL);
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const actionRepo = new chevre.repository.Action(mongoose.connection);
-    const projectRepo = new chevre.repository.Project(mongoose.connection);
-
-    await chevre.service.notification.sendEmailMessage({
-        project: {
-            typeOf: chevre.factory.organizationType.Project,
-            id: project.id
-        },
-        typeOf: chevre.factory.actionType.SendAction,
-        object: {
-            typeOf: chevre.factory.creativeWorkType.EmailMessage,
-            identifier: 'SendOrder-CIN1-3970498-5700993',
-            name: 'SendOrder-CIN1-3970498-5700993',
-            sender: {
-                typeOf: 'Corporation',
-                name: 'sample sender ',
-                email: SENDER_EMAIL
-            },
-            toRecipient: [
-                {
-                    typeOf: 'WebApplication',
-                    name: 'sample recipient 2',
-                    email: RECIPIENT_EMAIL
-                }
-            ],
-            about: {
-                typeOf: 'Thing',
-                identifier: chevre.factory.creativeWork.message.email.AboutIdentifier.OnOrderSent,
-                name: 'sample about'
-            },
-            text: 'sample text'
-        },
-        agent: {
-            typeOf: chevre.factory.organizationType.Project,
-            id: project.id
-        },
-        recipient: {
-            typeOf: chevre.factory.creativeWorkType.WebApplication,
-            id: 'xxxx',
-            name: 'sample recipient'
-        },
-        purpose: {
-            typeOf: chevre.factory.order.OrderType.Order,
-            seller: {
-                id: '59d20831e53ebc2b4e774466',
-                name: 'seller name',
-                typeOf: chevre.factory.organizationType.Corporation
-            },
-            customer: {
-                typeOf: chevre.factory.creativeWorkType.WebApplication,
-                id: 'xxxx'
-            },
-            orderNumber: 'CIN1-3970498-5700993',
-            price: 0,
-            priceCurrency: chevre.factory.priceCurrency.JPY,
-            orderDate: moment('2023-03-06T01:02:58.866Z')
-                .toDate()
-        }
-    })({
-        action: actionRepo,
-        project: projectRepo
-    });
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);