@chevre/domain 21.37.0-alpha.8 → 21.37.0

package/example/src/chevre/processOrder.ts

@@ -0,0 +1,87 @@
+// 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) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const acceptedOfferRepo = await chevre.repository.AcceptedOffer.createInstance(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const cursor = orderRepo.getCursor(
+        {
+            'project.id': { $eq: project.id },
+            // orderNumber: { $eq: 'SSK9-4896645-5698154' },
+            orderDate: {
+                $lte: moment('2024-07-03T18:00:00Z')
+                    .toDate(),
+                $gte: moment('2024-06-30T18:00:00Z')
+                    .toDate()
+            },
+            orderStatus: { $eq: chevre.factory.orderStatus.OrderProcessing }
+        },
+        {
+            confirmationNumber: 1,
+            orderDate: 1, orderNumber: 1,
+            project: 1, typeOf: 1, orderStatus: 1
+        }
+    );
+    console.log('orders found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: Pick<chevre.factory.order.IOrder, 'confirmationNumber' | 'orderDate' | 'orderNumber' | 'project' | 'typeOf' | 'orderStatus'> = doc.toObject();
+        if (order.orderStatus !== chevre.factory.orderStatus.OrderProcessing) {
+            console.log('nothing to do', order.orderStatus, order.orderNumber);
+        } else {
+            const { orderNumber } = order;
+
+            const itemOfferedTypeOfs = <chevre.factory.order.IItemOffered['typeOf'][]>await acceptedOfferRepo.distinctValues(
+                { orderNumber: { $in: [orderNumber] } },
+                'acceptedOffers.itemOffered.typeOf'
+            );
+            const serialNumbers = await acceptedOfferRepo.distinctValues(
+                { orderNumber: { $in: [orderNumber] } },
+                'acceptedOffers.serialNumber'
+            );
+            const offeredThroughIdentifier = (<chevre.factory.service.webAPI.Identifier[]>await acceptedOfferRepo.distinctValues(
+                { orderNumber: { $in: [orderNumber] } },
+                'acceptedOffers.offeredThrough.identifier'
+            )).shift();
+
+            console.log('processing order', order, itemOfferedTypeOfs, serialNumbers, offeredThroughIdentifier);
+            await (await chevre.service.order.createService()).processOrder({
+                order: {
+                    ...order,
+                    itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
+                    serialNumbers,
+                    offeredThroughIdentifier
+                },
+                options: { force: true }
+            })({ task: taskRepo });
+            console.log('order processed', order.orderNumber);
+            updateCount += 1;
+            console.log('updated.', order.project.id, order.orderNumber, order.orderDate, i);
+        }
+    });
+
+    console.log(i, 'orders checked');
+    console.log(updateCount, 'orders updated');
+}
+
+main()
+    .then()
+    .catch(console.error);
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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

@@ -1,23 +1,11 @@
 // tslint:disable:no-console
 import * as mongoose from 'mongoose';
-import * as readline from 'readline';
 import * as redis from 'redis';
 
 import { chevre } from '../../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
-const CLIENT_ID = '51qbjcfr72h62m06vtv5kkhgje';
-const paymentMethodType = 'CreditCard';
-const paymentServiceId = '5f9a4fed4f3709000abe6415';
-// const paymentMethodType = 'PayPay';
-// const paymentServiceId = '60e9560176a391000b23e20b';
-const AMOUNT: number = 1;
-const creditCard: chevre.factory.paymentMethod.paymentCard.creditCard.IUncheckedCardRaw = {
-    cardNo: '4100000000000100',
-    expire: '2812',
-    cardPass: '123',
-    holderName: 'AA AA'
-};
+const CLIENT_ID = 'xxx';
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -31,143 +19,29 @@ async function main() {
     });
     await client.connect();
 
