@chevre/domain 24.0.0-alpha.24 → 24.0.0-alpha.26

package/lib/chevre/repo/action/acceptPay.d.ts

@@ -1,8 +1,33 @@
 import * as factory from '../../factory';
-import { IActionRecipe, ActionProcessRepo } from './actionProcess';
+import { IKeyOfProjection, IActionRecipe, ActionProcessRepo } from './actionProcess';
 export type IAcceptPayAction = factory.action.accept.pay.IAction;
 /**
  * 決済採用リポジトリ
  */
 export declare class AcceptPayActionRepo extends ActionProcessRepo<IAcceptPayAction, IActionRecipe<factory.recipe.RecipeCategory.publishPaymentUrl>> {
+    /**
+     * 注文取引から検索する
+     */
+    findAcceptActionsByPurpose(params: {
+        project: {
+            id: string;
+        };
+        purpose: {
+            id: string;
+        };
+    }, inclusion: IKeyOfProjection[]): Promise<IAcceptPayAction[]>;
+    /**
+     * 決済取引番号から完了済の決済採用アクションを参照する
+     */
+    findCompletedAcceptActionsByTransactionNumber(params: {
+        project: {
+            id: string;
+        };
+        purpose: {
+            id: string;
+        };
+        object: {
+            transactionNumber: string;
+        };
+    }, inclusion: IKeyOfProjection[]): Promise<IAcceptPayAction[]>;
 }

package/lib/chevre/repo/action/acceptPay.js

@@ -1,7 +1,31 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcceptPayActionRepo = void 0;
-// import { MONGO_MAX_TIME_MS } from '../settings';
+const factory = __importStar(require("../../factory"));
+const settings_1 = require("../../settings");
 // import { createSchema, IModel as IActionModel, modelName } from './mongoose/schemas/action';
 // import { createSchema as createRecipeSchema, IModel as IActionRecipeModel, modelName as recipeModelName } from './mongoose/schemas/actionRecipe';
 const actionProcess_1 = require("./actionProcess");
