@chevre/domain 28.0.0-alpha.4 → 28.0.0-alpha.40

package/lib/chevre/emailMessageBuilder.js

@@ -71,7 +71,7 @@ function createEmailMessageSender(params, setting) {
         name: (typeof params.email?.sender?.name === 'string')
             ? params.email.sender.name
             : defaultSellerName,
-        email: setting.defaultSenderEmail
+        email: setting.defaultSenderEmail // 送信元未指定であればタスクで自動設定されるがとりあえず指定(2026-10-20~)
     };
 }
 /**

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

@@ -4,5 +4,5 @@ export type IMinimizedIndividualEvent = Pick<factory.event.screeningEvent.IEvent
  * 興行イベントのsuperEventを作成する
  */
 export declare function minimizeSuperEvent(params: {
-    superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'soundFormat' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
+    superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
 }): factory.event.screeningEvent.ISuperEvent;

package/lib/chevre/factory/event.js

@@ -29,15 +29,11 @@ function minimizeSuperEvent(params) {
         ...(params.superEventFromDB.location.name !== undefined)
             ? { name: params.superEventFromDB.location.name }
             : undefined
-        // 廃止(2024-03-05~)
-        // ...(typeof params.superEventFromDB.location.kanaName === 'string')
-        //     ? { kanaName: params.superEventFromDB.location.kanaName }
-        //     : undefined
     };
     return {
         typeOf: factory_1.factory.eventType.ScreeningEventSeries,
         id: params.superEventFromDB.id,
-        soundFormat: params.superEventFromDB.soundFormat,
+        // soundFormat: params.superEventFromDB.soundFormat, // discontinue(2026-10-05~)
         workPerformed,
         location,
         kanaName: params.superEventFromDB.kanaName,

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

@@ -1,9 +1,9 @@
 import type { Connection } from 'mongoose';
-import { AcceptedOfferInReserveRepo, IAcceptedOffer } from './acceptedOfferInReserve';
+import { factory } from '../factory';
+import { AcceptedOfferInReserveRepo } from './acceptedOfferInReserve';
 type IDistinctField = 'acceptedOffers.id' | 'acceptedOffers.itemOffered.reservationNumber' | 'acceptedOffers.itemOffered.reservationFor.id' | 'acceptedOffers.serialNumber' | 'acceptedOffers.offeredThrough.identifier' | 'acceptedOffers.itemOffered.reservationFor.superEvent.location.branchCode';
 interface ISearchSlicedAcceptedOffersResult {
-    acceptedOffers: Pick<IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[];
-    numAcceptedOffers: number;
+    partialAcceptedOffers: Pick<factory.acceptedOffer.IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[];
 }
 /**
  * 注文オファーリポジトリ
@@ -41,11 +41,12 @@ export declare class AcceptedOfferRepo extends AcceptedOfferInReserveRepo {
                 reservedTicket?: never;
             };
         };
-    }): Promise<Pick<IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[]>;
+    }): Promise<Pick<factory.acceptedOffer.IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'>[]>;
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
+     * 注文通知に渡すオファーを参照するためにのみ使用
      */
-    searchSlicedAcceptedOffersByOrderNumber(filter: {
+    findPartialAcceptedOffersByOrderNumber(filter: {
         $slice: [number, number];
         orderNumber: {
             $eq: string;

package/lib/chevre/repo/acceptedOffer.js

@@ -69,17 +69,22 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
     }
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
+     * 注文通知に渡すオファーを参照するためにのみ使用
      */
-    async searchSlicedAcceptedOffersByOrderNumber(filter) {
+    async findPartialAcceptedOffersByOrderNumber(filter) {
         const aggregate = this.orderModel.aggregate([
-            { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
-            { $match: { 'project.id': { $eq: filter.project.id.$eq } } },
-            { $match: { typeOf: { $eq: factory_1.factory.order.OrderType.Order } } },
+            {
+                $match: {
+                    orderNumber: { $eq: filter.orderNumber.$eq },
+                    'project.id': { $eq: filter.project.id.$eq },
+                    typeOf: { $eq: factory_1.factory.order.OrderType.Order }
+                }
+            },
             {
                 $project: {
                     _id: 0,
-                    acceptedOffers: { $slice: ['$acceptedOffers', ...filter.$slice] },
-                    numAcceptedOffers: { $size: '$acceptedOffers' }
+                    partialAcceptedOffers: { $slice: ['$acceptedOffers', ...filter.$slice] },
+                    // numAcceptedOffers: { $size: '$acceptedOffers' }
                 }
             }
         ]);
@@ -89,11 +94,11 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
         if (result === undefined) {
             throw new factory_1.factory.errors.NotFound(factory_1.factory.order.OrderType.Order);
         }
-        const { acceptedOffers, numAcceptedOffers } = result;
+        const { partialAcceptedOffers } = result;
         // 予約取引を参照(2026-05-18~)
         return {
-            acceptedOffers: await this.addAcceptedOffersDetails(acceptedOffers),
-            numAcceptedOffers
+            partialAcceptedOffers: await this.addAcceptedOffersDetails(partialAcceptedOffers),
+            // numAcceptedOffers
         };
     }
     async countByOrderNumber(filter) {

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

@@ -1,14 +1,8 @@
 import type { Connection } from 'mongoose';
 import { factory } from '../factory';
 import { IModel } from './mongoose/schemas/assetTransaction';
+import type { IAcceptedOfferInDoc } from './mongoose/schemas/order';
 import { IAcceptedOfferByReserveTransaction } from './factory/acceptedOffer/reserveTransaction2itemOffered';
-export type IAcceptedOffer = Pick<factory.order.IAcceptedOffer, 'id' | 'itemOffered' | 'offeredThrough' | 'serialNumber' | 'typeOf'> & {
-    /**
-     * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
-     */
-    priceSpecification?: factory.order.ITicketPriceSpecification;
-    name?: never;
-};
 /**
  * 予約取引に依存した注文オファーリポジトリ
  */
@@ -27,5 +21,9 @@ export declare class AcceptedOfferInReserveRepo {
     /**
      * 予約取引からオファー詳細情報を付加する
      */
-    protected addAcceptedOffersDetails(acceptedOffers: IAcceptedOffer[]): Promise<IAcceptedOffer[]>;
+    protected addAcceptedOffersDetails(
+    /**
+     * 注文ドキュメント内の生オファーを受け取る
+     */
+    acceptedOffers: IAcceptedOfferInDoc[]): Promise<factory.acceptedOffer.IAcceptedOffer[]>;
 }

package/lib/chevre/repo/acceptedOfferInReserve.js

@@ -41,7 +41,11 @@ class AcceptedOfferInReserveRepo {
     /**
      * 予約取引からオファー詳細情報を付加する
      */
-    async addAcceptedOffersDetails(acceptedOffers) {
+    async addAcceptedOffersDetails(
+    /**
+     * 注文ドキュメント内の生オファーを受け取る
+     */
+    acceptedOffers) {
         const offeredThroughIdentifier = acceptedOffers.at(0)?.offeredThrough?.identifier;
         if (offeredThroughIdentifier === factory_1.factory.service.webAPI.Identifier.COA) {
             // COAでは予約取引を参照しない
@@ -67,18 +71,20 @@ class AcceptedOfferInReserveRepo {
             // itemOfferedByReserveは必ず存在するはず
             if (itemOfferedByReserve === undefined) {
                 console.error('repo:acceptedOffer: addAcceptedOffersDetails: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+                throw new factory_1.factory.errors.Internal(`itemOfferedByReserve not found. itemOffered.id:${acceptedOffer.itemOffered.id}`);
             }
-            const nameByReserveTransaction = acceptedOfferByReserveTransaction?.name;
+            // const nameByReserveTransaction = acceptedOfferByReserveTransaction?.name;
             const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
             name: _originalName, // 注文ドキュメントのnameはもう採用しない(2026-06-09~)
-            itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
+            itemOffered: _itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
             return {
                 ...acceptedOfferWithoutPrice,
-                ...((nameByReserveTransaction !== undefined) && { name: nameByReserveTransaction }), // 予約取引参照の値で上書き(2026-06-09~)
+                // ...((nameByReserveTransaction !== undefined) && { name: nameByReserveTransaction }), // 予約取引参照の値で上書き(2026-06-09~)
                 ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
-                ...(itemOfferedByReserve !== undefined)
-                    ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き
-                    : { itemOffered }
+                itemOffered: itemOfferedByReserve // 予約取引参照の値で上書き
+                // ...(itemOfferedByReserve !== undefined)
+                //     ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き
+                //     : { itemOffered }
             };
         });
     }

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

@@ -1,22 +1,23 @@
 import type { Connection } from 'mongoose';
 import { factory } from '../factory';
-import { AcceptedOfferInReserveRepo, IAcceptedOffer } from './acceptedOfferInReserve';
+import { AcceptedOfferInReserveRepo } from './acceptedOfferInReserve';
 type IProjection4searchWithUnwoundAcceptedOffers = {
     [key in keyof factory.order.IOrder]?: 1;
 } & {};
-type IMinimizedReservationFor = Pick<IAcceptedOffer['itemOffered']['reservationFor'], 'id' | 'typeOf'>;
-type IMinimizedItemOffered = Pick<IAcceptedOffer['itemOffered'], 'additionalProperty' | 'additionalTicketText' | 'id' | 'issuedThrough' | 'programMembershipUsed' | 'reservationNumber' | 'reservedTicket' | 'typeOf'> & {
+type IMinimizedReservationFor = Pick<factory.acceptedOffer.IAcceptedOffer['itemOffered']['reservationFor'], 'id' | 'typeOf'>;
+type IMinimizedItemOffered = Pick<factory.acceptedOffer.IAcceptedOffer['itemOffered'], 'additionalProperty' | 'additionalTicketText' | 'programMembershipUsed' | 'id' | 'reservationNumber' | 'reservedTicket' | 'typeOf'> & {
     reservationFor: IMinimizedReservationFor;
+    issuedThrough?: factory.acceptedOffer.IAcceptedOffer['itemOffered']['issuedThrough'];
 };
-type IMinimizedAcceptedOffer = Pick<IAcceptedOffer, 'id' | 'name' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
+type IMinimizedAcceptedOffer = Pick<factory.acceptedOffer.IAcceptedOffer, 'id' | 'name' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
     itemOffered: IMinimizedItemOffered;
 };
-type IAcceptedOfferInOrder = Pick<IAcceptedOffer, 'id' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
+type IAcceptedOfferAsFindResult = Pick<factory.acceptedOffer.IAcceptedOffer, 'id' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
     /**
-     * reservationFor最小化に対応
-     * 2026-09-01~
+     * 常に最小化
+     * 2026-10-08~
      */
-    itemOffered: IAcceptedOffer['itemOffered'] | IMinimizedItemOffered;
+    itemOffered: IMinimizedItemOffered;
 };
 /**
  * 注文オファー管理リポジトリ
@@ -36,10 +37,16 @@ export declare class AdminAcceptedOfferRepo extends AcceptedOfferInReserveRepo {
         /**
          * reservationForをid属性のみにするオプション
          * 2026-08-31~
+         * always true(2026-10-08~)
+         */
+        minimizeReservationFor: true;
+        /**
+         * reservedTicket以外の属性を除外するオプション
+         * 2026-10-08~
          */
-        minimizeReservationFor: boolean;
+        onlyReservedTicket: boolean;
     }): Promise<(factory.order.IOrder & {
-        acceptedOffers: [IAcceptedOffer | IMinimizedAcceptedOffer];
+        acceptedOffers: [IMinimizedAcceptedOffer];
         _id?: never;
     })[]>;
     /**
@@ -57,8 +64,14 @@ export declare class AdminAcceptedOfferRepo extends AcceptedOfferInReserveRepo {
         /**
          * reservationForをid属性のみにするオプション
          * 2026-08-31~
+         * always true(2026-10-08~)
+         */
+        minimizeReservationFor: true;
+        /**
+         * reservedTicket以外の属性を除外するオプション
+         * 2026-10-08~
          */
-        minimizeReservationFor: boolean;
-    }): Promise<IAcceptedOfferInOrder[]>;
+        onlyReservedTicket: boolean;
+    }): Promise<IAcceptedOfferAsFindResult[]>;
 }
 export {};

package/lib/chevre/repo/adminAcceptedOffer.js

@@ -7,14 +7,22 @@ const settings_1 = require("../settings");
 const acceptedOfferInReserve_1 = require("./acceptedOfferInReserve");
 const order_2 = require("./order");
 function minimizeItemOffered(itemOffered, options) {
-    const { minimizeReservationFor } = options;
+    const { minimizeReservationFor, onlyReservedTicket } = options;
     if (minimizeReservationFor) {
         const { reservationFor, ...itemOfferedWithoutEvent } = itemOffered;
-        const { id, typeOf } = reservationFor;
-        return {
-            ...itemOfferedWithoutEvent,
-            reservationFor: { id, typeOf }
-        };
+        if (onlyReservedTicket) {
+            const { id, reservationNumber, reservedTicket, typeOf } = itemOfferedWithoutEvent;
+            return {
+                id, reservationNumber, reservedTicket, typeOf,
+                reservationFor: { id: reservationFor.id, typeOf: reservationFor.typeOf }
+            };
+        }
+        else {
+            return {
+                ...itemOfferedWithoutEvent,
+                reservationFor: { id: reservationFor.id, typeOf: reservationFor.typeOf }
+            };
+        }
     }
     else {
         return itemOffered;
@@ -94,11 +102,12 @@ class AdminAcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
                 // itemOfferedByReserveは必ず存在するはず
                 if (itemOfferedByReserve === undefined) {
                     console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+                    throw new factory_1.factory.errors.Internal(`itemOfferedByReserve not found. itemOffered.id:${acceptedOffer.itemOffered.id}`);
                 }
                 const nameByReserveTransaction = acceptedOfferByReserveTransaction?.name;
                 const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
                 name: _originalName, // 注文ドキュメントのnameはもう採用しない(2026-06-09~)
-                itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
+                itemOffered: _itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
                 return {
                     ...order,
                     acceptedOffers: [
@@ -106,9 +115,10 @@ class AdminAcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
                             ...acceptedOfferWithoutPrice,
                             ...((nameByReserveTransaction !== undefined) && { name: nameByReserveTransaction }), // 予約取引参照の値で上書き(2026-06-09~)
                             ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
-                            ...(itemOfferedByReserve !== undefined)
-                                ? { itemOffered: minimizeItemOffered(itemOfferedByReserve, options) } // 予約取引参照の値で上書き(2026-05-25~)
-                                : { itemOffered: minimizeItemOffered(itemOffered, options) }
+                            itemOffered: minimizeItemOffered(itemOfferedByReserve, options) // 予約取引参照の値で上書き(2026-05-25~)
+                            // ...(itemOfferedByReserve !== undefined)
+                            //     ? { itemOffered: minimizeItemOffered(itemOfferedByReserve, options) } // 予約取引参照の値で上書き(2026-05-25~)
+                            //     : { itemOffered: minimizeItemOffered(itemOffered, options) }
                         }
                     ]
                 };

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

@@ -0,0 +1,49 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+type IFindParams = Pick<factory.accountTitle.ISearchConditions, 'codeValue' | 'limit' | 'name' | 'page' | 'project' | 'additionalProperty' | 'inCodeSet'>;
+/**
+ * 細目管理リポジトリ
+ */
+export declare class AdminAccountTitleRepo {
+    private readonly accountTitleModel;
+    constructor(connection: Connection);
+    addAccountTitle(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project' | 'additionalProperty'> & {
+        inCodeSet: {
+            codeValue: string;
+            inCodeSet: {
+                codeValue: string;
+            };
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    updateAccountTitle(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project' | 'additionalProperty'> & {
+        inCodeSet: {
+            codeValue: string;
+            inCodeSet: {
+                codeValue: string;
+            };
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    findAccountTitles(params: IFindParams): Promise<(Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'additionalProperty'> & {
+        inCodeSet: {
+            codeValue: string;
+            name?: string;
+            inCodeSet: {
+                codeValue: string;
+                name?: string;
+            };
+        };
+    })[]>;
+    deleteAccountTitleByCodeValue(params: {
+        projectId: string;
+        codeValue: string;
+        accountTitleCategoryCode: string;
+        accountTitleSetCode: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export {};

package/lib/chevre/repo/adminAccountTitle.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAccountTitleRepo = void 0;
+const factory_1 = require("../factory");
+const accountTitle_1 = require("./mongoose/schemas/accountTitle");
+function createMatchStages(params) {
+    const matchStages = [];
+    const projectIdEq = params.project?.id?.$eq;
+    if (typeof projectIdEq === 'string') {
+        matchStages.push({
+            $match: { 'project.id': { $eq: projectIdEq } }
+        });
+    }
+    const nameRegex = params.name;
+    if (typeof nameRegex === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.name': { $exists: true, $regex: new RegExp(nameRegex) } }
+        });
+    }
+    if (typeof params.codeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(params.codeValue) } }
+        });
+    }
+    else {
+        const codeValueEq = params.codeValue?.$eq;
+        if (typeof codeValueEq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValueEq } }
+            });
+        }
+    }
+    const inCodeSetCodeValue = params.inCodeSet?.codeValue;
+    if (typeof inCodeSetCodeValue === 'string') {
+        matchStages.push({
+            $match: { 'hasCategoryCode.codeValue': { $exists: true, $regex: new RegExp(inCodeSetCodeValue) } }
+        });
+    }
+    else {
+        const inCodeSetCodeValueEq = inCodeSetCodeValue?.$eq;
+        if (typeof inCodeSetCodeValueEq === 'string') {
+            matchStages.push({
+                $match: { 'hasCategoryCode.codeValue': { $exists: true, $eq: inCodeSetCodeValueEq } }
+            });
+        }
+    }
+    const accountTitleCategoryCode = params.inCodeSet?.inCodeSet?.codeValue;
+    if (typeof accountTitleCategoryCode === 'string') {
+        matchStages.push({
+            $match: { codeValue: { $exists: true, $regex: new RegExp(accountTitleCategoryCode) } }
+        });
+    }
+    else {
+        const accountTitleCategoryCodeEq = accountTitleCategoryCode?.$eq;
+        if (typeof accountTitleCategoryCodeEq === 'string') {
+            matchStages.push({
+                $match: { codeValue: { $exists: true, $eq: accountTitleCategoryCodeEq } }
+            });
+        }
+    }
+    const additionalPropertyElemMatch = params.additionalProperty?.$elemMatch;
+    if (additionalPropertyElemMatch !== undefined && additionalPropertyElemMatch !== null) {
+        matchStages.push({
+            $match: { 'hasCategoryCode.hasCategoryCode.additionalProperty': { $exists: true, $elemMatch: additionalPropertyElemMatch } }
+        });
+    }
+    return matchStages;
+}
+/**
+ * 細目管理リポジトリ
+ */
+class AdminAccountTitleRepo {
+    accountTitleModel;
+    constructor(connection) {
+        this.accountTitleModel = connection.model(accountTitle_1.modelName, (0, accountTitle_1.createSchema)());
+    }
+    async addAccountTitle(params) {
+        const { codeValue, name, project, inCodeSet, additionalProperty } = params;
+        // 科目の存在確認
+        const categoryDoc = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (categoryDoc === null) {
+            throw new factory_1.factory.errors.NotFound('AccountTitleSet');
+        }
+        const newAccountTitle = {
+            typeOf: 'AccountTitle',
+            codeValue,
+            additionalProperty: (Array.isArray(additionalProperty)) ? additionalProperty : [],
+            ...(typeof name === 'string') && { name }
+        };
+        // プロジェクト内での細目コード重複確認(インデックスは保証できない)
+        const existingAccountTitle = await this.accountTitleModel.findOne({
+            'project.id': { $eq: project.id },
+            // codeValue: { $eq: accountTitleCategory.codeValue },
+            // 'hasCategoryCode.codeValue': {
+            //     $exists: true,
+            //     $eq: accountTitleSet.codeValue
+            // },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, { _id: 1 })
+            .exec();
+        if (existingAccountTitle !== null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['codeValue'], 'codeValue duplicated');
+        }
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $ne: codeValue }
+        }, {
+            $push: {
+                'hasCategoryCode.$[accountTitleSet].hasCategoryCode': newAccountTitle
+            }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        // 存在しなければ細目コード重複
+        if (doc === null) {
+            throw new factory_1.factory.errors.AlreadyInUse(accountTitle_1.modelName, ['hasCategoryCode.hasCategoryCode.codeValue']);
+        }
+        return { id: doc.id };
+    }
+    async updateAccountTitle(params) {
+        const { codeValue, name, project, inCodeSet, additionalProperty } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: project.id },
+            codeValue: { $eq: inCodeSet.inCodeSet.codeValue },
+            'hasCategoryCode.codeValue': { $eq: inCodeSet.codeValue },
+            'hasCategoryCode.hasCategoryCode.codeValue': codeValue
+        }, {
+            // 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].codeValue': accountTitle.codeValue,
+            ...(typeof name === 'string')
+                && { 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].name': name },
+            ...(Array.isArray(additionalProperty))
+                && { 'hasCategoryCode.$[accountTitleSet].hasCategoryCode.$[accountTitle].additionalProperty': additionalProperty }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': inCodeSet.codeValue },
+                { 'accountTitle.codeValue': codeValue }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+    async findAccountTitles(params) {
+        const aggregate = this.accountTitleModel.aggregate([
+            { $unwind: '$hasCategoryCode' },
+            { $unwind: '$hasCategoryCode.hasCategoryCode' },
+            ...createMatchStages(params),
+            {
+                $project: {
+                    _id: 0,
+                    codeValue: '$hasCategoryCode.hasCategoryCode.codeValue',
+                    name: '$hasCategoryCode.hasCategoryCode.name',
+                    inCodeSet: {
+                        codeValue: '$hasCategoryCode.codeValue',
+                        name: '$hasCategoryCode.name',
+                        inCodeSet: {
+                            codeValue: '$codeValue',
+                            name: '$name'
+                        },
+                    },
+                    additionalProperty: '$hasCategoryCode.hasCategoryCode.additionalProperty'
+                }
+            }
+        ]);
+        if (typeof params.limit === 'number' && typeof params.page === 'number') {
+            aggregate.skip(params.limit * (params.page - 1))
+                .limit(params.limit);
+        }
+        return aggregate.exec();
+    }
+    async deleteAccountTitleByCodeValue(params) {
+        const { projectId, codeValue, accountTitleCategoryCode, accountTitleSetCode } = params;
+        const doc = await this.accountTitleModel.findOneAndUpdate({
+            'project.id': { $eq: projectId },
+            codeValue: { $eq: accountTitleCategoryCode },
+            'hasCategoryCode.codeValue': { $exists: true, $eq: accountTitleSetCode },
+            'hasCategoryCode.hasCategoryCode.codeValue': { $exists: true, $eq: codeValue }
+        }, {
+            $pull: {
+                'hasCategoryCode.$[accountTitleSet].hasCategoryCode': { codeValue }
+            }
+        }, {
+            new: true,
+            arrayFilters: [
+                { 'accountTitleSet.codeValue': accountTitleSetCode }
+            ],
+            projection: { _id: 1 }
+        })
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(accountTitle_1.modelName);
+        }
+        return { id: doc.id };
+    }
+}
+exports.AdminAccountTitleRepo = AdminAccountTitleRepo;

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

@@ -0,0 +1,37 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+type IFindParams = Pick<factory.accountTitle.ISearchConditions, 'codeValue' | 'limit' | 'name' | 'page' | 'project' | 'sort'>;
+/**
+ * 科目分類管理リポジトリ
+ */
+export declare class AdminAccountTitleCategoryRepo {
+    private readonly accountTitleModel;
+    constructor(connection: Connection);
+    findAccountTitleCategorAsNotification(params: {
+        id: string;
+        projectId: string;
+    }): Promise<Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'hasCategoryCode' | 'name' | 'project' | 'typeOf'> & {
+        id: string;
+    }>;
+    deleteAccountTitleCategoriesByProject(params: {
+        project: {
+            id: string;
+        };
+    }): Promise<void>;
+    addAccountTitleCategory(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'>): Promise<{
+        id: string;
+    }>;
+    updateAccountTitleCategory(params: Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name' | 'project'>): Promise<{
+        id: string;
+    }>;
+    findAccountTitleCategories(params: IFindParams): Promise<Pick<factory.accountTitle.IAccountTitle, 'codeValue' | 'name'>[]>;
+    deleteAccountTitleCategoryByCodeValue(params: {
+        projectId: string;
+        codeValue: string;
+    }): Promise<void>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};