-    const transaction = await (await chevre.service.transaction.createService()).placeOrderInProgress.start({
-        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-        agent: { id: CLIENT_ID, typeOf: chevre.factory.creativeWorkType.WebApplication },
-        object: {
-            clientUser: <any>{ client_id: CLIENT_ID }
+    const transaction = await (await chevre.service.transaction.createService()).placeOrderInProgress.start(
+        {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            agent: { id: CLIENT_ID, typeOf: chevre.factory.creativeWorkType.WebApplication },
+            object: {
+                clientUser: <any>{ client_id: CLIENT_ID }
+            },
+            seller: { id: '59d20831e53ebc2b4e774466' }
         },
-        seller: { id: '59d20831e53ebc2b4e774466' }
-    })({
+        {
+            lockPassport: false
+        }
+    )({
         member: await chevre.repository.Member.createInstance(mongoose.connection),
+        passport: await chevre.repository.Passport.createInstance(
+            client,
+            { secret: 'xxx' }
+        ),
         projectMakesOffer: await chevre.repository.ProjectMakesOffer.createInstance(mongoose.connection),
         seller: await chevre.repository.Seller.createInstance(mongoose.connection),
         transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
     });
     console.log('transaction started', transaction);
-
-    const publishPaymentUrlResult = await (await chevre.service.payment.any.createService()).publishPaymentUrl({
-        project: { id: project.id },
-        agent: { id: CLIENT_ID },
-        object: {
-            amount: AMOUNT,
-            paymentMethod: paymentMethodType,
-            issuedThrough: { id: paymentServiceId },
-            method: '1',
-            creditCard: {
-                ...creditCard,
-                retUrl: String(process.env.SECURE_TRAN_RET_URL)
-            }
-        },
-        purpose: { id: transaction.id, typeOf: chevre.factory.transactionType.PlaceOrder },
-        paymentServiceType: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
-        location: {
-            typeOf: chevre.factory.creativeWorkType.WebApplication,
-            id: CLIENT_ID
-        }
-    })({
-        action: await chevre.repository.Action.createInstance(mongoose.connection),
-        assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
-        paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
-        paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-        paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
-        transactionNumber: await chevre.repository.TransactionNumber.createInstance(client),
-        transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
-    });
-    console.log(publishPaymentUrlResult);
-
-    // wait callback...
-    // tslint:disable-next-line:max-func-body-length
-    await new Promise<void>((resolve, reject) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        // tslint:disable-next-line:max-func-body-length
-        rl.question('callback received?:\n', async () => {
-            try {
-                await new Promise<void>(async (resolve2, reject2) => {
-                    const rl2 = readline.createInterface({
-                        input: process.stdin,
-                        output: process.stdout
-                    });
-
-                    rl2.question('VOID or AUTH?:\n', async (jobCd) => {
-                        if (jobCd === 'AUTH') {
-                            const authorizeResult = await (await chevre.service.payment.any.createService()).authorize({
-                                project: { id: project.id },
-                                agent: { id: CLIENT_ID },
-                                object: {
-                                    amount: AMOUNT,
-                                    paymentMethodId: publishPaymentUrlResult.paymentMethodId,
-                                    paymentMethod: paymentMethodType,
-                                    issuedThrough: { id: paymentServiceId },
-                                    method: '1',
-                                    creditCard
-                                },
-                                purpose: { id: transaction.id, typeOf: chevre.factory.transactionType.PlaceOrder },
-                                paymentServiceType: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
-                                location: {
-                                    typeOf: chevre.factory.creativeWorkType.WebApplication,
-                                    id: CLIENT_ID
-                                },
-                                options: {
-                                    useCancelPayTransactionOnFailed: false,
-                                    useCheckByIdentifierIfNotYet: false,
-                                    useUnlockTransactionProcess: false
-                                }
-                            })({
-                                accountingReport: await chevre.repository.AccountingReport.createInstance(mongoose.connection),
-                                action: await chevre.repository.Action.createInstance(mongoose.connection),
-                                assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
-                                authorization: await chevre.repository.Code.createInstance(mongoose.connection),
-                                confirmationNumber: await chevre.repository.ConfirmationNumber.createInstance(client),
-                                event: await chevre.repository.Event.createInstance(mongoose.connection),
-                                paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
-                                paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-                                paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
-                                product: await chevre.repository.Product.createInstance(mongoose.connection),
-                                task: await chevre.repository.Task.createInstance(mongoose.connection),
-                                ticket: await chevre.repository.Ticket.createInstance(mongoose.connection),
-                                transactionNumber: await chevre.repository.TransactionNumber.createInstance(client),
-                                transactionProcess:
-                                    await chevre.repository.TransactionProcess.createInstance(client, { lockExpiresInSeconds: 120 }),
-                                transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
-                            });
-                            console.log('payment authorized.', authorizeResult.id);
-                        } else if (jobCd === 'VOID') {
-                            await (await chevre.service.payment.any.createService()).invalidatePaymentUrl({
-                                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-                                purpose: { id: transaction.id, typeOf: chevre.factory.transactionType.PlaceOrder }
-                            })({
-                                accountingReport: await chevre.repository.AccountingReport.createInstance(mongoose.connection),
-                                action: await chevre.repository.Action.createInstance(mongoose.connection),
-                                assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
-                                paymentAccepted: await chevre.repository.SellerPaymentAccepted.createInstance(mongoose.connection),
-                                paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-                                paymentServiceProvider: await chevre.repository.PaymentServiceProvider.createInstance(mongoose.connection),
-                                task: await chevre.repository.Task.createInstance(mongoose.connection),
-                                transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
-                            });
-                            console.log('payment voided.');
-                        } else {
-                            reject2(`jobCd ${jobCd} not implemented`);
-
-                            return;
-                        }
-
-                        // rl.close();
-                        resolve2();
-                    });
-                });
-
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    });
 }
 
 main()

package/lib/chevre/factory/reservedAgentIdentifireNames.js

@@ -9,5 +9,6 @@ exports.RESERVED_AGENT_IDENTIFIER_NAMES = [
     'sub',
     'hostname',
     'username',
-    'jti'
+    'jti',
+    'passport'
 ];

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

@@ -3,13 +3,10 @@ export type IPassportValidator = (params: {
     passport: factory.waiter.passport.IPassport;
 }) => boolean;
 export declare namespace moneyTransfer {
-    type IStartParams = factory.transaction.moneyTransfer.IStartParamsWithoutDetail & {
-        passportValidator?: IPassportValidator;
-    };
+    type IStartParams = factory.transaction.moneyTransfer.IStartParamsWithoutDetail & {};
 }
 export declare namespace placeOrder {
     type IStartParams = factory.transaction.placeOrder.IStartParamsWithoutDetail & {
-        passportValidator?: IPassportValidator;
         broker?: factory.order.IBroker;
     };
     type IOrderURLGenerator = (order: factory.transaction.placeOrder.IOrderAsResult) => string;

package/lib/chevre/repo/passport.d.ts

@@ -0,0 +1,39 @@
+import * as jwt from 'jsonwebtoken';
+import type { RedisClientType } from 'redis';
+import * as factory from '../factory';
+import { IPassportValidator } from '../factory/transaction';
+export type IVerifiedPassport = factory.waiter.passport.IPassport & {
+    /**
+     * 許可証識別子(2024-07-06~)
+     */
+    identifier: string;
+};
+type ILockKey = IVerifiedPassport;
+interface IOptions {
+    secret: string;
+    passportValidator?: IPassportValidator;
+}
+type IStartParams = (factory.transaction.placeOrder.IStartParamsWithoutDetail | factory.transaction.moneyTransfer.IStartParamsWithoutDetail) & {};
+/**
+ * 取引許可証リポジトリ
+ */
+export declare class PassportRepo {
+    private readonly redisClient;
+    private readonly options;
+    constructor(redisClient: RedisClientType, options: IOptions);
+    static CREATE_VERIFIED_PASSPORT(params: string | jwt.JwtPayload | undefined): IVerifiedPassport;
+    static CREATE_REDIS_KEY(params: ILockKey): string;
+    lock(params: ILockKey): Promise<void>;
+    /**
+     * 許可証トークンがあれば検証する
+     */
+    validatePassportTokenIfExist(params: Pick<IStartParams, 'object'>): Promise<{
+        passport?: IVerifiedPassport;
+        customerType?: string;
+    }>;
+    /**
+     * 暗号化された許可証を検証する
+     */
+    private verify;
+}
+export {};

package/lib/chevre/repo/passport.js

@@ -0,0 +1,134 @@
+"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.PassportRepo = void 0;
+const createDebug = require("debug");
+const jwt = require("jsonwebtoken");
+const moment = require("moment");
+const factory = require("../factory");
+const debug = createDebug('chevre-domain:repo:passport');
+/**
+ * 取引許可証リポジトリ
+ */
+class PassportRepo {
+    constructor(redisClient, options) {
+        this.redisClient = redisClient;
+        this.options = options;
+    }
+    static CREATE_VERIFIED_PASSPORT(params) {
+        var _a;
+        if (typeof params === 'string' || params === undefined) {
+            throw new factory.errors.Argument('decoded must be an object');
+        }
+        if (typeof params.scope !== 'string' || params.scope === '') {
+            throw new factory.errors.ArgumentNull('scope');
+        }
+        if (typeof params.iat !== 'number') {
+            throw new factory.errors.Argument('iat', 'iat must be number');
+        }
+        if (typeof params.exp !== 'number') {
+            throw new factory.errors.Argument('exp', 'exp must be number');
+        }
+        if (typeof params.iss !== 'string' || params.iss === '') {
+            throw new factory.errors.ArgumentNull('iss');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof ((_a = params.issueUnit) === null || _a === void 0 ? void 0 : _a.identifier) !== 'string' || params.issueUnit.identifier === '') {
+            throw new factory.errors.Argument('issueUnit.identifier', 'issueUnit.identifier must be string');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof params.issueUnit.numberOfRequests !== 'number') {
+            throw new factory.errors.Argument('issueUnit.numberOfRequests', 'issueUnit.numberOfRequests must be number');
+        }
+        const identifier = `${params.issueUnit.identifier}:${params.issueUnit.numberOfRequests}`;
+        return Object.assign({ identifier, scope: params.scope, iat: params.iat, exp: params.exp, iss: params.iss, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            project: params.project, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            issueUnit: params.issueUnit }, (Array.isArray(params.aud)) ? { aud: params.aud } : undefined);
+    }
+    static CREATE_REDIS_KEY(params) {
+        return `chvr:lockPassport:${params.identifier}`;
+    }
+    lock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = moment();
+            const passportExpires = moment.unix(params.exp);
+            const key = PassportRepo.CREATE_REDIS_KEY(params);
+            const ttl = (passportExpires.isAfter(now))
+                ? moment.unix(params.exp)
+                    .diff(moment(), 'seconds')
+                : 1;
+            const results = yield this.redisClient.multi()
+                .setNX(key, '1')
+                .expire(key, ttl)
+                .exec();
+            debug('locked,', params.issueUnit.identifier, now, passportExpires, ttl, results);
+            if (Array.isArray(results) && (results[0] === 1 || results[0] === true)) {
+                return;
+            }
+            else {
+                throw new factory.errors.AlreadyInUse('passport', [], 'passport already in use');
+            }
+        });
+    }
+    /**
+     * 許可証トークンがあれば検証する
+     */
+    validatePassportTokenIfExist(params) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let passport;
+            let customerType;
+            if (typeof ((_b = (_a = params.object) === null || _a === void 0 ? void 0 : _a.passport) === null || _b === void 0 ? void 0 : _b.token) === 'string') {
+                try {
+                    passport = yield this.verify({
+                        token: params.object.passport.token
+                        // secret: this.options.secret
+                    });
+                }
+                catch (error) {
+                    throw new factory.errors.Argument('Passport Token', `Invalid token: ${error.message}`);
+                }
+                // 許可証バリデーション
+                if (typeof this.options.passportValidator === 'function') {
+                    if (!this.options.passportValidator({ passport })) {
+                        throw new factory.errors.Argument('Passport Token', 'passportValidator requirement not satisfied');
+                    }
+                }
+                // カスタマータイプ決定(2023-11-20~)
+                // スコープのフォーマットは、Transaction:${TransactionType}:${sellerId}:${customerType}
+                const splittedScope = passport.scope.split(':');
+                // tslint:disable-next-line:no-magic-numbers
+                customerType = splittedScope[3];
+            }
+            return Object.assign(Object.assign({}, (typeof customerType === 'string') ? { customerType } : undefined), (passport !== undefined) ? { passport } : undefined);
+        });
+    }
+    /**
+     * 暗号化された許可証を検証する
+     */
+    verify(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                jwt.verify(params.token, this.options.secret, (err, decoded) => {
+                    if (err instanceof Error) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(PassportRepo.CREATE_VERIFIED_PASSPORT(decoded));
+                    }
+                });
+            });
+        });
+    }
+}
+exports.PassportRepo = PassportRepo;

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