@@ -9,5 +33,67 @@ const actionProcess_1 = require("./actionProcess");
  * 決済採用リポジトリ
  */
 class AcceptPayActionRepo extends actionProcess_1.ActionProcessRepo {
+    /**
+     * 注文取引から検索する
+     */
+    async findAcceptActionsByPurpose(params, inclusion) {
+        const andConditions = [
+            { typeOf: { $eq: factory.actionType.AcceptAction } },
+            { 'project.id': { $eq: params.project.id } },
+            { 'object.typeOf': { $exists: true, $eq: factory.assetTransactionType.Pay } },
+            { 'purpose.id': { $exists: true, $eq: params.purpose.id } }
+        ];
+        let positiveProjectionFields = actionProcess_1.AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = inclusion.filter((key) => actionProcess_1.AVAILABLE_PROJECT_FIELDS.includes(key));
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const query = this.actionModel.find({ $and: andConditions }, projection);
+        // if (typeof params.limit === 'number' && params.limit > 0) {
+        //     const page: number = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
+        //     query.limit(params.limit)
+        //         .skip(params.limit * (page - 1));
+        // }
+        // /* istanbul ignore else */
+        // if (params.sort?.startDate !== undefined) {
+        //     query.sort({ startDate: params.sort.startDate });
+        // }
+        // const explainResult = await (<any>query).explain();
+        // console.log(explainResult[0].executionStats.allPlansExecution.map((e: any) => e.executionStages.inputStage));
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
+    /**
+     * 決済取引番号から完了済の決済採用アクションを参照する
+     */
+    async findCompletedAcceptActionsByTransactionNumber(params, inclusion) {
+        const andConditions = [
+            { typeOf: { $eq: factory.actionType.AcceptAction } },
+            { actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus } },
+            { 'project.id': { $eq: params.project.id } },
+            { 'purpose.id': { $exists: true, $eq: params.purpose.id } },
+            { 'object.typeOf': { $exists: true, $eq: factory.assetTransactionType.Pay } },
+            { 'object.transactionNumber': { $exists: true, $eq: params.object.transactionNumber } }
+        ];
+        let positiveProjectionFields = actionProcess_1.AVAILABLE_PROJECT_FIELDS;
+        if (Array.isArray(inclusion) && inclusion.length > 0) {
+            positiveProjectionFields = inclusion.filter((key) => actionProcess_1.AVAILABLE_PROJECT_FIELDS.includes(key));
+        }
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const query = this.actionModel.find({ $and: andConditions }, projection);
+        query.limit(1); // ひとまず1つだけでよい
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
 }
 exports.AcceptPayActionRepo = AcceptPayActionRepo;

package/lib/chevre/repo/action/authorizePaymentMethod.d.ts

@@ -0,0 +1,36 @@
+import * as factory from '../../factory';
+import { ActionProcessRepo } from './actionProcess';
+export type IAuthorizePaymentMethodAction = factory.action.authorize.paymentMethod.any.IAction;
+export type IActionRecipe = never;
+/**
+ * 決済承認リポジトリ
+ */
+export declare class AuthorizePaymentMethodActionRepo extends ActionProcessRepo<IAuthorizePaymentMethodAction, IActionRecipe> {
+    /**
+     * 取引に対する決済承認アクションを検索する
+     */
+    findAuthorizePaymentMethodActionsByPurpose(params: {
+        /**
+         * 注文取引でフィルター
+         */
+        purpose: {
+            typeOf: factory.transactionType;
+            id: string;
+        };
+        /**
+         * 決済取引番号でフィルター
+         */
+        object?: {
+            paymentMethodId?: {
+                $eq?: string;
+            };
+        };
+        /**
+         * アクションステータスでフィルター
+         */
+        actionStatus?: {
+            $eq?: factory.actionStatusType.CompletedActionStatus;
+        };
+        sort?: factory.action.ISortOrder;
+    }): Promise<IAuthorizePaymentMethodAction[]>;
+}

package/lib/chevre/repo/action/authorizePaymentMethod.js

@@ -0,0 +1,88 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizePaymentMethodActionRepo = void 0;
+const factory = __importStar(require("../../factory"));
+const settings_1 = require("../../settings");
+// import { createSchema, IModel as IActionModel, modelName } from './mongoose/schemas/action';
+// import { createSchema as createRecipeSchema, IModel as IActionRecipeModel, modelName as recipeModelName } from './mongoose/schemas/actionRecipe';
+const actionProcess_1 = require("./actionProcess");
+/**
+ * 決済承認リポジトリ
+ */
+class AuthorizePaymentMethodActionRepo extends actionProcess_1.ActionProcessRepo {
+    /**
+     * 取引に対する決済承認アクションを検索する
+     */
+    async findAuthorizePaymentMethodActionsByPurpose(params) {
+        const andConditions = [
+            { typeOf: { $eq: factory.actionType.AuthorizeAction } },
+            { 'purpose.typeOf': { $exists: true, $eq: params.purpose.typeOf } },
+            { 'purpose.id': { $exists: true, $eq: params.purpose.id } },
+            { 'object.typeOf': { $exists: true, $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment } }
+        ];
+        const objectPaymentMethodIdEq = params.object?.paymentMethodId?.$eq;
+        if (typeof objectPaymentMethodIdEq === 'string') {
+            andConditions.push({ 'object.paymentMethodId': { $exists: true, $eq: objectPaymentMethodIdEq } });
+        }
+        const actionStatusEq = params.actionStatus?.$eq;
+        if (typeof actionStatusEq === 'string') {
+            andConditions.push({ actionStatus: { $eq: actionStatusEq } });
+        }
+        const positiveProjectionFields = [
+            'project',
+            'actionStatus',
+            'typeOf',
+            'description',
+            'agent',
+            'recipient',
+            'result',
+            'error',
+            'object',
+            'startDate',
+            'endDate',
+            'purpose',
+            'potentialActions',
+            'instrument',
+            'location',
+            'sameAs',
+            'cancelAction',
+            'identifier'
+        ];
+        const projection = {
+            _id: 0,
+            id: { $toString: '$_id' },
+            ...Object.fromEntries(positiveProjectionFields.map((key) => ([key, 1])))
+        };
+        const query = this.actionModel.find({ $and: andConditions }, projection);
+        if (typeof params.sort?.startDate === 'number') {
+            query.sort({ startDate: params.sort.startDate });
+        }
+        return query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .lean()
+            .exec();
+    }
+}
+exports.AuthorizePaymentMethodActionRepo = AuthorizePaymentMethodActionRepo;

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

@@ -16,7 +16,7 @@ export declare class ActionRepo extends ActionProcessRepo<IAction<StartableActio
     /**
      * アクション検索
      */
-    search<T extends factory.actionType>(params: factory.action.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IAction<T>[]>;
+    search<T extends StartableActionType>(params: factory.action.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IAction<T>[]>;
     findPayAction(params: {
         project: {
             id: string;

package/lib/chevre/repository.d.ts

@@ -12,6 +12,7 @@ import type { AcceptCOAOfferActionRepo } from './repo/action/acceptCOAOffer';
 import type { AcceptPayActionRepo } from './repo/action/acceptPay';
 import type { AuthorizeInvoiceActionRepo } from './repo/action/authorizeInvoice';
 import type { AuthorizeOfferActionRepo } from './repo/action/authorizeOffer';
+import type { AuthorizePaymentMethodActionRepo } from './repo/action/authorizePaymentMethod';
 import type { CheckMovieTicketActionRepo } from './repo/action/checkMovieTicket';
 import type { CheckThingActionRepo } from './repo/action/checkThing';
 import type { AdditionalPropertyRepo } from './repo/additionalProperty';
@@ -147,6 +148,10 @@ export declare namespace action {
     namespace AuthorizeOffer {
         function createInstance(...params: ConstructorParameters<typeof AuthorizeOfferActionRepo>): Promise<AuthorizeOfferActionRepo>;
     }
+    type AuthorizePaymentMethodAction = AuthorizePaymentMethodActionRepo;
+    namespace AuthorizePaymentMethodAction {
+        function createInstance(...params: ConstructorParameters<typeof AuthorizePaymentMethodActionRepo>): Promise<AuthorizePaymentMethodActionRepo>;
+    }
     type CheckMovieTicket = CheckMovieTicketActionRepo;
     namespace CheckMovieTicket {
         function createInstance(...params: ConstructorParameters<typeof CheckMovieTicketActionRepo>): Promise<CheckMovieTicketActionRepo>;

package/lib/chevre/repository.js

@@ -148,6 +148,17 @@ var action;
         }
         AuthorizeOffer.createInstance = createInstance;
     })(AuthorizeOffer = action.AuthorizeOffer || (action.AuthorizeOffer = {}));
+    let AuthorizePaymentMethodAction;
+    (function (AuthorizePaymentMethodAction) {
+        let repo;
+        async function createInstance(...params) {
+            if (repo === undefined) {
+                repo = (await Promise.resolve().then(() => __importStar(require('./repo/action/authorizePaymentMethod')))).AuthorizePaymentMethodActionRepo;
+            }
+            return new repo(...params);
+        }
+        AuthorizePaymentMethodAction.createInstance = createInstance;
+    })(AuthorizePaymentMethodAction = action.AuthorizePaymentMethodAction || (action.AuthorizePaymentMethodAction = {}));
     let CheckMovieTicket;
     (function (CheckMovieTicket) {
         let repo;

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

@@ -1,5 +1,6 @@
 import * as factory from '../../../../factory';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../../repo/action/authorizePaymentMethod';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
 import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
@@ -7,7 +8,9 @@ import type { TransactionNumberRepo } from '../../../../repo/transactionNumber';
 import * as PayTransactionService from '../../../assetTransaction/pay';
 import { IInvoiceByTicketToken } from '../factory';
 interface IFixTransactionNumberRepos {
-    action: ActionRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     authorization: AuthorizationRepo;
     ticket: TicketRepo;
     placeOrder: PlaceOrderRepo;

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

@@ -1,5 +1,6 @@
 import * as factory from '../../../../factory';
-import type { ActionRepo } from '../../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../../repo/action/authorizePaymentMethod';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
 import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
@@ -10,6 +11,14 @@ interface IAcceptAction2ticketResult {
     invoiceByTicketToken: IInvoiceByTicketToken;
     ticketToken: string;
 }
+interface IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos {
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    authorization: AuthorizationRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+}
 /**
  * 決済承認前の決済採用アクションを参照する
  */
@@ -17,12 +26,7 @@ declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
     object: Pick<IObjectWithoutDetail, 'amount' | 'issuedThrough' | 'paymentMethod' | 'referencesOrder'>;
     prePublishedPaymentMethodId: string;
     transaction: Pick<ITransactionInProgress, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
-}): (repos: {
-    action: ActionRepo;
-    authorization: AuthorizationRepo;
-    ticket: TicketRepo;
-    placeOrder: PlaceOrderRepo;
-}) => Promise<{
+}): (repos: IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos) => Promise<{
     authorizeParams?: {
         creditCard: factory.action.authorize.paymentMethod.any.ICreditCard;
         paymentMethodByTransaction: factory.transaction.placeOrder.IPaymentMethodByPaymentUrl;
@@ -37,4 +41,4 @@ declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
     authorizeParams?: never;
     acceptAction2ticketResult?: never;
 }>;
-export { handlePrePublishedPaymentMethodIdOnAuthorizing };
+export { IHandlePrePublishedPaymentMethodIdOnAuthorizingRepos, handlePrePublishedPaymentMethodIdOnAuthorizing };

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

@@ -125,24 +125,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);
             }
             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 }
             });
@@ -169,13 +177,22 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
                 throw new 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 },
                 object: {
-                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId },
-                    typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment }
+                    paymentMethodId: { $eq: params.prePublishedPaymentMethodId }
                 },
                 sort: { startDate: factory.sortType.Ascending }
             });

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

