@chevre/domain 21.13.0-alpha.0 → 21.13.0-alpha.10

package/example/src/chevre/importEventsFromCOA.ts

@@ -10,28 +10,31 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const actionRepo = new chevre.repository.Action(mongoose.connection);
-    const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
-    const eventRepo = new chevre.repository.Event(mongoose.connection);
-    const placeRepo = new chevre.repository.Place(mongoose.connection);
-    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
+    const actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
+    const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
+    const creativeWorkRepo = await chevre.repository.CreativeWork.createInstance(mongoose.connection);
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const placeRepo = await chevre.repository.Place.createInstance(mongoose.connection);
+    const sellerRepo = await chevre.repository.Seller.createInstance(mongoose.connection);
 
-    await chevre.service.event.importFromCOA({
+    await (await chevre.service.event.createService()).importFromCOA({
         project: {
             id: project.id,
             typeOf: chevre.factory.organizationType.Project
         },
-        locationBranchCode: '022',
+        locationBranchCode: '120',
         importFrom: moment()
             .toDate(),
         importThrough: moment()
             .add(1, 'day')
             .toDate(),
         saveMovieTheater: false,
-        saveScreeningEventSeries: false
+        saveScreeningEventSeries: true,
+        saveScreeningEventSeriesPeriodInMonth: 24
     })({
         action: actionRepo,
         categoryCode: categoryCodeRepo,
+        creativeWork: creativeWorkRepo,
         event: eventRepo,
         place: placeRepo,
         seller: sellerRepo

package/example/src/chevre/searchEvents.ts

@@ -1,14 +1,17 @@
 // tslint:disable:no-console
 import * as mongoose from 'mongoose';
 
+const startTime = process.hrtime();
 import { chevre } from '../../../lib/index';
+const diff = process.hrtime(startTime);
+console.log(`importing chevre took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
 
 const PROJECT_ID = process.env.PROJECT_ID;
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const eventRepo: chevre.repository.Event = await chevre.repository.Event.createInstance(mongoose.connection);
 
     const events = await eventRepo.search(
         {
@@ -26,7 +29,7 @@ async function main() {
         }
     );
     console.log(events);
-    console.log(events.length);
+    console.log(events.length, 'events found');
 }
 
 main()

package/example/src/chevre/searchOrders.ts

@@ -8,7 +8,7 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const orderRepo = new chevre.repository.Order(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
 
     const orders = await orderRepo.search({
         limit: 10,

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

@@ -9,8 +9,8 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const ownershipInfoRepo = new chevre.repository.OwnershipInfo(mongoose.connection);
-    const productRepo = new chevre.repository.Product(mongoose.connection);
+    const ownershipInfoRepo = await chevre.repository.OwnershipInfo.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
 
     const result = await findPaymentCardPermit({
         project: { id: project.id },

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

@@ -8,7 +8,7 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const result = await chevre.service.transaction.returnOrder.start({
+    const result = await (await chevre.service.transaction.createService()).returnOrder.start({
         project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
         expiresInSeconds: 60,
         agent: { id: 'xxx', typeOf: chevre.factory.creativeWorkType.WebApplication },
@@ -23,14 +23,14 @@ async function main() {
             id: 'xxx'
         }
     })({
-        event: new chevre.repository.Event(mongoose.connection),
-        merchantReturnPolicy: new chevre.repository.MerchantReturnPolicy(mongoose.connection),
-        offer: new chevre.repository.Offer(mongoose.connection),
-        offerItemCondition: new chevre.repository.OfferItemCondition(mongoose.connection),
-        order: new chevre.repository.Order(mongoose.connection),
-        reservation: new chevre.repository.Reservation(mongoose.connection),
-        seller: new chevre.repository.Seller(mongoose.connection),
-        transaction: new chevre.repository.Transaction(mongoose.connection)
+        event: await chevre.repository.Event.createInstance(mongoose.connection),
+        merchantReturnPolicy: await chevre.repository.MerchantReturnPolicy.createInstance(mongoose.connection),
+        offer: await chevre.repository.Offer.createInstance(mongoose.connection),
+        offerItemCondition: await chevre.repository.OfferItemCondition.createInstance(mongoose.connection),
+        order: await chevre.repository.Order.createInstance(mongoose.connection),
+        reservation: await chevre.repository.Reservation.createInstance(mongoose.connection),
+        seller: await chevre.repository.Seller.createInstance(mongoose.connection),
+        transaction: await chevre.repository.Transaction.createInstance(mongoose.connection)
     });
     console.log(result);
 }

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

@@ -6,7 +6,7 @@ import { chevre } from '../../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
     const result = await transactionRepo.startExportTasks({
         typeOf: { $in: [chevre.factory.transactionType.PlaceOrder] },
         status: chevre.factory.transactionStatusType.Confirmed,

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -9,7 +9,7 @@ const PROJECT_ID = String(process.env.PROJECT_ID);
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
 
     let updateResult: any;
     updateResult = await transactionRepo.unsetUnnecessaryFields({

package/example/src/retryConnectMongo.ts

@@ -0,0 +1,82 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+let connection: mongoose.Connection | undefined;
+let mongoLastConnected: Date | undefined;
+const MONGO_RETRY_INTERVAL_IN_MILLISECONDS = 1000;
+const MONGO_GIVE_UP_IN_SECONDS = 5;
+async function getConnection(): Promise<mongoose.Connection> {
+    if (mongoLastConnected instanceof Date) {
+        if (connection === undefined) {
+            if (moment()
+                .isAfter(moment(mongoLastConnected)
+                    .add(MONGO_GIVE_UP_IN_SECONDS, 'seconds'))
+            ) {
+                mongoLastConnected = void 0;
+            }
+
+            // 最終接続から一定期間経過していればリトライ
+            connection = await new Promise<mongoose.Connection>((resolve, reject) => {
+                setTimeout(
+                    async () => {
+                        console.log('retrying...', mongoLastConnected);
+                        try {
+                            resolve(await getConnection());
+                        } catch (error) {
+                            reject(error);
+                        }
+                    },
+                    MONGO_RETRY_INTERVAL_IN_MILLISECONDS
+                );
+            });
+        }
+    } else {
+        mongoLastConnected = new Date();
+        console.log('creating connection...', mongoLastConnected);
+        if (connection === undefined) {
+            connection = await new Promise<mongoose.Connection>((resolve) => {
+                setTimeout(
+                    async () => {
+                        resolve(await mongoose.createConnection(<string>process.env.MONGOLAB_URI, { autoIndex: false }));
+                    },
+                    // tslint:disable-next-line:no-magic-numbers
+                    2000
+                );
+            });
+            // throw new Error('failed in createConnection')
+        }
+    }
+
+    return connection;
+}
+
+getConnection()
+    .then(() => {
+        console.log('sucess!', mongoose.connections.length);
+    })
+    .catch((error) => {
+        console.error(error, mongoose.connections.length);
+    });
+getConnection()
+    .then(() => {
+        console.log('sucess!', mongoose.connections.length);
+    })
+    .catch((error) => {
+        console.error(error, mongoose.connections.length);
+    });
+getConnection()
+    .then(() => {
+        console.log('sucess!', mongoose.connections.length);
+    })
+    .catch((error) => {
+        console.error(error, mongoose.connections.length);
+    });
+// setInterval(
+//     () => {
+//         getConnection()
+//             .then(console.log)
+//             .catch(console.error);
+//     },
+//     1000
+// );

package/lib/chevre/errorHandler.d.ts

@@ -3,8 +3,8 @@ export declare enum MongoErrorCode {
     MaxTimeMSExpired = 50,
     ExceededTimeLimit = 262
 }
-export declare function isMongoError(error: unknown): boolean;
-export declare function handleMongoError(error: unknown): unknown;
+export declare function isMongoError(error: unknown): Promise<boolean>;
+export declare function handleMongoError(error: unknown): Promise<unknown>;
 /**
  * 汎用的なCOAエラーハンドリング
  */

package/lib/chevre/errorHandler.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleAWSError = exports.handleMvtkReserveError = exports.handlePecorinoError = exports.handleCOAError = exports.handleMongoError = exports.isMongoError = exports.MongoErrorCode = void 0;
 /**
@@ -7,7 +16,7 @@ exports.handleAWSError = exports.handleMvtkReserveError = exports.handlePecorino
  */
 const http_status_1 = require("http-status");
 const factory_1 = require("./factory");
-const mongoose_1 = require("mongoose");
+let mongo;
 var MongoErrorCode;
 (function (MongoErrorCode) {
     MongoErrorCode[MongoErrorCode["DuplicateKey"] = 11000] = "DuplicateKey";
@@ -15,28 +24,38 @@ var MongoErrorCode;
     MongoErrorCode[MongoErrorCode["ExceededTimeLimit"] = 262] = "ExceededTimeLimit";
 })(MongoErrorCode = exports.MongoErrorCode || (exports.MongoErrorCode = {}));
 function isMongoError(error) {
-    return (error instanceof mongoose_1.mongo.MongoError || error instanceof mongoose_1.mongo.MongoServerError);
+    return __awaiter(this, void 0, void 0, function* () {
+        if (mongo === undefined) {
+            mongo = (yield Promise.resolve().then(() => require('mongoose'))).mongo;
+        }
+        return (error instanceof mongo.MongoError || error instanceof mongo.MongoServerError);
+    });
 }
 exports.isMongoError = isMongoError;
 function handleMongoError(error) {
-    let handledError = error;
-    if (handledError instanceof mongoose_1.mongo.MongoError || handledError instanceof mongoose_1.mongo.MongoServerError) {
-        switch (handledError.code) {
-            case MongoErrorCode.DuplicateKey:
-                handledError = new factory_1.errors.AlreadyInUse('', [], `Some fields already in use. code:${handledError.code} message:${handledError.message}`);
-                // no op
-                break;
-            case MongoErrorCode.MaxTimeMSExpired:
-            case MongoErrorCode.ExceededTimeLimit:
-                handledError = new factory_1.errors.GatewayTimeout(`Gateway Timeout. name:${handledError.name} code:${handledError.code} message:${handledError.message}`);
-                break;
-            default:
+    return __awaiter(this, void 0, void 0, function* () {
+        if (mongo === undefined) {
+            mongo = (yield Promise.resolve().then(() => require('mongoose'))).mongo;
         }
-    }
-    if (mongoose_1.mongo.BSON.BSONError.isBSONError(handledError)) {
-        handledError = new factory_1.errors.Argument('', handledError.message);
-    }
-    return handledError;
+        let handledError = error;
+        if (handledError instanceof mongo.MongoError || handledError instanceof mongo.MongoServerError) {
+            switch (handledError.code) {
+                case MongoErrorCode.DuplicateKey:
+                    handledError = new factory_1.errors.AlreadyInUse('', [], `Some fields already in use. code:${handledError.code} message:${handledError.message}`);
+                    // no op
+                    break;
+                case MongoErrorCode.MaxTimeMSExpired:
+                case MongoErrorCode.ExceededTimeLimit:
+                    handledError = new factory_1.errors.GatewayTimeout(`Gateway Timeout. name:${handledError.name} code:${handledError.code} message:${handledError.message}`);
+                    break;
+                default:
+            }
+        }
+        if (mongo.BSON.BSONError.isBSONError(handledError)) {
+            handledError = new factory_1.errors.Argument('', handledError.message);
+        }
+        return handledError;
+    });
 }
 exports.handleMongoError = handleMongoError;
 /**

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

@@ -0,0 +1,42 @@
+import * as factory from '../factory';
+export type IPassportValidator = (params: {
+    passport: factory.waiter.passport.IPassport;
+}) => boolean;
+export declare namespace moneyTransfer {
+    type IStartParams = factory.transaction.moneyTransfer.IStartParamsWithoutDetail & {
+        passportValidator?: IPassportValidator;
+    };
+}
+export declare namespace placeOrder {
+    type IStartParams = factory.transaction.placeOrder.IStartParamsWithoutDetail & {
+        passportValidator?: IPassportValidator;
+        broker?: factory.order.IBroker;
+        validateSeller?: boolean;
+    };
+    type IOrderURLGenerator = (order: factory.order.IOrder) => string;
+    type IResultOrderParams = factory.transaction.placeOrder.IResultOrderParams & {
+        /**
+         * 注文日時
+         */
+        orderDate: Date;
+        /**
+         * 注文確認URLのカスタム指定
+         */
+        url?: string | IOrderURLGenerator;
+        /**
+         * 注文アイテム数
+         */
+        numItems?: {
+            maxValue?: number;
+            minValue?: number;
+        };
+    };
+    type IConfirmParams = factory.transaction.placeOrder.IConfirmParams & {
+        project: {
+            id: string;
+        };
+        result: {
+            order: IResultOrderParams;
+        };
+    };
+}

package/lib/chevre/factory/transaction.js

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

package/lib/chevre/index.d.ts

@@ -1,15 +1,15 @@
 /**
  * index module
  */
-import * as COA from '@motionpicture/coa-service';
-import * as GMO from '@motionpicture/gmo-service';
-import * as surfrock from '@surfrock/sdk';
+import type * as GMOService from '@motionpicture/gmo-service';
+import type * as Pecorinoapi from './pecorinoapi';
 import { credentials } from './credentials';
 import * as errorHandler from './errorHandler';
 import * as eventEmitter from './eventEmitter';
 import * as factory from './factory';
-import * as pecorinoapi from './pecorinoapi';
 import * as repository from './repository';
 import * as service from './service';
 import * as settings from './settings';
-export { credentials, errorHandler, eventEmitter, factory, repository, service, settings, surfrock, pecorinoapi, COA, GMO };
+export { credentials, errorHandler, eventEmitter, factory, repository, service, settings };
+export declare function loadPecorinoapi(): Promise<typeof Pecorinoapi>;
+export declare function loadGMO(): Promise<typeof GMOService>;

package/lib/chevre/index.js

@@ -1,15 +1,15 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMO = exports.COA = exports.pecorinoapi = exports.surfrock = exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = exports.credentials = void 0;
-/**
- * index module
- */
-const COA = require("@motionpicture/coa-service");
-exports.COA = COA;
-const GMO = require("@motionpicture/gmo-service");
-exports.GMO = GMO;
-const surfrock = require("@surfrock/sdk");
-exports.surfrock = surfrock;
+exports.loadGMO = exports.loadPecorinoapi = exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = exports.credentials = void 0;
 const credentials_1 = require("./credentials");
 Object.defineProperty(exports, "credentials", { enumerable: true, get: function () { return credentials_1.credentials; } });
 const errorHandler = require("./errorHandler");
@@ -18,11 +18,29 @@ const eventEmitter = require("./eventEmitter");
 exports.eventEmitter = eventEmitter;
 const factory = require("./factory");
 exports.factory = factory;
-const pecorinoapi = require("./pecorinoapi");
-exports.pecorinoapi = pecorinoapi;
 const repository = require("./repository");
 exports.repository = repository;
 const service = require("./service");
 exports.service = service;
 const settings = require("./settings");
 exports.settings = settings;
+let pecorinoapi;
+function loadPecorinoapi() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (pecorinoapi === undefined) {
+            pecorinoapi = yield Promise.resolve().then(() => require('./pecorinoapi'));
+        }
+        return pecorinoapi;
+    });
+}
+exports.loadPecorinoapi = loadPecorinoapi;
+let GMO;
+function loadGMO() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (GMO === undefined) {
+            GMO = yield Promise.resolve().then(() => require('@motionpicture/gmo-service'));
+        }
+        return GMO;
+    });
+}
+exports.loadGMO = loadGMO;

package/lib/chevre/pecorinoapi.d.ts

@@ -1,6 +1,5 @@
 /**
  * Pecorino API Client
  */
-import { auth, pecorino } from '@cinerino/sdk';
-export import service = pecorino.service;
-export import auth = auth;
+import { auth, loadPecorino, pecorino } from '@cinerino/sdk';
+export { auth, loadPecorino, pecorino };

package/lib/chevre/pecorinoapi.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.auth = exports.service = void 0;
+exports.loadPecorino = exports.auth = void 0;
 /**
  * Pecorino API Client
  */
 const sdk_1 = require("@cinerino/sdk");
-exports.service = sdk_1.pecorino.service;
-exports.auth = sdk_1.auth;
+Object.defineProperty(exports, "auth", { enumerable: true, get: function () { return sdk_1.auth; } });
+Object.defineProperty(exports, "loadPecorino", { enumerable: true, get: function () { return sdk_1.loadPecorino; } });

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

@@ -1,4 +1,4 @@
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * 口座リポジトリ

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

@@ -22,7 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection, Model } from 'mongoose';
+import type { Connection, Model } from 'mongoose';
 /**
  * 科目リポジトリ
  */

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

@@ -1,4 +1,4 @@
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * 口座取引リポジトリ

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

@@ -1,4 +1,4 @@
-import { Connection, Model } from 'mongoose';
+import type { Connection, Model } from 'mongoose';
 import * as factory from '../factory';
 export type IOrder4report = factory.report.accountingReport.IOrderAsMainEntity;
 export interface IAccountingReport {

package/lib/chevre/repo/accountingReport.js

@@ -30,7 +30,7 @@ class MongoRepository {
             }
             catch (error) {
                 let throwsError = true;
-                if ((0, errorHandler_1.isMongoError)(error)) {
+                if (yield (0, errorHandler_1.isMongoError)(error)) {
                     // すでにorderNumberが存在する場合ok
                     if (error.code === errorHandler_1.MongoErrorCode.DuplicateKey) {
                         throwsError = false;

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

@@ -22,7 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 export type IAction<T extends factory.actionType> = T extends factory.actionType.OrderAction ? factory.action.trade.order.IAction : T extends factory.actionType.AuthorizeAction ? factory.action.authorize.IAction<factory.action.authorize.IAttributes<any, any>> : factory.action.IAction<factory.action.IAttributes<T, any, any>>;
 export type IPayAction = factory.action.trade.pay.IAction;

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

@@ -1,4 +1,4 @@
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * 追加特性リポジトリ

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

@@ -1,4 +1,4 @@
-import { AnyExpression, Connection, PipelineStage } from 'mongoose';
+import type { AnyExpression, Connection, PipelineStage } from 'mongoose';
 import * as factory from '../factory';
 type IMatchStage = PipelineStage.Match;
 type KeyOfUnitPriceOffer = keyof factory.unitPriceOffer.IUnitPriceOffer;

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

@@ -1,4 +1,4 @@
-import { Connection, Model } from 'mongoose';
+import type { Connection, Model } from 'mongoose';
 import * as factory from '../factory';
 export declare enum AggregationType {
     AggregateAuthorizeEventServiceOfferAction = "AggregateAuthorizeEventServiceOfferAction",

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

@@ -22,7 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 interface IAggregationByStatus {
     transactionCount: number;

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

@@ -22,7 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * 区分リポジトリ

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

@@ -1,4 +1,4 @@
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 import { modelName } from './mongoose/schemas/authorization';
 export type IObject = factory.authorization.IObject;

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

@@ -22,7 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * コメントリポジトリ

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

@@ -22,7 +22,8 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Connection } from 'mongoose';
+import type { BulkWriteResult } from 'mongodb';
+import type { Connection } from 'mongoose';
 import * as factory from '../factory';
 /**
  * コンテンツリポジトリ
@@ -35,10 +36,15 @@ export declare class MongoRepository {
      * コンテンツを保管する
      */
     saveMovie(params: factory.creativeWork.movie.ICreativeWork): Promise<any>;
+    /**
+     * コードをキーにして冪等作成
+     */
+    upsertMoviesByIdentifier(params: {
+        attributes: factory.creativeWork.movie.ICreativeWork;
+    }[]): Promise<BulkWriteResult | void>;
     findMovieById(params: {
         id: string;
     }): Promise<factory.creativeWork.movie.ICreativeWork>;
-    countMovies(params: factory.creativeWork.movie.ISearchConditions): Promise<number>;
     /**
      * コンテンツを検索する
      */