@chevre/domain 24.0.0-alpha.9 → 24.0.0

package/lib/chevre/service/payment/any/authorize/handlePrePublishedPaymentMethodIdOnAuthorizing.js

@@ -1,64 +1,41 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePrePublishedPaymentMethodIdOnAuthorizing = handlePrePublishedPaymentMethodIdOnAuthorizing;
 const debug_1 = __importDefault(require("debug"));
-const factory = __importStar(require("../../../../factory"));
+const factory_1 = require("../../../../factory");
 const debug = (0, debug_1.default)('chevre-domain:service:payment');
 function recipe2paymentAgencyTransaction(actionRecipe) {
     let entryTranArgs;
     let entryTranResult;
     let execTranArgs;
     let execTranResult;
-    if (actionRecipe.recipeCategory !== factory.recipe.RecipeCategory.publishPaymentUrl) {
-        throw new factory.errors.NotFound('', `Recipe with category ${factory.recipe.RecipeCategory.publishPaymentUrl} not found`);
+    if (actionRecipe.recipeCategory !== factory_1.factory.recipe.RecipeCategory.publishPaymentUrl) {
+        throw new factory_1.factory.errors.NotFound('', `Recipe with category ${factory_1.factory.recipe.RecipeCategory.publishPaymentUrl} not found`);
     }
     const howToSection = actionRecipe.step;
     const howToSteps = howToSection.at(0)?.itemListElement;
     if (Array.isArray(howToSteps)) {
         howToSteps.forEach((howToStep) => {
             const stepIdentifier = howToStep.identifier;
-            if (stepIdentifier === factory.recipe.StepIdentifier.entryTran) {
+            if (stepIdentifier === factory_1.factory.recipe.StepIdentifier.entryTran) {
                 entryTranArgs = howToStep.itemListElement.at(0)?.beforeMedia;
                 entryTranResult = howToStep.itemListElement.at(0)?.afterMedia;
             }
-            else if (stepIdentifier === factory.recipe.StepIdentifier.execTran) {
+            else if (stepIdentifier === factory_1.factory.recipe.StepIdentifier.execTran) {
                 execTranArgs = howToStep.itemListElement.at(0)?.beforeMedia;
                 execTranResult = howToStep.itemListElement.at(0)?.afterMedia;
             }
             else {
-                throw new factory.errors.NotImplemented(`howToStep.identifier '${stepIdentifier}' not implemented`);
+                throw new factory_1.factory.errors.NotImplemented(`howToStep.identifier '${stepIdentifier}' not implemented`);
             }
         });
     }
     if (entryTranArgs === undefined || entryTranResult === undefined
         || execTranArgs === undefined || execTranResult === undefined) {
-        throw new factory.errors.NotFound(`beforeMedia or afterMedia of actionRecipe`);
+        throw new factory_1.factory.errors.NotFound(`beforeMedia or afterMedia of actionRecipe`);
     }
     return { entryTranArgs, entryTranResult, execTranArgs, execTranResult };
 }
@@ -78,7 +55,7 @@ function acceptAction2ticket(params) {
                 ticketToken: { $eq: ticketToken }
             }, ['ticketToken'])).shift();
             if (ticket === undefined) {
-                throw new factory.errors.NotFound('Ticket');
+                throw new factory_1.factory.errors.NotFound('Ticket');
             }
             // 承認を参照
             const validAuthorization = await repos.authorization.findValidOneByCode({
@@ -88,12 +65,12 @@ function acceptAction2ticket(params) {
             const authorizedObject = validAuthorization.object;
             if (authorizedObject.typeOf === 'OwnershipInfo') {
                 const { typeOfGood } = authorizedObject;
-                if (typeOfGood.typeOf === factory.service.paymentService.PaymentServiceType.CreditCard
-                    || typeOfGood.typeOf === factory.service.paymentService.PaymentServiceType.MovieTicket
-                    || typeOfGood.typeOf === factory.service.paymentService.PaymentServiceType.FaceToFace) {
+                if (typeOfGood.typeOf === factory_1.factory.service.paymentService.PaymentServiceType.CreditCard
+                    || typeOfGood.typeOf === factory_1.factory.service.paymentService.PaymentServiceType.MovieTicket
+                    || typeOfGood.typeOf === factory_1.factory.service.paymentService.PaymentServiceType.FaceToFace) {
                     if (acceptPayAction.object.transactionNumber !== typeOfGood.serviceOutput.paymentMethodId) {
                         // 念のため決済方法IDの一致検証
-                        throw new factory.errors.Internal('acceptPayAction.object.transactionNumber must be the same as typeOfGood.serviceOutput.paymentMethodId');
+                        throw new factory_1.factory.errors.Internal('acceptPayAction.object.transactionNumber must be the same as typeOfGood.serviceOutput.paymentMethodId');
                     }
                     acceptAction2ticketResult = {
                         invoiceByTicketToken: typeOfGood.serviceOutput,
@@ -101,11 +78,11 @@ function acceptAction2ticket(params) {
                     };
                 }
                 else {
-                    throw new factory.errors.Argument('ticketToken', `invalid typeOfGood.typeOf ${typeOfGood.typeOf}`);
+                    throw new factory_1.factory.errors.Argument('ticketToken', `invalid typeOfGood.typeOf ${typeOfGood.typeOf}`);
                 }
             }
             else {
-                throw new factory.errors.Argument('ticketToken', 'must be OwnershipInfo');
+                throw new factory_1.factory.errors.Argument('ticketToken', 'must be OwnershipInfo');
             }
         }
         return { acceptAction2ticketResult };
@@ -125,24 +102,32 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
         const paymentMethodByTransaction = await repos.placeOrder.findInProgressPaymentMethodId({ id: params.transaction.id });
         if (params.prePublishedPaymentMethodId === paymentMethodByTransaction?.paymentMethodId) {
             // check existence of acceptAction when authorizing payment(2024-06-01~)
-            acceptPayAction = (await repos.action.search({
-                limit: 1,
-                page: 1,
-                project: { id: { $eq: params.transaction.project.id } },
-                typeOf: { $eq: factory.actionType.AcceptAction },
-                actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
-                purpose: { id: { $in: [params.transaction.id] } },
-                object: {
-                    transactionNumber: { $eq: params.prePublishedPaymentMethodId },
-                    typeOf: { $eq: factory.assetTransactionType.Pay }
-                }
+            // acceptPayAction = (<Pick<IAcceptPayAction, 'object' | 'result' | 'id' | 'instrument'>[]>await repos.action.search<factory.actionType.AcceptAction>(
+            //     {
+            //         limit: 1,
+            //         page: 1,
+            //         project: { id: { $eq: params.transaction.project.id } },
+            //         typeOf: { $eq: factory.actionType.AcceptAction },
+            //         actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
+            //         purpose: { id: { $in: [params.transaction.id] } },
+            //         object: {
+            //             transactionNumber: { $eq: params.prePublishedPaymentMethodId },
+            //             typeOf: { $eq: factory.assetTransactionType.Pay }
+            //         }
+            //     },
+            //     ['object', 'result', 'instrument']
+            // )).shift();
+            acceptPayAction = (await repos.acceptPayAction.findCompletedAcceptActionsByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                purpose: { id: params.transaction.id },
+                object: { transactionNumber: params.prePublishedPaymentMethodId }
             }, ['object', 'result', 'instrument'])).shift();
             if (acceptPayAction === undefined) {
-                throw new factory.errors.NotFound(factory.actionType.AcceptAction);
+                throw new factory_1.factory.errors.NotFound(factory_1.factory.actionType.AcceptAction);
             }
             debug('acceptPayAction found:', acceptPayAction.id);
             // find recipe(2024-06-02~)
-            const actionRecipe = await repos.action.findRecipeByAction({
+            const actionRecipe = await repos.acceptPayAction.findRecipeByAction({
                 project: { id: params.transaction.project.id },
                 recipeFor: { id: acceptPayAction.id }
             });
@@ -163,21 +148,30 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
                 // pendingPaymentAgencyTransaction = { entryTranArgs, entryTranResult, execTranArgs, execTranResult };
             }
             if (creditCard === undefined) {
-                throw new factory.errors.Argument('paymentMethodId', 'creditCard not found');
+                throw new factory_1.factory.errors.Argument('paymentMethodId', 'creditCard not found');
             }
             if (pendingPaymentAgencyTransaction === undefined) {
-                throw new factory.errors.Argument('paymentMethodId', 'pendingPaymentAgencyTransaction not found');
+                throw new factory_1.factory.errors.Argument('paymentMethodId', 'pendingPaymentAgencyTransaction not found');
             }
             // 既に承認済であれば何もしない(2023-05-15~)
-            const existingCompletedAuthorizeActions = await repos.action.searchByPurpose({
-                typeOf: factory.actionType.AuthorizeAction,
+            // const existingCompletedAuthorizeActions = <IAuthorizePaymentAction[]>
+            //     await repos.action.searchByPurpose<factory.actionType.AuthorizeAction>({
+            //         typeOf: factory.actionType.AuthorizeAction,
+            //         purpose: { id: params.transaction.id, typeOf: params.transaction.typeOf },
+            //         actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus },
+            //         object: {
+            //             paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
+            //             typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+            //         },
+            //         sort: { startDate: factory.sortType.Ascending }
+            //     });
+            const existingCompletedAuthorizeActions = await repos.authorizePaymentMethodAction.findAuthorizePaymentMethodActionsByPurpose({
                 purpose: { id: params.transaction.id, typeOf: params.transaction.typeOf },
-                actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus },
+                actionStatus: { $eq: factory_1.factory.actionStatusType.CompletedActionStatus },
                 object: {
-                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
-                    typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId }
                 },
-                sort: { startDate: factory.sortType.Ascending }
+                sort: { startDate: factory_1.factory.sortType.Ascending }
             });
             existingCompletedAuthorizeAction = existingCompletedAuthorizeActions.shift();
             if (existingCompletedAuthorizeAction !== undefined) {
@@ -196,7 +190,7 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
         }
         else {
             // 取引にないpaymentMethodIdの指定はクライアントエラー
-            throw new factory.errors.Argument('paymentMethodId', 'invalid paymentMethodId for the transaction');
+            throw new factory_1.factory.errors.Argument('paymentMethodId', 'invalid paymentMethodId for the transaction');
         }
     };
 }
@@ -212,15 +206,15 @@ function validatePaymentMethodByTransaction(params) {
     const paymentMethodTypeByTransaction = params.acceptObject.object.paymentMethod?.identifier;
     // 決済サービスID検証
     if (paymentServiceIdByObject !== paymentServiceIdByTransaction) {
-        throw new factory.errors.Argument('object.issuedThrough.id', 'issuedThrough.id must match the target of the paymentUrl');
+        throw new factory_1.factory.errors.Argument('object.issuedThrough.id', 'issuedThrough.id must match the target of the paymentUrl');
     }
     // 金額検証
     if (amountByObject !== amountByTransaction) {
-        throw new factory.errors.Argument('object.amount', 'amount must match the target of the paymentUrl');
+        throw new factory_1.factory.errors.Argument('object.amount', 'amount must match the target of the paymentUrl');
     }
     // 決済方法区分検証
     if (paymentMethodTypeByObject !== paymentMethodTypeByTransaction) {
-        throw new factory.errors.Argument('object.paymentMethod', 'paymentMethod must match the target of the paymentUrl');
+        throw new factory_1.factory.errors.Argument('object.paymentMethod', 'paymentMethod must match the target of the paymentUrl');
     }
     // 注文アイテム検証(2025-11-25)
     let eventIdsMustBe = [];
@@ -238,6 +232,6 @@ function validatePaymentMethodByTransaction(params) {
     const eventIdsMatched = eventIdsMustBe.length === eventIdsByAuthorizeAction.length
         && eventIdsMustBe.every((eventIdMustExist) => eventIdsByAuthorizeAction.includes(eventIdMustExist));
     if (!eventIdsMatched) {
-        throw new factory.errors.Argument('id', `referencesOrder.orderedItem between authorze and accept not matched.`);
+        throw new factory_1.factory.errors.Argument('id', `referencesOrder.orderedItem between authorze and accept not matched.`);
     }
 }

package/lib/chevre/service/payment/any/authorize.d.ts

@@ -0,0 +1,103 @@
+import { factory } from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { PayActionRepo } from '../../../repo/action/pay';
+import type { RefundActionRepo } from '../../../repo/action/refund';
+import type { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { AuthorizationRepo } from '../../../repo/authorization';
+import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
+import type { CredentialsRepo } from '../../../repo/credentials';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { IssuerRepo } from '../../../repo/issuer';
+import type { OrderNumberRepo } from '../../../repo/orderNumber';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { PotentialActionRepo } from '../../../repo/potentialAction';
+import type { ProductRepo } from '../../../repo/product';
+import type { ProjectRepo } from '../../../repo/project';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import type { TicketRepo } from '../../../repo/ticket';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import type { TransactionNumberRepo } from '../../../repo/transactionNumber';
+interface IAuthorizeRepos {
+    accountingReport: AccountingReportRepo;
+    action?: never;
+    actions: {
+        pay: PayActionRepo;
+        refund: RefundActionRepo;
+    };
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    authorization: AuthorizationRepo;
+    confirmationNumber: ConfirmationNumberRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    issuer: IssuerRepo;
+    orderNumber: OrderNumberRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    potentialAction: PotentialActionRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    task: TaskRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+type IAuthorizeOperation<T> = (repos: IAuthorizeRepos, settings: Settings) => Promise<T>;
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
+    ticketToken?: string;
+};
+/**
+ * 決済承認
+ * CreditCard,MovieTicket -> 決済承認タスクから呼ばれる
+ * FaceToFace,PaymentCard -> apiから呼ばれる
+ */
+declare function authorize(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: IObjectWithoutDetail;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+    location?: factory.action.trade.pay.ILocation;
+    options: {
+        /**
+         * アクション失敗時に即時に決済取引を中止するかどうか
+         */
+        useCancelPayTransactionOnFailed: boolean;
+        checkedAction: {
+            id: string;
+        };
+    };
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+    /**
+     * ツールとしての対応決済方法オファー
+     */
+    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
+}): IAuthorizeOperation<{
+    /**
+     * 承認アクションID
+     */
+    id: string;
+}>;
+export { authorize, IAuthorizeRepos };

package/lib/chevre/service/payment/any/authorize.js

@@ -0,0 +1,252 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorize = authorize;
+const util_1 = require("util");
+const factory_1 = require("../../../factory");
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+const fixTransactionNumber_1 = require("./authorize/fixTransactionNumber");
+const factory_2 = require("./factory");
+const fixOrderAsNeeded_1 = require("./authorize/fixOrderAsNeeded");
+const processVoidPayTransaction_1 = require("./processVoidPayTransaction");
+/**
+ * 承認アクションオブジェクトから冗長な属性を排除する
+ */
+function minimizeObjectIncludingPaymentMethodDetails(authorizeObjectIncludingPaymentMethodDetails) {
+    const { accountId, paymentMethodId, typeOf } = authorizeObjectIncludingPaymentMethodDetails;
+    return { authorizeObject: { accountId, paymentMethodId, typeOf } }; // optimize(2024-06-26~)
+}
+/**
+ * 決済承認
+ * CreditCard,MovieTicket -> 決済承認タスクから呼ばれる
+ * FaceToFace,PaymentCard -> apiから呼ばれる
+ */
+function authorize(params) {
+    return async (repos, settings) => {
+        const { paymentServiceType, purpose, project } = params;
+        if (purpose.typeOf !== factory_1.factory.transactionType.PlaceOrder) {
+            throw new factory_1.factory.errors.NotImplemented(`purpose.typeOf '${purpose.typeOf} not implemented'`);
+        }
+        const transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: purpose.typeOf, id: purpose.id }, ['agent', 'expires', 'typeOf', 'project', 'seller']);
+        if (project.id !== transaction.project.id) {
+            throw new factory_1.factory.errors.NotFound(factory_1.factory.transactionType.PlaceOrder);
+        }
+        const { confirmationNumber, orderNumber } = await (0, fixOrderAsNeeded_1.fixOrderAsNeeded)({
+            project: { id: transaction.project.id },
+            purpose
+            // paymentServiceType
+        })(repos);
+        // 取引番号生成
+        const fixTransactionNumberResult = await (0, fixTransactionNumber_1.fixTransactionNumber)({
+            object: params.object,
+            transaction,
+            paymentServiceType
+        })({
+            acceptPayAction: repos.acceptPayAction,
+            authorizePaymentMethodAction: repos.authorizePaymentMethodAction,
+            authorization: repos.authorization,
+            ticket: repos.ticket,
+            placeOrder: repos.placeOrder,
+            transactionNumber: repos.transactionNumber
+        });
+        if (typeof fixTransactionNumberResult.id === 'string') {
+            return { id: fixTransactionNumberResult.id };
+        }
+        const { transactionNumber, pendingPaymentAgencyTransaction, creditCard, invoiceByTicketToken, ticketToken } = fixTransactionNumberResult;
+        const movieTickets = (Array.isArray(params.object.movieTickets)) ? params.object.movieTickets.map(factory_2.createMovieTicket) : undefined;
+        const { accountId } = await fixAccountIdIfPossible({
+            object: params.object, project: { id: transaction.project.id }
+        })();
+        const authorizeObjectIncludingPaymentMethodDetails = {
+            ...params.object,
+            accountId,
+            paymentMethodId: transactionNumber,
+            typeOf: factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment,
+            // support referencesOrder(2025-11-24~)
+            referencesOrder: (params.object.referencesOrder?.typeOf === factory_1.factory.order.OrderType.Order)
+                ? params.object.referencesOrder
+                : { typeOf: factory_1.factory.order.OrderType.Order },
+            ...(creditCard !== undefined) ? { creditCard } : undefined,
+            ...(Array.isArray(movieTickets)) ? { movieTickets } : undefined
+        };
+        const { authorizeObject } = minimizeObjectIncludingPaymentMethodDetails(authorizeObjectIncludingPaymentMethodDetails);
+        // 承認アクションを開始する
+        const taskId = params.sameAs?.id;
+        const uniqueActionIdentifier = (0, util_1.format)(`%s:%s:%s`, factory_1.factory.actionType.AuthorizeAction, factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment, authorizeObject.paymentMethodId);
+        const actionAttributes = {
+            project: transaction.project,
+            typeOf: factory_1.factory.actionType.AuthorizeAction,
+            object: authorizeObject,
+            agent: {
+                typeOf: transaction.agent.typeOf,
+                id: transaction.agent.id
+            },
+            instrument: {
+                typeOf: factory_1.factory.assetTransactionType.Pay, // 資産取引化(2024-03-11~)
+                identifier: factory_1.factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre,
+                transactionNumber
+            },
+            recipient: {
+                typeOf: transaction.seller.typeOf,
+                id: transaction.seller.id,
+                name: (typeof transaction.seller.name === 'string')
+                    ? transaction.seller.name
+                    : String(transaction.seller.name?.ja)
+            },
+            purpose: { typeOf: transaction.typeOf, id: transaction.id },
+            identifier: uniqueActionIdentifier, // add unique identifier(2025-02-25~)
+            ...(typeof taskId === 'string') ? { sameAs: { id: taskId, typeOf: 'Task' } } : undefined // タスク関連付け(2024-04-22~)
+        };
+        const action = await repos.authorizePaymentMethodAction.start(actionAttributes);
+        let payTransaction;
+        try {
+            const startParams = (0, factory_2.creatPayTransactionStartParams)({
+                accountId,
+                object: authorizeObjectIncludingPaymentMethodDetails,
+                paymentServiceType,
+                transaction: transaction,
+                transactionNumber: transactionNumber,
+                location: params.location,
+                // confirmationNumber required(2025-02-12~)
+                // orderNumber required(2025-02-14~)
+                order: { confirmationNumber, orderNumber },
+                action: { id: action.id, typeOf: action.typeOf },
+                ticketToken,
+                instrument: params.instrument
+            });
+            payTransaction = await PayTransactionService.start(startParams, {
+                // useCheckByIdentifierIfNotYet: params.options.useCheckByIdentifierIfNotYet,
+                executor: (typeof taskId === 'string') ? { id: taskId } : {}, // タスク関連付け(2024-05-18~)
+                purpose: { id: transaction.id },
+                checkedAction: params.options.checkedAction,
+                ...(pendingPaymentAgencyTransaction !== undefined) ? { pendingPaymentAgencyTransaction } : undefined
+            })(repos, settings);
+        }
+        catch (error) {
+            try {
+                await repos.authorizePaymentMethodAction.giveUp({ typeOf: action.typeOf, id: action.id, error });
+            }
+            catch (__) {
+                // no op
+            }
+            // 即時に決済取引を中止するか？(2023-02-03~)
+            if (params.options.useCancelPayTransactionOnFailed) {
+                // abortエラーの場合は状態不明なので即時中止しない(2023-06-01~)
+                // {
+                //     "type": "aborted",
+                //     "message": "The user aborted a request.",
+                //     "name": "AbortError"
+                // }
+                const rawError = Array.isArray(error) ? error[1] : undefined;
+                if (rawError !== undefined
+                    && rawError.name !== 'AbortError'
+                    && rawError.name !== 'TimeoutError' // native AbortSignalの場合
+                ) {
+                    await (0, processVoidPayTransaction_1.processVoidPayTransaction)({
+                        project: actionAttributes.project,
+                        id: action.id,
+                        purpose: actionAttributes.purpose
+                    })({
+                        authorizePaymentMethodAction: repos.authorizePaymentMethodAction,
+                        accountingReport: repos.accountingReport,
+                        assetTransaction: repos.assetTransaction,
+                        task: repos.task,
+                        placeOrder: repos.placeOrder,
+                        // transaction: TransactionRepo;
+                    });
+                }
+            }
+            // 複数対応(決済代行IFの場合、0:ChevreError,1:rawError)(2024-03-27~)
+            if (Array.isArray(error)) {
+                throw error[0];
+            }
+            else {
+                throw error;
+            }
+        }
+        const result = (0, factory_2.createAuthorizeResult)({
+            payTransaction,
+            object: authorizeObjectIncludingPaymentMethodDetails,
+            invoiceByTicketToken
+        });
+        await repos.authorizePaymentMethodAction.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
+        return { id: action.id };
+    };
+}
+/**
+ * 承認しようとしているobjectからaccountIdを決定する
+ */
+function fixAccountIdIfPossible(params) {
+    return async (
+    // repos: {
+    //     action: ActionRepo;
+    //     authorization: AuthorizationRepo;
+    //     ticket: TicketRepo;
+    // }
+    // credentials: {
+    //     jwt: JWTCredentials;
+    // }
+    ) => {
+        let accountId = '';
+        const fromLocation = params.object?.fromLocation;
+        const movieTickets = params.object?.movieTickets;
+        // discontinue token as fromLocation(ticketTokenへ移行するべき)(2024-12-18~)
+        if (typeof fromLocation === 'string') {
+            throw new factory_1.factory.errors.NotImplemented('object.fromLocation as string not implemented');
+            // トークン化されたペイメントカード情報でリクエストされた場合、実ペイメントカード情報へ変換する
+            // const { authorizedObject } = await verifyToken({
+            //     project: { id: params.project.id },
+            //     agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+            //     token: fromLocation
+            // })(repos);
+            // const paymentCardOwnershipInfo = authorizedObject;
+            // if (Array.isArray(paymentCardOwnershipInfo)) {
+            //     throw new factory.errors.NotImplemented('fromLocation as an array not implemented');
+            // }
+            // if (paymentCardOwnershipInfo.typeOf !== 'OwnershipInfo') {
+            //     throw new factory.errors.Argument('fromLocation', 'must be OwnershipInfo');
+            // }
+            // if (paymentCardOwnershipInfo.typeOfGood.typeOf !== factory.permit.PermitType.Permit) {
+            //     throw new factory.errors.Argument('fromLocation', 'must be Permit');
+            // }
+            // accountId = paymentCardOwnershipInfo.typeOfGood.identifier;
+        }
+        // 購入番号管理番号をaccountIdにセット(2024-03-24~)
+        if (Array.isArray(movieTickets) && movieTickets.length > 0) {
+            accountId = movieTickets[0].identifier; // 決済カードidentifierは1つのみ許可の前提
+        }
+        return { accountId };
+    };
+}

package/lib/chevre/service/payment/any/factory.d.ts

@@ -1,4 +1,4 @@
-import * as factory from '../../../factory';
+import { factory } from '../../../factory';
 /**
  * 決済方法チケットによって表現された請求情報
  */