@@ -75,6 +75,7 @@ export declare class MongoRepository {
         };
     }): Promise<{
         id: string;
+        status: factory.taskStatus;
     } | undefined>;
     /**
      * タスク識別子から冪等作成する
@@ -127,6 +128,14 @@ export declare class MongoRepository {
     retry(params: {
         intervalInMinutes: number;
     }): Promise<UpdateWriteOpResult>;
+    /**
+     * 実行中止済タスクを強制的にリトライ
+     * 中止済タスクでなければ何もしない
+     */
+    retryForciblyIfAborted(params: {
+        id: string;
+        remainingNumberOfTries: number;
+    }): Promise<import("mongodb").UpdateResult>;
     abortOne(params: {
         intervalInMinutes: number;
     }): Promise<factory.task.ITask<factory.taskName> | null>;

package/lib/chevre/repo/task.js

@@ -201,12 +201,13 @@ class MongoRepository {
                 'project.id': { $eq: params.project.id },
                 name: { $eq: params.name },
                 identifier: { $exists: true, $eq: params.identifier }
-            }, { _id: 1 })
+            }, { _id: 1, status: 1 })
                 .exec();
             if (doc === null) {
                 return;
             }
-            return { id: doc.id };
+            const { id, status } = doc.toObject();
+            return { id, status };
         });
     }
     /**
@@ -514,6 +515,26 @@ class MongoRepository {
                 .exec();
         });
     }
+    /**
+     * 実行中止済タスクを強制的にリトライ
+     * 中止済タスクでなければ何もしない
+     */
+    retryForciblyIfAborted(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.taskModel.updateOne({
+                _id: { $eq: params.id },
+                status: { $eq: factory.taskStatus.Aborted }
+            }, {
+                $set: {
+                    status: factory.taskStatus.Ready
+                },
+                $inc: {
+                    remainingNumberOfTries: params.remainingNumberOfTries
+                }
+            })
+                .exec();
+        });
+    }
     abortOne(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const lastTriedAtShoudBeLessThan = moment()

package/lib/chevre/repository.d.ts

@@ -31,6 +31,7 @@ import type { MongoRepository as OfferItemConditionRepo } from './repo/offerItem
 import type { MongoRepository as OrderRepo } from './repo/order';
 import type { MongoRepository as OrderInTransactionRepo } from './repo/orderInTransaction';
 import type { MongoRepository as OwnershipInfoRepo } from './repo/ownershipInfo';
+import type { PassportRepo } from './repo/passport';
 import type { MongoRepository as PaymentServiceRepo } from './repo/paymentService';
 import type { MongoRepository as PaymentServiceProviderRepo } from './repo/paymentServiceProvider';
 import type { MongoRepository as PermitRepo } from './repo/permit';
@@ -193,6 +194,10 @@ export type OwnershipInfo = OwnershipInfoRepo;
 export declare namespace OwnershipInfo {
     function createInstance(...params: ConstructorParameters<typeof OwnershipInfoRepo>): Promise<OwnershipInfoRepo>;
 }
+export type Passport = PassportRepo;
+export declare namespace Passport {
+    function createInstance(...params: ConstructorParameters<typeof PassportRepo>): Promise<PassportRepo>;
+}
 export type PaymentService = PaymentServiceRepo;
 export declare namespace PaymentService {
     function createInstance(...params: ConstructorParameters<typeof PaymentServiceRepo>): Promise<PaymentServiceRepo>;

package/lib/chevre/repository.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceOutputIdentifier = exports.ServiceOutput = exports.SellerPaymentAccepted = exports.Seller = exports.Role = exports.Reservation = exports.ProjectMakesOffer = exports.Project = exports.ProductOffer = exports.ProductModel = exports.Product = exports.PriceSpecification = exports.place = exports.Permit = exports.Person = exports.paymentMethod = exports.PaymentServiceProvider = exports.PaymentService = exports.OwnershipInfo = exports.OrderNumber = exports.OrderInTransaction = exports.Order = exports.Offer = exports.OfferItemCondition = exports.OfferCatalogItem = exports.OfferCatalog = exports.Note = exports.Message = exports.MerchantReturnPolicy = exports.Member = exports.Event = exports.EmailMessage = exports.CustomerType = exports.Customer = exports.CreativeWork = exports.ConfirmationNumber = exports.Comment = exports.Code = exports.CategoryCode = exports.AssetTransaction = exports.Aggregation = exports.AggregateReservation = exports.AggregateOffer = exports.AdditionalProperty = exports.Action = exports.AccountTransaction = exports.AccountTitle = exports.AccountingReport = exports.Account = exports.AcceptedOffer = void 0;
-exports.rateLimit = exports.Trip = exports.TransactionProcess = exports.TransactionNumber = exports.Transaction = exports.Ticket = exports.Telemetry = exports.Task = exports.StockHolder = void 0;
+exports.ServiceOutput = exports.SellerPaymentAccepted = exports.Seller = exports.Role = exports.Reservation = exports.ProjectMakesOffer = exports.Project = exports.ProductOffer = exports.ProductModel = exports.Product = exports.PriceSpecification = exports.place = exports.Permit = exports.Person = exports.paymentMethod = exports.PaymentServiceProvider = exports.PaymentService = exports.Passport = exports.OwnershipInfo = exports.OrderNumber = exports.OrderInTransaction = exports.Order = exports.Offer = exports.OfferItemCondition = exports.OfferCatalogItem = exports.OfferCatalog = exports.Note = exports.Message = exports.MerchantReturnPolicy = exports.Member = exports.Event = exports.EmailMessage = exports.CustomerType = exports.Customer = exports.CreativeWork = exports.ConfirmationNumber = exports.Comment = exports.Code = exports.CategoryCode = exports.AssetTransaction = exports.Aggregation = exports.AggregateReservation = exports.AggregateOffer = exports.AdditionalProperty = exports.Action = exports.AccountTransaction = exports.AccountTitle = exports.AccountingReport = exports.Account = exports.AcceptedOffer = void 0;
+exports.rateLimit = exports.Trip = exports.TransactionProcess = exports.TransactionNumber = exports.Transaction = exports.Ticket = exports.Telemetry = exports.Task = exports.StockHolder = exports.ServiceOutputIdentifier = void 0;
 var AcceptedOffer;
 (function (AcceptedOffer) {
     let repo;
@@ -427,6 +427,19 @@ var OwnershipInfo;
     }
     OwnershipInfo.createInstance = createInstance;
 })(OwnershipInfo = exports.OwnershipInfo || (exports.OwnershipInfo = {}));
+var Passport;
+(function (Passport) {
+    let repo;
+    function createInstance(...params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (repo === undefined) {
+                repo = (yield Promise.resolve().then(() => require('./repo/passport'))).PassportRepo;
+            }
+            return new repo(...params);
+        });
+    }
+    Passport.createInstance = createInstance;
+})(Passport = exports.Passport || (exports.Passport = {}));
 var PaymentService;
 (function (PaymentService) {
     let repo;

package/lib/chevre/service/accountTransaction/deposit.js

@@ -25,7 +25,6 @@ function start(params) {
         });
         // 取引ファクトリーで新しい進行中取引オブジェクトを作成
         const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Deposit, agent: params.agent, recipient: params.recipient, object: {
-                // clientUser: params.object.clientUser,
                 amount: params.object.amount,
                 toLocation: {
                     typeOf: account.typeOf,

package/lib/chevre/service/accountTransaction/transfer.js

@@ -43,7 +43,6 @@ function start(params) {
         }
         // 取引ファクトリーで新しい進行中取引オブジェクトを作成
         const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Transfer, agent: params.agent, recipient: params.recipient, object: {
-                // clientUser: params.object.clientUser,
                 amount: params.object.amount,
                 fromLocation: {
                     typeOf: fromAccount.typeOf,

package/lib/chevre/service/accountTransaction/withdraw.js

@@ -32,7 +32,6 @@ function start(params) {
         }
         // 取引ファクトリーで新しい進行中取引オブジェクトを作成
         const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Withdraw, agent: params.agent, recipient: params.recipient, object: {
-                // clientUser: params.object.clientUser,
                 amount: params.object.amount,
                 fromLocation: {
                     typeOf: fromAccount.typeOf,

package/lib/chevre/service/assetTransaction/reserve/cancel.d.ts

@@ -0,0 +1,22 @@
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { MongoRepository as AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
+import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
+import type { StockHolderRepository as StockHolderRepo } from '../../../repo/stockHolder';
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+type ICancelOperation<T> = (repos: {
+    action: ActionRepo;
+    stockHolder: StockHolderRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引中止
+ */
+declare function cancel(params: {
+    id?: string;
+    transactionNumber?: string;
+}): ICancelOperation<void>;
+export { cancel };