@@ -4,7 +4,9 @@ import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMet
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
 import type { ActionRepo } from '../../../repo/action';
 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';
@@ -27,7 +29,9 @@ interface IAuthorizeRepos {
     accountingReport: AccountingReportRepo;
     action: ActionRepo;
     checkMovieTicketAction: CheckMovieTicketActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
     authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     assetTransaction: AssetTransactionRepo;
     authorization: AuthorizationRepo;
     confirmationNumber: ConfirmationNumberRepo;

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

@@ -63,7 +63,14 @@ function authorize(params) {
             object: params.object,
             transaction,
             paymentServiceType
-        })(repos);
+        })({
+            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 };
         }
@@ -112,7 +119,7 @@ function authorize(params) {
             identifier: uniqueActionIdentifier, // add unique identifier(2025-02-25~)
             ...(typeof taskId === 'string') ? { sameAs: { id: taskId, typeOf: 'Task' } } : undefined // タスク関連付け(2024-04-22~)
         };
-        const action = await repos.action.start(actionAttributes);
+        const action = await repos.authorizePaymentMethodAction.start(actionAttributes);
         let payTransaction;
         try {
             const startParams = (0, factory_1.creatPayTransactionStartParams)({
@@ -139,7 +146,7 @@ function authorize(params) {
         }
         catch (error) {
             try {
-                await repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error });
+                await repos.authorizePaymentMethodAction.giveUp({ typeOf: action.typeOf, id: action.id, error });
             }
             catch (__) {
                 // no op
@@ -158,7 +165,14 @@ function authorize(params) {
                         project: actionAttributes.project,
                         id: action.id,
                         purpose: actionAttributes.purpose
-                    })(repos);
+                    })({
+                        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~)
@@ -174,7 +188,7 @@ function authorize(params) {
             object: authorizeObjectIncludingPaymentMethodDetails,
             invoiceByTicketToken
         });
