@chevre/domain 26.0.0-alpha.9 → 26.1.0-alpha.0

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

@@ -41,12 +41,6 @@ export declare class AuthorizationRepo {
     projectFields(params: factory.authorization.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<(factory.authorization.IAuthorization & {
         id: string;
     })[]>;
-    /**
-     * 有効期限を一定期間過ぎた承認を削除する
-     */
-    deleteValidUntilPassedCertainPeriod(params: {
-        $lt: Date;
-    }): Promise<void>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.authorization.IAuthorization>;
         $unset: any;

package/lib/chevre/repo/authorization.js

@@ -69,21 +69,21 @@ class AuthorizationRepo {
                     'object.typeOf': { $exists: true, $in: object.typeOfs }
                 });
             }
-            /* istanbul ignore else */
-            if (object.typeOfGood !== undefined) {
-                /* istanbul ignore else */
-                if (Array.isArray(object.typeOfGood.ids)) {
-                    andConditions.push({
-                        'object.typeOfGood.id': { $exists: true, $in: object.typeOfGood.ids }
-                    });
-                }
-                /* istanbul ignore else */
-                if (Array.isArray(object.typeOfGood.typeOfs)) {
-                    andConditions.push({
-                        'object.typeOfGood.typeOf': { $exists: true, $in: object.typeOfGood.typeOfs }
-                    });
-                }
-            }
+            // /* istanbul ignore else */
+            // if (object.typeOfGood !== undefined) {
+            //     /* istanbul ignore else */
+            //     if (Array.isArray(object.typeOfGood.ids)) {
+            //         andConditions.push({
+            //             'object.typeOfGood.id': { $exists: true, $in: object.typeOfGood.ids }
+            //         });
+            //     }
+            //     /* istanbul ignore else */
+            //     if (Array.isArray(object.typeOfGood.typeOfs)) {
+            //         andConditions.push({
+            //             'object.typeOfGood.typeOf': { $exists: true, $in: object.typeOfGood.typeOfs }
+            //         });
+            //     }
+            // }
         }
         if (params.validFrom instanceof Date) {
             andConditions.push({ validUntil: { $gte: params.validFrom } });
@@ -177,18 +177,6 @@ class AuthorizationRepo {
             .lean()
             .exec();
     }
-    /**
-     * 有効期限を一定期間過ぎた承認を削除する
-     */
-    async deleteValidUntilPassedCertainPeriod(params) {
-        await this.authorizationModel.deleteMany({
-            validUntil: {
-                $exists: true,
-                $lt: params.$lt
-            }
-        })
-            .exec();
-    }
     async unsetUnnecessaryFields(params) {
         return this.authorizationModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
             .exec();

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

@@ -0,0 +1,4 @@
+import { FilterQuery } from 'mongoose';
+import { factory } from '../../../factory';
+import { IDocType } from '../../mongoose/schemas/action';
+export declare function createMongoConditions(params: factory.action.ISearchConditions): FilterQuery<IDocType>[];

package/lib/chevre/repo/factory/action/createMongoConditions.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongoConditions = createMongoConditions;
+function createMongoConditions(params) {
+    const andConditions = [];
+    const idIn = params.id?.$in;
+    if (Array.isArray(idIn)) {
+        andConditions.push({ _id: { $in: idIn } });
+    }
+    const idNin = params.id?.$nin;
+    if (Array.isArray(idNin)) {
+        andConditions.push({ _id: { $nin: idNin } });
+    }
+    const projectIdEq = params.project?.id?.$eq;
+    if (typeof projectIdEq === 'string') {
+        andConditions.push({
+            'project.id': {
+                $eq: projectIdEq
+            }
+        });
+    }
+    const agentTypeOfIn = params.agent?.typeOf?.$in;
+    if (Array.isArray(agentTypeOfIn)) {
+        andConditions.push({
+            'agent.typeOf': {
+                $exists: true,
+                $in: agentTypeOfIn
+            }
+        });
+    }
+    const agentIdIn = params.agent?.id?.$in;
+    if (Array.isArray(agentIdIn)) {
+        andConditions.push({
+            'agent.id': {
+                $exists: true,
+                $in: agentIdIn
+            }
+        });
+    }
+    const instrumentTransactionNumberEq = params.instrument?.transactionNumber?.$eq;
+    if (typeof instrumentTransactionNumberEq === 'string') {
+        andConditions.push({ 'instrument.transactionNumber': { $exists: true, $eq: instrumentTransactionNumberEq } });
+    }
+    const instrumentTypeOfEq = params.instrument?.typeOf?.$eq;
+    if (typeof instrumentTypeOfEq === 'string') {
+        andConditions.push({ 'instrument.typeOf': { $exists: true, $eq: instrumentTypeOfEq } });
+    }
+    const instrumentIdentifierEq = params.instrument?.identifier?.$eq;
+    if (typeof instrumentIdentifierEq === 'string') {
+        andConditions.push({ 'instrument.identifier': { $exists: true, $eq: instrumentIdentifierEq } });
+    }
+    const instrumentIdEq = params.instrument?.id?.$eq;
+    if (typeof instrumentIdEq === 'string') {
+        andConditions.push({ 'instrument.id': { $exists: true, $eq: instrumentIdEq } });
+    }
+    const instrumentOrderNumberEq = params.instrument?.orderNumber?.$eq;
+    if (typeof instrumentOrderNumberEq === 'string') {
+        andConditions.push({ 'instrument.orderNumber': { $exists: true, $eq: instrumentOrderNumberEq } });
+    }
+    const locationIdEq = params.location?.id?.$eq;
+    if (typeof locationIdEq === 'string') {
+        andConditions.push({
+            'location.id': {
+                $exists: true,
+                $eq: locationIdEq
+            }
+        });
+    }
+    const locationIdentifierEq = params.location?.identifier?.$eq;
+    if (typeof locationIdentifierEq === 'string') {
+        andConditions.push({
+            'location.identifier': {
+                $exists: true,
+                $eq: locationIdentifierEq
+            }
+        });
+    }
+    const objectMovieTicketsIdentifierEq = params.object?.movieTickets?.identifier?.$eq;
+    if (typeof objectMovieTicketsIdentifierEq === 'string') {
+        andConditions.push({
+            'object.movieTickets.identifier': {
+                $exists: true,
+                $eq: objectMovieTicketsIdentifierEq
+            }
+        });
+    }
+    const objectMovieTicketsServiceOutputReservationForIdEq = params.object?.movieTickets?.serviceOutput?.reservationFor?.id?.$eq;
+    if (typeof objectMovieTicketsServiceOutputReservationForIdEq === 'string') {
+        andConditions.push({
+            'object.movieTickets.serviceOutput.reservationFor.id': {
+                $exists: true,
+                $eq: objectMovieTicketsServiceOutputReservationForIdEq
+            }
+        });
+    }
+    const objectPaymentMethodIdEq = params.object?.paymentMethodId?.$eq;
+    if (typeof objectPaymentMethodIdEq === 'string') {
+        andConditions.push({
+            'object.paymentMethodId': {
+                $exists: true,
+                $eq: objectPaymentMethodIdEq
+            }
+        });
+    }
+    const objectObjectPaymentMethodIdEq = params.object?.object?.paymentMethodId?.$eq;
+    if (typeof objectObjectPaymentMethodIdEq === 'string') {
+        andConditions.push({
+            'object.object.paymentMethodId': {
+                $exists: true,
+                $eq: objectObjectPaymentMethodIdEq
+            }
+        });
+    }
+    const objectReservationForIdEq = params.object?.reservationFor?.id?.$eq;
+    if (typeof objectReservationForIdEq === 'string') {
+        andConditions.push({
+            'object.reservationFor.id': {
+                $exists: true,
+                $eq: objectReservationForIdEq
+            }
+        });
+    }
+    const objectReservationNumberEq = params.object?.reservationNumber?.$eq;
+    if (typeof objectReservationNumberEq === 'string') {
+        andConditions.push({
+            'object.reservationNumber': {
+                $exists: true,
+                $eq: objectReservationNumberEq
+            }
+        });
+    }
+    const objectReservationNumberIn = params.object?.reservationNumber?.$in;
+    if (Array.isArray(objectReservationNumberIn)) {
+        andConditions.push({
+            'object.reservationNumber': {
+                $exists: true,
+                $in: objectReservationNumberIn
+            }
+        });
+    }
+    const objectPaymentMethodAccountIdEq = params.object?.paymentMethod?.accountId?.$eq;
+    if (typeof objectPaymentMethodAccountIdEq === 'string') {
+        andConditions.push({
+            'object.paymentMethod.accountId': {
+                $exists: true,
+                $eq: objectPaymentMethodAccountIdEq
+            }
+        });
+    }
+    const objectPaymentMethodPaymentMethodIdEq = params.object?.paymentMethod?.paymentMethodId?.$eq;
+    if (typeof objectPaymentMethodPaymentMethodIdEq === 'string') {
+        andConditions.push({
+            'object.paymentMethod.paymentMethodId': {
+                $exists: true,
+                $eq: objectPaymentMethodPaymentMethodIdEq
+            }
+        });
+    }
+    const objectPaymentMethodPaymentMethodIdIn = params.object?.paymentMethod?.paymentMethodId?.$in;
+    if (Array.isArray(objectPaymentMethodPaymentMethodIdIn)) {
+        andConditions.push({
+            'object.paymentMethod.paymentMethodId': {
+                $exists: true,
+                $in: objectPaymentMethodPaymentMethodIdIn
+            }
+        });
+    }
+    const objectPaymentMethodTypeOfEq = params.object?.paymentMethod?.typeOf?.$eq;
+    if (typeof objectPaymentMethodTypeOfEq === 'string') {
+        andConditions.push({
+            'object.paymentMethod.typeOf': {
+                $exists: true,
+                $eq: objectPaymentMethodTypeOfEq
+            }
+        });
+    }
+    const objectTypeOfEq = params.object?.typeOf?.$eq;
+    if (typeof objectTypeOfEq === 'string') {
+        andConditions.push({
+            'object.typeOf': {
+                $exists: true,
+                $eq: objectTypeOfEq
+            }
+        });
+    }
+    const objectTypeOfIn = params.object?.typeOf?.$in;
+    if (Array.isArray(objectTypeOfIn)) {
+        andConditions.push({
+            'object.typeOf': {
+                $exists: true,
+                $in: objectTypeOfIn
+            }
+        });
+    }
+    const objectIdEq = params.object?.id?.$eq;
+    if (typeof objectIdEq === 'string') {
+        andConditions.push({
+            'object.id': {
+                $exists: true,
+                $eq: objectIdEq
+            }
+        });
+    }
+    const objectIdIn = params.object?.id?.$in;
+    if (Array.isArray(objectIdIn)) {
+        andConditions.push({
+            'object.id': {
+                $exists: true,
+                $in: objectIdIn
+            }
+        });
+    }
+    const objectOrderNumberIn = params.object?.orderNumber?.$in;
+    if (Array.isArray(objectOrderNumberIn)) {
+        andConditions.push({
+            'object.orderNumber': {
+                $exists: true,
+                $in: objectOrderNumberIn
+            }
+        });
+    }
+    const objectTransactionNumberEq = params.object?.transactionNumber?.$eq;
+    if (typeof objectTransactionNumberEq === 'string') {
+        andConditions.push({ 'object.transactionNumber': { $exists: true, $eq: objectTransactionNumberEq } });
+    }
+    if (typeof params.typeOf === 'string') {
+        andConditions.push({
+            typeOf: params.typeOf
+        });
+    }
+    else {
+        const typeOfEq = params.typeOf?.$eq;
+        if (typeof typeOfEq === 'string') {
+            andConditions.push({
+                typeOf: { $eq: typeOfEq }
+            });
+        }
+    }
+    const actionStatusIn = params.actionStatus?.$in;
+    if (Array.isArray(actionStatusIn)) {
+        andConditions.push({
+            actionStatus: { $in: actionStatusIn }
+        });
+    }
+    if (Array.isArray(params.actionStatusTypes)) {
+        andConditions.push({
+            actionStatus: { $in: params.actionStatusTypes }
+        });
+    }
+    const startDateGte = params.startFrom;
+    if (startDateGte instanceof Date) {
+        andConditions.push({
+            startDate: { $gte: startDateGte }
+        });
+    }
+    const startDateLte = params.startThrough;
+    if (startDateLte instanceof Date) {
+        andConditions.push({
+            startDate: { $lte: startDateLte }
+        });
+    }
+    const purposeTypeOfIn = params.purpose?.typeOf?.$in;
+    if (Array.isArray(purposeTypeOfIn)) {
+        andConditions.push({
+            'purpose.typeOf': {
+                $exists: true,
+                $in: purposeTypeOfIn
+            }
+        });
+    }
+    const purposeIdIn = params.purpose?.id?.$in;
+    if (Array.isArray(purposeIdIn)) {
+        andConditions.push({
+            'purpose.id': {
+                $exists: true,
+                $in: purposeIdIn
+            }
+        });
+    }
+    const purposeOrderNumberIn = params.purpose?.orderNumber?.$in;
+    if (Array.isArray(purposeOrderNumberIn)) {
+        andConditions.push({
+            'purpose.orderNumber': {
+                $exists: true,
+                $in: purposeOrderNumberIn
+            }
+        });
+    }
+    const resultTypeOfIn = params.result?.typeOf?.$in;
+    if (Array.isArray(resultTypeOfIn)) {
+        andConditions.push({
+            'result.typeOf': {
+                $exists: true,
+                $in: resultTypeOfIn
+            }
+        });
+    }
+    const resultIdIn = params.result?.id?.$in;
+    if (Array.isArray(resultIdIn)) {
+        andConditions.push({
+            'result.id': {
+                $exists: true,
+                $in: resultIdIn
+            }
+        });
+    }
+    const resultOrderNumberIn = params.result?.orderNumber?.$in;
+    if (Array.isArray(resultOrderNumberIn)) {
+        andConditions.push({
+            'result.orderNumber': {
+                $exists: true,
+                $in: resultOrderNumberIn
+            }
+        });
+    }
+    const resultCodeIn = params.result?.code?.$in;
+    if (Array.isArray(resultCodeIn)) {
+        andConditions.push({
+            'result.code': {
+                $exists: true,
+                $in: resultCodeIn
+            }
+        });
+    }
+    // sameAs(2024-04-23~)
+    const sameAsIdEq = params.sameAs?.id?.$eq;
+    if (typeof sameAsIdEq === 'string') {
+        andConditions.push({ 'sameAs.id': { $exists: true, $eq: sameAsIdEq } });
+    }
+    const aboutOrderNumberEq = params.about?.orderNumber?.$eq;
+    if (typeof aboutOrderNumberEq === 'string') {
+        andConditions.push({ 'about.orderNumber': { $exists: true, $eq: aboutOrderNumberEq } });
+    }
+    return andConditions;
+}

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

@@ -59,13 +59,6 @@ export declare class MessageRepo {
             id: string;
         };
     }): Promise<IFindByIdentifierResult>;
