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

package/example/src/chevre/aggregateAllEvents2.ts

@@ -35,8 +35,47 @@ export async function aggregateScreeningEvent() {
             try {
                 console.log('executing...', count);
                 await (await chevre.service.task.createService()).executeByName({
-                    name: chevre.factory.taskName.AggregateScreeningEvent
-                })({ connection: mongoose.connection, redisClient: redisClient });
+                    name: chevre.factory.taskName.AggregateScreeningEvent,
+                    executor: { name: 'sample' }
+                })({
+                    connection: mongoose.connection,
+                    redisClient,
+                    credentials: {
+                        sendGrid: await chevre.credentials.SendGrid.createInstance({ apiKey: 'xxx' })
+                    },
+                    settings: new chevre.settings.Settings({
+                        onEventChanged: {
+                            informEvent: []
+                        },
+                        onOrderStatusChanged: {
+                            informOrder: []
+                        },
+                        onResourceUpdated: {
+                            informResource: []
+                        },
+                        onReservationStatusChanged: {
+                            informReservation: []
+                        },
+                        notification: {
+                            timeout: 1000,
+                            useFetchAPI: true
+                        },
+                        userPoolIdOld: '',
+                        userPoolIdNew: '',
+                        useAggregateEntranceGateProjects: [],
+                        useAggregateOfferProjects: [],
+                        useOfferRateLimitProjects: [],
+                        defaultSenderEmail: 'test@example.com',
+                        deliverOrderLimit: 1,
+                        transaction: { informUrls: [], confirmedStoragePeriodInDays: 365, canceledStoragePeriodInDays: 365 },
+                        abortedTasksWithoutReport: [],
+                        gmo: { timeout: 1000, timeoutBackground: 1000, useFetch: true },
+                        movieticketReserve: { timeout: 1000, timeoutCheck: 1000 },
+                        numTryConfirmReserveTransaction: 10,
+                        useAssetTransactionSyncProcessing: true,
+                        useExperimentalFeature: false
+                    })
+                });
                 console.log('executed', count);
             } catch (error) {
                 console.error(error);

package/example/src/chevre/aggregation/aggregateSystem.ts

@@ -16,6 +16,7 @@ async function main() {
 
     const aggregationRepo = await chevre.repository.Aggregation.createInstance(mongoose.connection);
     const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
     const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
     const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
     const actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
@@ -23,17 +24,30 @@ async function main() {
 
     let result: { aggregationCount: number; aggregateDuration: string };
 
-    result = await (await chevre.service.aggregation.createService()).system.aggregateReserveAction({
+    result = await (await chevre.service.aggregation.createService()).system.aggregateOrder({
         aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
         aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        action: actionRepo
+        order: orderRepo
     });
-    console.log('aggregateReserveAction processed.', result);
+    console.log('aggregateOrder processed.', result);
+    // return;
 
-    result = await (await chevre.service.aggregation.createService()).system.aggregateOrderAction({
+    result = await (await chevre.service.aggregation.createService()).system.aggregatePlaceOrder({
+        aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
+        aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+    console.log('aggregatePlaceOrder processed.', result);
+    // return;
+
+    result = await (await chevre.service.aggregation.createService()).system.aggregateReserveAction({
         aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
         aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
@@ -43,7 +57,7 @@ async function main() {
     });
     console.log('aggregateReserveAction processed.', result);
 
-    result = await (await chevre.service.aggregation.createService()).system.aggregateCancelReservationAction({
+    result = await (await chevre.service.aggregation.createService()).system.aggregateOrderAction({
         aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
         aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
@@ -51,19 +65,17 @@ async function main() {
         agregation: aggregationRepo,
         action: actionRepo
     });
-    console.log('aggregateCancelReservationAction processed.', result);
+    console.log('aggregateReserveAction processed.', result);
 
-    result = await (await chevre.service.aggregation.createService()).system.aggregatePlaceOrder({
+    result = await (await chevre.service.aggregation.createService()).system.aggregateCancelReservationAction({
         aggregateDurationUnit: AGGREGATE_DURATION_UNIT,
         aggregationCount: (AGGREGATE_DURATION_UNIT === 'hours') ? AGGREGATE_DAYS * ONE_DAY_IN_HOURS : AGGREGATE_DAYS,
-        excludedProjectId: EXCLUDED_PROJECT_ID,
-        clientIds: AGGREGATE_CLIENT_IDS
+        excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        transaction: transactionRepo
+        action: actionRepo
     });
-    console.log('aggregatePlaceOrder processed.', result);
-    // return;
+    console.log('aggregateCancelReservationAction processed.', result);
 
     result = await (await chevre.service.aggregation.createService()).system.aggregateTask({
         aggregateDurationUnit: AGGREGATE_DURATION_UNIT,

package/example/src/chevre/findReservationByCode.ts

@@ -28,11 +28,23 @@ async function main() {
         ticket: {
             ticketToken: CODE
         }
-    })({
-        authorization: authorizationRepo,
-        order: orderRepo,
-        ticket: ticketRepo
-    });
+    })(
+        {
+            authorization: authorizationRepo,
+            order: orderRepo,
+            ticket: ticketRepo
+        },
+        {
+            jwt: await chevre.credentials.JWT.createInstance({
+                secret: <string>process.env.TOKEN_SECRET,
+                issuers: (typeof process.env.TOKEN_ISSUERS_BY_AUTHORIZATION === 'string')
+                    ? process.env.TOKEN_ISSUERS_BY_AUTHORIZATION.split(' ')
+                    : [],
+                version: (typeof process.env.TOKEN_VERSION === 'string') ? process.env.TOKEN_VERSION : '2024-05-02',
+                payloadTypPrefix: (typeof process.env.TOKEN_PAYLOAD_TYP_PREFIX === 'string') ? process.env.TOKEN_PAYLOAD_TYP_PREFIX : 'chevre'
+            })
+        }
+    );
     console.log('verified.');
 
     const result = await (await chevre.service.reserve.createService()).findByCode({

package/example/src/chevre/findValidAuthorization.ts

@@ -33,10 +33,22 @@ async function main() {
         issuer: 'https://example.com',
         audience: 'https://example.com',
         useJti: true
-    })({
-        authorization: authorizationRepo,
-        ticket: ticketRepo
-    });
+    })(
+        {
+            authorization: authorizationRepo,
+            ticket: ticketRepo
+        },
+        {
+            jwt: await chevre.credentials.JWT.createInstance({
+                secret: <string>process.env.TOKEN_SECRET,
+                issuers: (typeof process.env.TOKEN_ISSUERS_BY_AUTHORIZATION === 'string')
+                    ? process.env.TOKEN_ISSUERS_BY_AUTHORIZATION.split(' ')
+                    : [],
+                version: (typeof process.env.TOKEN_VERSION === 'string') ? process.env.TOKEN_VERSION : '2024-05-02',
+                payloadTypPrefix: (typeof process.env.TOKEN_PAYLOAD_TYP_PREFIX === 'string') ? process.env.TOKEN_PAYLOAD_TYP_PREFIX : 'chevre'
+            })
+        }
+    );
     console.log('token:', token);
 }
 

package/example/src/chevre/importCategoryCodesFromCOA.ts

@@ -1,28 +1,25 @@
 // tslint:disable:no-console
-import * as COA from '@motionpicture/coa-service';
-// import * as redis from 'redis';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
 
-const coaAuthClient = new COA.auth.RefreshToken({
-    endpoint: chevre.credentials.coa.endpoint,
-    refreshToken: chevre.credentials.coa.refreshToken,
-    useFetch: chevre.credentials.coa.useFetch
-});
-
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
     const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
-    const masterService = new COA.service.Master(
+    const coaAuthClient = new (await chevre.loadCOA()).auth.RefreshToken({
+        endpoint: '',
+        refreshToken: '',
+        useFetch: true
+    });
+    const masterService = new (await chevre.loadCOA()).service.Master(
         {
-            endpoint: chevre.credentials.coa.endpoint,
+            endpoint: '',
             auth: coaAuthClient
         },
-        { timeout: chevre.credentials.coa.timeout }
+        { timeout: 20000 }
     );
 
     await (await chevre.service.offer.createService()).event.importCategoryCodesFromCOA({

package/example/src/chevre/importEventsFromCOA.ts

@@ -18,6 +18,19 @@ async function main() {
     const movieTheaterRepo = await chevre.repository.place.MovieTheater.createInstance(mongoose.connection);
     const sellerRepo = await chevre.repository.Seller.createInstance(mongoose.connection);
 
+    const coaAuthClient = new (await chevre.loadCOA()).auth.RefreshToken({
+        endpoint: '',
+        refreshToken: '',
+        useFetch: true
+    });
+    const masterService = new (await chevre.loadCOA()).service.Master(
+        {
+            endpoint: '',
+            auth: coaAuthClient
+        },
+        { timeout: 20000 }
+    );
+
     await (await chevre.service.event.createService()).importFromCOA({
         project: {
             id: project.id,
@@ -39,7 +52,8 @@ async function main() {
         event: eventRepo,
         movieTheater: movieTheaterRepo,
         screeningRoom: screeningRoomRepo,
-        seller: sellerRepo
+        seller: sellerRepo,
+        masterService
     });
     console.log('imported');
 }

package/example/src/chevre/migrateCognitoUser.ts

@@ -1,4 +1,7 @@
 // tslint:disable:no-console
+import { CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
+import { fromEnv } from '@aws-sdk/credential-providers';
+
 import { chevre } from '../../../lib/index';
 
 export const USERPOOL_ID_OLD = String(process.env.USERPOOL_ID_OLD);
@@ -9,11 +12,21 @@ const NEW_USERPOOL_PROVIDER_NAME = 'SSKTS';
 export async function migrateUser(params: {
     id: string;
 }): Promise<void> {
+    const awsCredentials = fromEnv();
+    const cognitoIdentityServiceProvider = new CognitoIdentityProvider({
+        apiVersion: 'latest',
+        region: 'ap-northeast-1',
+        credentials: awsCredentials
+    });
+
     // 旧会員を取得
     let oldPerson: chevre.factory.person.IPerson | undefined;
 
     try {
-        const oldPersonRepo = await chevre.repository.Person.createInstance({ userPoolId: USERPOOL_ID_OLD });
+        const oldPersonRepo = await chevre.repository.Person.createInstance({
+            userPoolId: USERPOOL_ID_OLD,
+            cognitoIdentityServiceProvider
+        });
         oldPerson = await oldPersonRepo.findById({ userId: params.id });
         console.log('oldPerson found', oldPerson.id, oldPerson.givenName, oldPerson.familyName);
     } catch (error) {
@@ -33,7 +46,10 @@ export async function migrateUser(params: {
     }
 
     // create user
-    const newPersonRepo = await chevre.repository.Person.createInstance({ userPoolId: USERPOOL_ID_NEW });
+    const newPersonRepo = await chevre.repository.Person.createInstance({
+        userPoolId: USERPOOL_ID_NEW,
+        cognitoIdentityServiceProvider
+    });
     const newUsername = `${NEW_USERPOOL_PROVIDER_NAME}_${oldPerson.id}`;
     const newUserId = await new Promise<string>((resolve, reject) => {
         newPersonRepo.cognitoIdentityServiceProvider.adminCreateUser(

package/example/src/chevre/person/updateProfile.ts

@@ -1,9 +1,18 @@
+import { CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
+import { fromEnv } from '@aws-sdk/credential-providers';
+
 // tslint:disable:no-console no-magic-numbers
 import { chevre } from '../../../../lib/index';
 
 async function main() {
+    const awsCredentials = fromEnv();
     const personRepo = await chevre.repository.Person.createInstance({
-        userPoolId: <string>process.env.COGNITO_USER_POOL_ID
+        userPoolId: <string>process.env.COGNITO_USER_POOL_ID,
+        cognitoIdentityServiceProvider: new CognitoIdentityProvider({
+            apiVersion: 'latest',
+            region: 'ap-northeast-1',
+            credentials: awsCredentials
+        })
     });
 
     const username = 'xxx';

package/example/src/chevre/processOrder.ts

@@ -64,7 +64,10 @@ async function main() {
                     serialNumbers,
                     offeredThroughIdentifier
                 },
-                options: { force: true }
+                options: {
+                    force: true,
+                    numTryConfirmReserveTransaction: 10
+                }
             })({ task: taskRepo });
             console.log('order processed', order.orderNumber);
             updateCount += 1;

package/example/src/chevre/searchReservationsByOrder.ts

@@ -8,19 +8,31 @@ const project = { id: String(process.env.PROJECT_ID) };
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
+    const coaAuthClient = new (await chevre.loadCOA()).auth.RefreshToken({
+        endpoint: '',
+        refreshToken: '',
+        useFetch: true
+    });
+
     const { reservations } = await (await chevre.service.reserve.createService()).searchByOrder({
         limit: 10,
         page: 1,
         project: { id: project.id },
         orderNumber: 'CIN3-0760465-8981560',
-        // orderNumber: 'SSK1-3743647-5975553',
-        // orderNumber: 'SSK9-4864565-8689164',
         typeOf: chevre.factory.reservationType.EventReservation
     })({
         acceptedOffer: await chevre.repository.AcceptedOffer.createInstance(mongoose.connection),
         order: await chevre.repository.Order.createInstance(mongoose.connection),
-        reservation: await chevre.repository.Reservation.createInstance(mongoose.connection)
+        reservation: await chevre.repository.Reservation.createInstance(mongoose.connection),
+        reserveService: new (await chevre.loadCOA()).service.Reserve(
+            {
+                endpoint: '',
+                auth: coaAuthClient
+            },
+            { timeout: 20000 }
+        )
     });
+
     console.log(reservations);
     console.log(reservations.length, 'reservations found');
 }

package/lib/chevre/credentials/coa.d.ts

@@ -0,0 +1,17 @@
+interface IOptions {
+    endpoint: string;
+    refreshToken: string;
+    timeout: number;
+    useFetch: boolean;
+}
+/**
+ * COA認証情報
+ */
+declare class COACredentials {
+    readonly endpoint: string;
+    readonly refreshToken: string;
+    readonly timeout: number;
+    readonly useFetch: boolean;
+    constructor(options: IOptions);
+}
+export { COACredentials };

package/lib/chevre/credentials/coa.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COACredentials = void 0;
+/**
+ * COA認証情報
+ */
+class COACredentials {
+    constructor(options) {
+        this.timeout = 20000;
+        const { endpoint, refreshToken, timeout, useFetch } = options;
+        this.endpoint = endpoint;
+        this.refreshToken = refreshToken;
+        this.timeout = timeout;
+        this.useFetch = useFetch;
+    }
+}
+exports.COACredentials = COACredentials;

package/lib/chevre/credentials/customSearch.d.ts

@@ -0,0 +1,13 @@
+interface IOptions {
+    engineId: string;
+    apiKey: string;
+}
+/**
+ * GoogleCustomSearch認証情報
+ */
+declare class CustomSearchCredentials {
+    readonly engineId: string;
+    readonly apiKey: string;
+    constructor(options: IOptions);
+}
+export { CustomSearchCredentials };

package/lib/chevre/credentials/customSearch.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSearchCredentials = void 0;
+/**
+ * GoogleCustomSearch認証情報
+ */
+class CustomSearchCredentials {
+    constructor(options) {
+        const { engineId, apiKey } = options;
+        this.engineId = engineId;
+        this.apiKey = apiKey;
+    }
+}
+exports.CustomSearchCredentials = CustomSearchCredentials;

package/lib/chevre/credentials/jwt.d.ts

@@ -0,0 +1,23 @@
+interface IOptions {
+    secret: string;
+    /**
+     * トークン検証時の発行者リスト
+     */
+    issuers: string[];
+    version: string;
+    payloadTypPrefix: string;
+}
+/**
+ * トークン認証情報
+ */
+declare class JWTCredentials {
+    readonly secret: string;
+    /**
+     * トークン検証時の発行者リスト
+     */
+    readonly issuers: string[];
+    readonly version: string;
+    readonly payloadTypPrefix: string;
+    constructor(options: IOptions);
+}
+export { JWTCredentials };

package/lib/chevre/credentials/jwt.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWTCredentials = void 0;
+/**
+ * トークン認証情報
+ */
+class JWTCredentials {
+    constructor(options) {
+        this.version = '2024-05-02'; // 追加(2024-05-02~)
+        this.payloadTypPrefix = 'chevre';
+        const { secret, issuers, version, payloadTypPrefix } = options;
+        this.issuers = issuers;
+        this.payloadTypPrefix = payloadTypPrefix;
+        this.secret = secret;
+        this.version = version;
+    }
+}
+exports.JWTCredentials = JWTCredentials;

package/lib/chevre/credentials/lineNotify.d.ts

@@ -0,0 +1,17 @@
+interface IOptions {
+    url: string;
+    accessToken: string;
+    accessTokenAlert: string;
+    accessTokenInfo: string;
+}
+/**
+ * 通知認証情報
+ */
+declare class LINENotifyCredentials {
+    readonly url: string;
+    readonly accessToken: string;
+    readonly accessTokenAlert: string;
+    readonly accessTokenInfo: string;
+    constructor(options: IOptions);
+}
+export { LINENotifyCredentials };

package/lib/chevre/credentials/lineNotify.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINENotifyCredentials = void 0;
+/**
+ * 通知認証情報
+ */
+class LINENotifyCredentials {
+    constructor(options) {
+        const { url, accessToken, accessTokenAlert, accessTokenInfo } = options;
+        this.url = url;
+        this.accessToken = accessToken;
+        this.accessTokenAlert = accessTokenAlert;
+        this.accessTokenInfo = accessTokenInfo;
+    }
+}
+exports.LINENotifyCredentials = LINENotifyCredentials;

package/lib/chevre/credentials/sendGrid.d.ts

@@ -0,0 +1,11 @@
+interface IOptions {
+    apiKey: string;
+}
+/**
+ * SendGrid認証情報
+ */
+declare class SendGridCredentials {
+    readonly apiKey: string;
+    constructor(options: IOptions);
+}
+export { SendGridCredentials };

package/lib/chevre/credentials/sendGrid.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendGridCredentials = void 0;
+/**
+ * SendGrid認証情報
+ */
+class SendGridCredentials {
+    constructor(options) {
+        const { apiKey } = options;
+        this.apiKey = apiKey;
+    }
+}
+exports.SendGridCredentials = SendGridCredentials;

package/lib/chevre/credentials.d.ts

@@ -1,59 +1,30 @@
+import type { COACredentials } from './credentials/coa';
+import type { CustomSearchCredentials } from './credentials/customSearch';
+import type { JWTCredentials } from './credentials/jwt';
+import type { LINENotifyCredentials } from './credentials/lineNotify';
+import type { SendGridCredentials } from './credentials/sendGrid';
 /**
- * 外部サービスを使用するための認証情報
+ * 外部サービス認証情報
  */
-export declare const credentials: {
-    aws: {
-        accessKeyId: string;
-        secretAccessKey: string;
-        tokenIssuerEndpoint: string;
-    };
-    chevre: {
-        authorizeServerDomain: string;
-        clientId: string;
-        clientSecret: string;
-        endpoint: string;
-    };
-    coa: {
-        endpoint: string;
-        refreshToken: string;
-        timeout: number;
-        useFetch: boolean;
-    };
-    customSearch: {
-        engineId: string;
-        apiKey: string;
-    };
-    gmo: {
-        timeout: number;
-        timeoutBackground: number | undefined;
-        useFetch: boolean;
-    };
-    lineNotify: {
-        url: string | undefined;
-        accessToken: string | undefined;
-        accessTokenAlert: string | undefined;
-        accessTokenInfo: string | undefined;
-    };
-    movieticketReserve: {
-        /**
-         * 着券時タイムアウト
-         */
-        timeout: number;
-        /**
-         * 認証時タイムアウト
-         */
-        timeoutCheck: number;
-    };
-    sendGrid: {
-        apiKey: string | undefined;
-    };
-    jwt: {
-        secret: string;
-        /**
-         * トークン検証時の発行者リスト
-         */
-        issuers: string[];
-        version: string;
-        payloadTypPrefix: string;
-    };
-};
+export declare namespace credentials {
+    type COA = COACredentials;
+    namespace COA {
+        function createInstance(...params: ConstructorParameters<typeof COACredentials>): Promise<COACredentials>;
+    }
+    type CustomSearch = CustomSearchCredentials;
+    namespace CustomSearch {
+        function createInstance(...params: ConstructorParameters<typeof CustomSearchCredentials>): Promise<CustomSearchCredentials>;
+    }
+    type JWT = JWTCredentials;
+    namespace JWT {
+        function createInstance(...params: ConstructorParameters<typeof JWTCredentials>): Promise<JWTCredentials>;
+    }
+    type LINENotify = LINENotifyCredentials;
+    namespace LINENotify {
+        function createInstance(...params: ConstructorParameters<typeof LINENotifyCredentials>): Promise<LINENotifyCredentials>;
+    }
+    type SendGrid = SendGridCredentials;
+    namespace SendGrid {
+        function createInstance(...params: ConstructorParameters<typeof SendGridCredentials>): Promise<SendGridCredentials>;
+    }
+}