-        await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
+        await repos.authorizePaymentMethodAction.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
         return { id: action.id };
     };
 }

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

@@ -1,5 +1,5 @@
 import * as factory from '../../../factory';
-import type { ActionRepo } from '../../../repo/action';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
 import type { TaskRepo } from '../../../repo/task';
 interface IFindAuthorizeActionResult {
     /**
@@ -18,6 +18,10 @@ interface IFindAuthorizeActionResult {
         message?: string;
     };
 }
+interface IFindAuthorizeActionRepos {
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    task: TaskRepo;
+}
 declare function findAuthorizeAction(params: {
     project: {
         id: string;
@@ -34,8 +38,5 @@ declare function findAuthorizeAction(params: {
          */
         id: string;
     };
-}): (repos: {
-    action: ActionRepo;
-    task: TaskRepo;
-}) => Promise<IFindAuthorizeActionResult>;
-export { findAuthorizeAction, };
+}): (repos: IFindAuthorizeActionRepos) => Promise<IFindAuthorizeActionResult>;
+export { IFindAuthorizeActionRepos, findAuthorizeAction, };

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

@@ -55,7 +55,7 @@ function findAuthorizeAction(params) {
                 break;
             default:
                 // タスクがReadyでなければアクション検索
-                const authorizeAction = (await repos.action.searchBySameAs({
+                const authorizeAction = (await repos.authorizePaymentMethodAction.searchBySameAs({
                     sameAs: { id: { $eq: task.id } },
                     typeOf: { $eq: factory.actionType.AuthorizeAction }
                     // purpose: { id: { $eq: String(params.purpose.id) } }

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

@@ -1,6 +1,6 @@
 import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
@@ -9,7 +9,8 @@ import type { TaskRepo } from '../../../repo/task';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 interface IInvalidatePaymentUrlRepos {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
     assetTransaction: AssetTransactionRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;

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

@@ -47,15 +47,17 @@ function invalidatePaymentUrl(params) {
         //     }
         // }
         // support multiple accept actions(2025-02-25~)
-        let acceptPayActions = await repos.action.search({
-            project: { id: { $eq: transaction.project.id } },
-            typeOf: { $eq: factory.actionType.AcceptAction },
-            // actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] }, // all statuses(2025-02-26~)
-            purpose: { id: { $in: [transaction.id] } },
-            object: {
-                // transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
-                typeOf: { $eq: factory.assetTransactionType.Pay }
-            }
+        let acceptPayActions = await repos.acceptPayAction.findAcceptActionsByPurpose({
+            // project: { id: { $eq: transaction.project.id } },
+            // typeOf: { $eq: factory.actionType.AcceptAction },
+            // // actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] }, // all statuses(2025-02-26~)
+            // purpose: { id: { $in: [transaction.id] } },
+            // object: {
+            //     // transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
+            //     typeOf: { $eq: factory.assetTransactionType.Pay }
+            // }
+            project: { id: transaction.project.id },
+            purpose: { id: transaction.id },
         }, ['object']);
         switch (transaction.status) {
             case factory.transactionStatusType.InProgress:

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

@@ -1,11 +1,12 @@
 import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { TaskRepo } from '../../../repo/task';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 interface IProcessVoidPayTransactionRepos {
-    action: ActionRepo;
+    action?: never;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     accountingReport: AccountingReportRepo;
     assetTransaction: AssetTransactionRepo;
     task: TaskRepo;

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

@@ -48,7 +48,7 @@ function processVoidPayTransaction(params) {
         // 承認アクションを取得
         let authorizeActions;
         if (typeof params.id === 'string') {
-            const authorizeAction = await repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            const authorizeAction = await repos.authorizePaymentMethodAction.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
             // 取引内のアクションかどうか確認
             if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
                 throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
@@ -56,10 +56,10 @@ function processVoidPayTransaction(params) {
             authorizeActions = [authorizeAction];
         }
         else {
-            authorizeActions = await repos.action.searchByPurpose({
-                typeOf: factory.actionType.AuthorizeAction,
+            authorizeActions = await repos.authorizePaymentMethodAction.findAuthorizePaymentMethodActionsByPurpose({
+                // typeOf: factory.actionType.AuthorizeAction,
                 purpose: { typeOf: transaction.typeOf, id: transaction.id },
-                object: { typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment } }
+                // object: { typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment } }
             });
             switch (transaction.status) {
                 case factory.transactionStatusType.InProgress:
@@ -94,7 +94,7 @@ function processVoidPayTransaction(params) {
         for (const action of authorizeActions) {
             // 失敗するケースがあっても、残りが少なくとも処理されるようにエラーハンドリング
             try {
-                await repos.action.cancelWithVoid({ typeOf: action.typeOf, id: action.id, cancelAction });
+                await repos.authorizePaymentMethodAction.cancelWithVoid({ typeOf: action.typeOf, id: action.id, cancelAction });
                 // 取引が存在すれば中止
                 const transactionNumber = action.object.paymentMethodId;
                 if (typeof transactionNumber === 'string' && transactionNumber.length > 0) {

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

@@ -1,6 +1,7 @@
 import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
-import type { ActionRepo } from '../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { PaymentServiceRepo } from '../../../repo/paymentService';
 import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
@@ -20,7 +21,9 @@ declare function voidPayTransaction(params: factory.task.IData<factory.taskName.
     };
 }): (repos: {
     accountingReport: AccountingReportRepo;
-    action: ActionRepo;
+    action?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
     assetTransaction: AssetTransactionRepo;
     paymentAccepted: SellerPaymentAcceptedRepo;
     paymentService: PaymentServiceRepo;

package/lib/chevre/service/task/authorizePayment.js

@@ -29,7 +29,9 @@ const acceptedPaymentMethod_1 = require("../../repo/acceptedPaymentMethod");
 const accountingReport_1 = require("../../repo/accountingReport");
 const action_1 = require("../../repo/action");
 const checkMovieTicket_1 = require("../../repo/action/checkMovieTicket");
+const acceptPay_1 = require("../../repo/action/acceptPay");
 const authorizeInvoice_1 = require("../../repo/action/authorizeInvoice");
+const authorizePaymentMethod_1 = require("../../repo/action/authorizePaymentMethod");
 const assetTransaction_1 = require("../../repo/assetTransaction");
 const authorization_1 = require("../../repo/authorization");
 const confirmationNumber_1 = require("../../repo/confirmationNumber");
@@ -63,7 +65,8 @@ function call(params) {
             return;
         }
         let callResult;
-        const actionRepo = new action_1.ActionRepo(connection);
+        // const actionRepo = new ActionRepo(connection);
+        const authorizePaymentMethodActionRepo = new authorizePaymentMethod_1.AuthorizePaymentMethodActionRepo(connection);
         // const transactionProcessRepo = new TransactionProcessRepo(redisClient, { lockExpiresInSeconds: 120 });
         const paymentServiceId = params.data.object.issuedThrough.id;
         const credentialsExpireInSeconds = settings.movieticketReserve.credentialsExpireInSeconds;
@@ -77,9 +80,11 @@ function call(params) {
             })({
                 acceptedPaymentMethod: new acceptedPaymentMethod_1.AcceptedPaymentMethodRepo(connection),
                 accountingReport: new accountingReport_1.AccountingReportRepo(connection),
-                action: actionRepo,
+                action: new action_1.ActionRepo(connection),
                 checkMovieTicketAction: new checkMovieTicket_1.CheckMovieTicketActionRepo(connection),
+                acceptPayAction: new acceptPay_1.AcceptPayActionRepo(connection),
                 authorizeInvoiceAction: new authorizeInvoice_1.AuthorizeInvoiceActionRepo(connection),
+                authorizePaymentMethodAction: authorizePaymentMethodActionRepo,
                 assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
                 authorization: new authorization_1.AuthorizationRepo(connection),
                 confirmationNumber: new confirmationNumber_1.ConfirmationNumberRepo({ connection }),
@@ -107,7 +112,7 @@ function call(params) {
         catch (error) {
             let throwsError = true;
             // アクションが存在すればタスクを実行済扱いにする
-            const action = (await actionRepo.searchBySameAs({
+            const action = (await authorizePaymentMethodActionRepo.searchBySameAs({
                 sameAs: { id: { $eq: params.id } },
                 purpose: { id: { $eq: params.data.purpose.id } },
                 typeOf: { $eq: factory.actionType.AuthorizeAction }

package/lib/chevre/service/task/voidPayTransaction.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = call;
 const accountingReport_1 = require("../../repo/accountingReport");
-const action_1 = require("../../repo/action");
+// import { ActionRepo } from '../../repo/action';
+const acceptPay_1 = require("../../repo/action/acceptPay");
+const authorizePaymentMethod_1 = require("../../repo/action/authorizePaymentMethod");
 const assetTransaction_1 = require("../../repo/assetTransaction");
 const paymentService_1 = require("../../repo/paymentService");
 const paymentServiceProvider_1 = require("../../repo/paymentServiceProvider");
@@ -22,7 +24,9 @@ function call(params) {
             sameAs: { id: params.id }
         })({
             accountingReport: new accountingReport_1.AccountingReportRepo(connection),
-            action: new action_1.ActionRepo(connection),
+            // action: new ActionRepo(connection),
+            acceptPayAction: new acceptPay_1.AcceptPayActionRepo(connection),
+            authorizePaymentMethodAction: new authorizePaymentMethod_1.AuthorizePaymentMethodActionRepo(connection),
             assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
             paymentAccepted: new sellerPaymentAccepted_1.SellerPaymentAcceptedRepo(connection),
             paymentService: new paymentService_1.PaymentServiceRepo(connection),

package/package.json

@@ -99,5 +99,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "24.0.0-alpha.24"
+  "version": "24.0.0-alpha.26"
 }