-    /**
-     * 発行日時を基準に複数削除
-     * 2026-06-28~
-     */
-    deleteDatePublishedPassedCertainPeriod(params: {
-        $lt: Date;
-    }): Promise<void>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

package/lib/chevre/repo/message.js

@@ -160,44 +160,6 @@ class MessageRepo {
         }
         return doc;
     }
-    /**
-     * 発行日時を基準に複数削除
-     * 2026-06-28~
-     */
-    async deleteDatePublishedPassedCertainPeriod(params) {
-        const { $lt } = params;
-        if ($lt instanceof Date) {
-            await this.messageModel.deleteMany({
-                datePublished: { $lt }
-            })
-                .exec();
-        }
-    }
-    // public async deleteByMainEntityOrderNumber(params: {
-    //     project: { id: string };
-    //     mainEntity: { orderNumber: string };
-    // }): Promise<{
-    //     n?: number;
-    //     // opTime: result.opTime,
-    //     ok?: number;
-    //     // operationTime,
-    //     deletedCount?: number;
-    // } | null> {
-    //     return this.messageModel.deleteMany({
-    //         'project.id': { $eq: params.project.id },
-    //         'mainEntity.orderNumber': { $exists: true, $eq: params.mainEntity.orderNumber }
-    //     })
-    //         .exec()
-    //         .then((result) => {
-    //             return {
-    //                 // n: result?.n,
-    //                 // opTime: result.opTime,
-    //                 // ok: result?.ok,
-    //                 // operationTime,
-    //                 deletedCount: result?.deletedCount
-    //             };
-    //         });
-    // }
     async unsetUnnecessaryFields(params) {
         return this.messageModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
             .exec();

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

@@ -0,0 +1,48 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+import { IModel as IActionModel, IDocType } from './mongoose/schemas/action';
+import { IDocType as IRecipeDocType, IModel as IActionRecipeModel } from './mongoose/schemas/actionRecipe';
+/**
+ * アクション移行リポジトリ
+ */
+export declare class MigrateActionRepo {
+    protected readonly actionModel: IActionModel;
+    protected readonly actionRecipeModel: IActionRecipeModel;
+    constructor(connection: Connection);
+    getActionCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & IDocType & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & IDocType & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | null>;
+    getActionRecipeCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IRecipeDocType, import("./mongoose/virtuals").IVirtuals, {}> & factory.recipe.IRecipe & {
+        recipeFor: {
+            id: string;
+        };
+        dateCreated?: Date;
+        dateModified?: Date;
+        expires?: Date;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, import("mongoose").QueryOptions<IRecipeDocType>, (import("mongoose").Document<unknown, Record<string, never>, IRecipeDocType, import("./mongoose/virtuals").IVirtuals, {}> & factory.recipe.IRecipe & {
+        recipeFor: {
+            id: string;
+        };
+        dateCreated?: Date;
+        dateModified?: Date;
+        expires?: Date;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | null>;
+    migrateActionExpires(params: {
+        id: string;
+        expires: Date;
+    }): Promise<void>;
+}

package/lib/chevre/repo/migrateAction.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateActionRepo = void 0;
+const factory_1 = require("../factory");
+const action_1 = require("./mongoose/schemas/action");
+const actionRecipe_1 = require("./mongoose/schemas/actionRecipe");
+/**
+ * アクション移行リポジトリ
+ */
+class MigrateActionRepo {
+    actionModel;
+    actionRecipeModel;
+    constructor(connection) {
+        this.actionModel = connection.model(action_1.modelName, (0, action_1.createSchema)());
+        this.actionRecipeModel = connection.model(actionRecipe_1.modelName, (0, actionRecipe_1.createSchema)());
+    }
+    getActionCursor(conditions, projection) {
+        return this.actionModel.find(conditions, projection)
+            .sort({ startDate: factory_1.factory.sortType.Ascending })
+            .cursor();
+    }
+    getActionRecipeCursor(conditions, projection) {
+        return this.actionRecipeModel.find(conditions, projection)
+            .sort({ dateCreated: factory_1.factory.sortType.Ascending })
+            .cursor();
+    }
+    async migrateActionExpires(params) {
+        await this.actionModel.updateOne({ _id: { $eq: params.id } }, { $set: { expires: params.expires } })
+            .exec();
+    }
+}
+exports.MigrateActionRepo = MigrateActionRepo;

package/lib/chevre/repo/mongoose/schemas/action/abstractAction.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from 'mongoose';
+import type { IVirtuals } from '../../virtuals';
+type IAbstractActionDocType = any;
+type IAbstractActionModel = Model<IAbstractActionDocType, Record<string, never>, Record<string, never>, IVirtuals>;
+export { IAbstractActionDocType, IAbstractActionModel };

package/lib/chevre/repo/mongoose/schemas/action/abstractAction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/chevre/repo/mongoose/schemas/action/inform.d.ts

@@ -0,0 +1,11 @@
+import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../../virtuals';
+import { factory } from '../../../../factory';
+type IDocType = Pick<factory.action.interact.inform.IAction, 'about' | 'actionStatus' | 'agent' | 'endDate' | 'object' | 'project' | 'recipient' | 'result' | 'startDate' | 'target' | 'typeOf' | 'purpose' | 'error' | 'expires'>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
+type ISchemaDefinition = SchemaDefinition<IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
+declare const modelName = "Action.Inform";
+declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): ISchema;
+export { createSchema, IDocType, IModel, indexes, modelName };

package/lib/chevre/repo/mongoose/schemas/action/inform.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelName = exports.indexes = void 0;
+exports.createSchema = createSchema;
+const mongoose_1 = require("mongoose");
+const writeConcern_1 = require("../../writeConcern");
+const settings_1 = require("../../../../settings");
+const modelName = 'Action.Inform';
+exports.modelName = modelName;
+const schemaDefinition = {
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    actionStatus: { type: String, required: true },
+    typeOf: { type: String, required: true },
+    agent: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    object: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    startDate: { type: Date, required: true },
+    expires: { type: Date, required: true },
+    target: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    recipient: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    result: mongoose_1.SchemaTypes.Mixed,
+    error: mongoose_1.SchemaTypes.Mixed,
+    endDate: Date,
+    about: mongoose_1.SchemaTypes.Mixed,
+    purpose: mongoose_1.SchemaTypes.Mixed,
+};
+const schemaOptions = {
+    autoIndex: settings_1.MONGO_AUTO_INDEX,
+    autoCreate: false,
+    collection: 'actions.inform',
+    id: true,
+    read: 'primary',
+    writeConcern: writeConcern_1.writeConcern,
+    strict: true,
+    strictQuery: false,
+    timestamps: false,
+    versionKey: false,
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+};
+const indexes = [
+    [
+        { expires: 1 },
+        {
+            name: 'expires',
+            expireAfterSeconds: 0
+        }
+    ],
+    [
+        { startDate: -1 },
+        { name: 'startDate' }
+    ],
+    [
+        { 'project.id': 1, startDate: -1 },
+        { name: 'projectId' }
+    ],
+];
+exports.indexes = indexes;
+/**
+ * 通知アクションスキーマ
+ */
+let schema;
+function createSchema() {
+    if (schema === undefined) {
+        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
+    }
+    if (settings_1.MONGO_AUTO_INDEX) {
+        indexes.forEach((indexParams) => {
+            schema?.index(...indexParams);
+        });
+    }
+    return schema;
+}

package/lib/chevre/repo/mongoose/schemas/action/update.d.ts

@@ -0,0 +1,12 @@
+import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import { IVirtuals } from '../../virtuals';
+import { factory } from '../../../../factory';
+type Keys = 'actionStatus' | 'agent' | 'endDate' | 'error' | 'instrument' | 'object' | 'project' | 'result' | 'sameAs' | 'startDate' | 'targetCollection' | 'typeOf' | 'expires';
+type IDocType = Pick<factory.action.update.add.IAction, Keys> | Pick<factory.action.update.replace.IAction, Keys> | Pick<factory.action.update.update.IAction, Keys> | Pick<factory.action.update.deleteAction.IAction, Keys>;
+type IModel = Model<IDocType, Record<string, never>, Record<string, never>, IVirtuals>;
+type ISchemaDefinition = SchemaDefinition<IDocType>;
+type ISchema = Schema<IDocType, IModel, Record<string, never>, Record<string, never>, IVirtuals, Record<string, never>, ISchemaDefinition, IDocType>;
+declare const modelName = "Action.Update";
+declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): ISchema;
+export { createSchema, IDocType, IModel, indexes, modelName };