@chevre/domain 22.11.0-alpha.9 → 22.12.0-alpha.0

package/example/src/chevre/searchProducts.ts

@@ -0,0 +1,28 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+
+    const products = await productRepo.projectFields(
+        {
+            limit: 10,
+            project: { id: { $eq: PROJECT_ID } },
+            additionalPropertyMatch: { nameEq: 'xxxxx' }
+            // seller: { id: { $eq: 'xxx' } }
+        },
+        ['additionalProperty', 'productID']
+    );
+    console.log(products);
+    console.log(products.length, 'products found');
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/settings/addSettings.ts

@@ -3,28 +3,42 @@ import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../../lib/index';
 
+const { INFORM_TASK_AGG_URL } = process.env;
+if (typeof INFORM_TASK_AGG_URL !== 'string') {
+    throw new Error('INFORM_TASK_AGG_URL required');
+}
+
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const settingRepo = await chevre.repository.Setting.createInstance(mongoose.connection);
-
-    const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['onOrderStatusChanged']);
-    const useInformReturnAction = (<any>setting)?.onOrderStatusChanged?.useInformReturnAction === true;
-    if (useInformReturnAction) {
-        console.log('already useInformReturnAction:true');
-    } else {
-        // update
-        await settingRepo.updateByProject4migration(
-            { project: { id: { $eq: '*' } } },
-            {
-                $set: {
-                    'onOrderStatusChanged.useInformReturnAction': true
-                }
+    // const setting = await settingRepo.findOne({ project: { id: { $eq: '*' } } }, ['onTaskStatusChanged']);
+    // update
+    await settingRepo.updateByProject(
+        { project: { id: { $eq: '*' } } },
+        {
+            onTaskStatusChanged: {
+                informTask: [{
+                    recipient: {
+                        name: 'Aggregation Service',
+                        url: INFORM_TASK_AGG_URL
+                    }
+                }],
+                informTaskNames: [
+                    chevre.factory.taskName.Pay,
+                    chevre.factory.taskName.InvalidatePaymentUrl,
+                    chevre.factory.taskName.Refund,
+                    chevre.factory.taskName.VoidPayment
+                    // chevre.factory.taskName.ConfirmReserveTransaction
+                ],
+                informTaskStatuses: [
+                    chevre.factory.taskStatus.Aborted
+                    // chevre.factory.taskStatus.Running
+                ]
             }
-        );
-        console.log('updated.');
-    }
-
+        }
+    );
+    console.log('updated.');
 }
 
 main()

package/example/src/chevre/task/countPotentiallyRunning.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+const excludedTaskNames = [
+    chevre.factory.taskName.DeleteTransaction,
+    chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+    chevre.factory.taskName.ImportEventsFromCOA,
+    chevre.factory.taskName.AcceptCOAOffer,
+    chevre.factory.taskName.CheckMovieTicket,
+    chevre.factory.taskName.AuthorizePayment,
+    chevre.factory.taskName.PublishPaymentUrl
+];
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    let allTaskNames = Object.values(chevre.factory.taskName);
+    allTaskNames = allTaskNames.filter((taskName) => !excludedTaskNames.includes(taskName));
+    console.log('allTaskNames:', allTaskNames, allTaskNames.length);
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const result = await taskRepo.countPotentiallyRunning({
+        name: {
+            $in: allTaskNames
+        },
+        runsAt: { $lt: new Date() },
+        limit: 100
+    });
+    console.log('result:', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/task/countTasks.ts

@@ -0,0 +1,51 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    setInterval(
+        async () => {
+            const readyTasksCountResult = await taskRepo.count({
+                limit: 100,
+                status: { $eq: chevre.factory.taskStatus.Ready },
+                runsThrough: new Date()
+            });
+            console.log('readyTasksCountResult:', readyTasksCountResult);
+
+            const readyTasks = await taskRepo.projectFields(
+                {
+                    limit: 10,
+                    status: { $eq: chevre.factory.taskStatus.Ready },
+                    runsThrough: new Date(),
+                    name: { $nin: [chevre.factory.taskName.DeleteTransaction] }
+                },
+                ['name']
+            );
+            console.log('readyTasks:', readyTasks);
+
+            const runningTasksCountResult = await taskRepo.count({
+                limit: 100,
+                status: { $eq: chevre.factory.taskStatus.Running },
+                runsThrough: new Date()
+            });
+            console.log('runningTasksCountResult:', runningTasksCountResult);
+        },
+        // tslint:disable-next-line:no-magic-numbers
+        10000
+    );
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{deleteRunsAtPassedCertainPeriod.ts → task/deleteRunsAtPassedCertainPeriod.ts}

@@ -2,9 +2,10 @@
 import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
-import { chevre } from '../../../lib/index';
+import { chevre } from '../../../../lib/index';
 
-const TASK_STORAGE_PERIOD_IN_MINUTES = 43200; // 30*24*60
+// const TASK_STORAGE_PERIOD_IN_MINUTES = 43200; // 30*24*60
+const TASK_STORAGE_PERIOD_IN_MINUTES = 20160; // 14*24*60
 
 async function main() {
     const now = new Date();
@@ -12,7 +13,7 @@ async function main() {
 
     const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
 
-    let taskInMinutes = 57600; // 40*24*60
+    let taskInMinutes = 21600; // 15*24*60
     // let taskInMinutes = 172800; // 120*24*60
     // tslint:disable-next-line:no-magic-numbers
     while (taskInMinutes > TASK_STORAGE_PERIOD_IN_MINUTES) {

package/example/src/chevre/task/deleteUnexpectedTasks.ts

@@ -0,0 +1,23 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+    const result = await taskRepo.taskModel.deleteMany({
+        $or: [
+            { name: { $exists: false } },
+            { status: { $exists: false } }
+        ]
+    })
+        .exec();
+
+    console.log('success!', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/task/emitRunning.ts

@@ -0,0 +1,89 @@
+// tslint:disable:no-console no-magic-numbers
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const delayInSeconds = 60;
+const numExecuteByRequest = 50;
+const selfName = 'sample';
+
+const excludedTaskNames = [
+    chevre.factory.taskName.DeleteTransaction,
+    chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+    chevre.factory.taskName.ImportEventsFromCOA,
+    chevre.factory.taskName.AcceptCOAOffer,
+    chevre.factory.taskName.CheckMovieTicket,
+    chevre.factory.taskName.AuthorizePayment,
+    chevre.factory.taskName.PublishPaymentUrl
+];
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false, appName: 'sample' });
+
+    const now = new Date();
+    const runsAtLt = moment(now)
+        .add(-delayInSeconds, 'seconds')
+        .toDate();
+
+    let allTaskNames = Object.values(chevre.factory.taskName);
+    allTaskNames = allTaskNames.filter((name) => !excludedTaskNames.includes(name));
+    console.log('allTaskNames:', allTaskNames, allTaskNames.length);
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const delayedTask: Pick<chevre.factory.task.ITask<chevre.factory.taskName>, 'id' | 'name'>[] = [];
+
+    // const { count } = await taskRepo.countPotentiallyRunning({
+    //     name: { $in: allTaskNames },
+    //     runsAt: { $lt: runsAtLt },
+    //     limit: numExecuteByRequest
+    // });
+    // console.log('countPotentiallyRunning:', count);
+    // const executeCount: number = Math.min(count, numExecuteByRequest);
+    const executeCount: number = numExecuteByRequest;
+    const sort: {
+        numberOfTried?: chevre.factory.sortType;
+        runsAt?: chevre.factory.sortType;
+    } = {
+        numberOfTried: chevre.factory.sortType.Ascending, // numberOfTriedソートを加えるとどうなるのか？
+        runsAt: chevre.factory.sortType.Ascending
+    };
+
+    for (let i = 0; i < executeCount; i += 1) {
+        const runningTask = await taskRepo.emitRunningIfExists(
+            {
+                name: { $in: allTaskNames },
+                runsAt: { $lt: runsAtLt },
+                sort,
+                executor: {
+                    name: selfName
+                },
+                nameFilterBeforeRunsAt: false
+            }
+        );
+        console.log('runningTask found', JSON.stringify(runningTask), i, now);
+        if (runningTask !== null) {
+            delayedTask.push(runningTask);
+        }
+    }
+}
+
+const interval = setInterval(
+    () => {
+        main()
+            .then()
+            .catch(console.error);
+    },
+    1000
+);
+
+setTimeout(
+    () => {
+        clearInterval(interval);
+        console.log('interval cleared');
+    },
+    600000
+);

package/example/src/idaas/auth0/adminApplications.ts

@@ -0,0 +1,183 @@
+// tslint:disable:no-implicit-dependencies no-console no-magic-numbers
+import { ManagementClient } from 'auth0';
+import { readFileSync } from 'fs';
+import * as moment from 'moment';
+// import * as crypto from 'crypto'; // client_secret 生成用 (PKJWTなしの場合)
+// import { JWK, importPKCS8, generateKeyPair, SignJWT } from 'jose'; // Private Key JWT 用
+
+const PUBLIC_KEY_FILE_PATH = `${__dirname}/../../samplePublicKey.pem`;
+const { AUTH0_DOMAIN, AUTH0_MGMT_CLIENT_ID, AUTH0_MGMT_CLIENT_SECRET, AUTH0_MGMT_API_AUDIENCE, AUTH0_AUDIENCE } = process.env;
+
+if (typeof AUTH0_DOMAIN !== 'string'
+    || typeof AUTH0_MGMT_CLIENT_ID !== 'string'
+    || typeof AUTH0_MGMT_CLIENT_SECRET !== 'string'
+    || typeof AUTH0_MGMT_API_AUDIENCE !== 'string'
+    || typeof AUTH0_AUDIENCE !== 'string'
+) {
+    throw new Error('set envs!');
+}
+
+// --- Auth0 ManagementClient の初期化 ---
+const management = new ManagementClient({
+    domain: AUTH0_DOMAIN,
+    clientId: AUTH0_MGMT_CLIENT_ID,
+    clientSecret: AUTH0_MGMT_CLIENT_SECRET,
+    audience: AUTH0_MGMT_API_AUDIENCE
+    // scope: 'read:clients create:clients' // 必要なスコープを明示
+});
+
+async function sleep(waitInSeconds: number) {
+    await new Promise<void>((resolve) => {
+        setTimeout(
+            () => {
+                resolve();
+            },
+            waitInSeconds
+        );
+    });
+}
+
+/**
+ * アプリケーションを検索し、存在しなければ作成します。
+ * Private Key JWT 認証を使用する前提。
+ */
+async function findOrCreateServiceAccount(
+    appName: string,
+    projectId: string,
+    roles: string[],
+    audience: string
+) {
+    try {
+        console.log('getting organization...');
+        const getOrganizationResponse = await management.organizations.getByName({
+            name: projectId
+        });
+        const organization = getOrganizationResponse.data;
+        console.log('organization exists.', organization);
+
+        const newClient = (await management.clients.create({
+            name: appName,
+            app_type: 'non_interactive', // Machine to Machine アプリケーション
+            jwt_configuration: { // Private Key JWT の設定
+                alg: 'RS256' // 署名アルゴリズム
+            },
+            // token_endpoint_auth_method: 'client_secret_post',
+            client_authentication_methods: {
+                private_key_jwt: {
+                    credentials: [{
+                        alg: 'RS256',
+                        /**
+                         * Credential type. Supported types: public_key.
+                         *
+                         */
+                        credential_type: 'public_key',
+                        // name?: string;
+                        pem: readFileSync(PUBLIC_KEY_FILE_PATH, 'utf8')
+
+                    }]
+                }
+            },
+            grant_types: ['client_credentials'],
+            organization_usage: 'require', // 組織での利用を許可
+            default_organization: {
+                organization_id: organization.id,
+                flows: ['client_credentials']
+            },
+            oidc_conformant: true,
+            client_metadata: {
+                roles: JSON.stringify(roles)
+            }
+        })).data;
+        console.log(`Successfully created new application: ${newClient.client_id} (${newClient.name})`);
+
+        console.log(`checking clientGrant... ${newClient.client_id} (${newClient.name})`);
+        await sleep(3000);
+
+        let clientGrant = (await management.clientGrants.getAll({
+            audience,
+            client_id: newClient.client_id
+        })).data.shift();
+        if (clientGrant === undefined) {
+            clientGrant = (await management.clientGrants.create({
+                client_id: newClient.client_id,
+                audience,
+                organization_usage: 'require',
+                allow_any_organization: false,
+                scope: ['iam.members.me.read']
+            })).data;
+            console.log(`clientGrant created. ${newClient.client_id} (${newClient.name})`);
+        } else {
+            console.log(`clientGrant already exists. ${newClient.client_id} (${newClient.name})`);
+        }
+
+        console.log(`checking organizationClientGrant... ${newClient.client_id} (${newClient.name})`);
+        await sleep(3000);
+        const organizationClientGrant = (await management.organizations.getOrganizationClientGrants({
+            id: organization.id,
+            audience: 'https://development.apis.smart-theater.com',
+            client_id: newClient.client_id
+        })).data.shift();
+        if (organizationClientGrant === undefined) {
+            await management.organizations.postOrganizationClientGrants(
+                {
+                    id: organization.id
+                },
+                {
+                    grant_id: clientGrant.id
+                }
+            );
+            console.log(`organizationClientGrant created. ${newClient.client_id} (${newClient.name})`);
+        } else {
+            console.log(`organizationClientGrant already exists. ${newClient.client_id} (${newClient.name})`);
+        }
+
+        // 1. アプリケーションを検索 (名前で検索するのが一般的)
+        console.log('searching for applications...');
+        await sleep(3000);
+
+        await searchClients({ organization });
+    } catch (error) {
+        console.error(`Error finding or creating application: ${error.message}`);
+        throw error;
+    }
+}
+
+async function searchClients(params: {
+    organization: { id: string };
+}) {
+    const existingApps = await management.clients.getAll({
+        include_totals: true,
+        // app_type: 'non_interactive',
+        // is_global: false,
+        // page: 0,
+        // per_page: 50,
+        // q: `name:"${appName}"`, // 名前で検索
+        q: `client_grant.organization_id:"${params.organization.id}"`,
+        // from: undefined,
+        take: 50
+        // is_client_credentials: true // Machine to Machine アプリケーションに絞る
+    });
+    const clients = existingApps.data.clients;
+    console.log(clients.length, 'existingApps exist.', clients);
+    console.log(clients.length, 'clients found.');
+}
+
+export async function run() {
+    if (typeof AUTH0_AUDIENCE !== 'string') {
+        throw new Error('set envs!');
+    }
+
+    try {
+        await findOrCreateServiceAccount(
+            `sampleServiceAccount-${moment()
+                .format('YYYY-MM-DDTHH:mm:ss')}`,
+            'cinerino',
+            ['inventoryManager', 'user'],
+            AUTH0_AUDIENCE
+        );
+    } catch (error) {
+        console.error('Failed to run provisioning script:', error);
+    }
+}
+
+run();

package/example/src/idaas/auth0/getToken.ts

@@ -0,0 +1,55 @@
+// tslint:disable:no-implicit-dependencies no-console
+interface IAuth0Config {
+    auth0Domain: string;
+    clientId: string;
+    clientSecret: string;
+    audience: string;
+}
+
+// 環境変数から機密情報を取得することを強く推奨します
+const config: IAuth0Config = {
+    auth0Domain: String(process.env.AUTH0_DOMAIN),
+    clientId: String(process.env.AUTH0_CLIENT_ID),
+    clientSecret: String(process.env.AUTH0_CLIENT_SECRET),
+    audience: String(process.env.AUTH0_AUDIENCE)
+    // scopes: process.env.OKTA_SCOPES || 'api_access_scope openid', // 必要なスコープを指定
+    // authServerId: 'aussd9v86wlIar3cX697', // デフォルト承認サーバーを使用する場合はコメントアウトまたは指定しない
+};
+
+async function getToken() {
+    try {
+        const response = await fetch(
+            `https://${config.auth0Domain}/oauth/token`,
+            {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    client_id: config.clientId,
+                    client_secret: config.clientSecret,
+                    audience: config.audience,
+                    grant_type: 'client_credentials'
+                    // organization: 'org_zuMP9ng42QSgZ5Kn'
+                })
+            });
+
+        if (!response.ok) {
+            console.log(await response.json());
+            throw new Error('Network response was not ok');
+        }
+
+        const data = await response.json();
+        console.log(data);
+
+        return data;
+    } catch (error) {
+        console.error('Error fetching token:', error);
+    }
+}
+
+export async function main() {
+    const token = await getToken();
+    console.log(token);
+}
+
+main()
+    .catch(console.error);

package/example/src/idaas/auth0/getTokenByPrivateKeyJWT.ts

@@ -0,0 +1,84 @@
+// tslint:disable:no-implicit-dependencies no-console
+import * as crypto from 'crypto';
+import { readFileSync } from 'fs';
+import { SignJWT } from 'jose';
+import * as uuid from 'uuid';
+
+const PRIVATE_KEY_FILE_PATH = `${__dirname}/../../samplePrivateKey.pem`;
+
+interface IAuth0Config {
+    auth0Domain: string;
+    clientId: string;
+    privateKeyContent: string; // PEM形式の秘密鍵の内容 (例: fs.readFileSync('private_key.pem', 'utf8'))
+    audience: string;
+}
+
+// 環境変数から機密情報を取得することを強く推奨します
+const auth0config: IAuth0Config = {
+    auth0Domain: String(process.env.AUTH0_DOMAIN),
+    clientId: String(process.env.AUTH0_CLIENT_ID),
+    // keyId: 'xxx',
+    privateKeyContent: readFileSync(PRIVATE_KEY_FILE_PATH, 'utf8'), // 秘密鍵の内容を読み込む
+    audience: String(process.env.AUTH0_AUDIENCE)
+    // scopes: process.env.OKTA_SCOPES || 'api_access_scope openid', // 必要なスコープを指定
+    // authServerId: 'aussd9v86wlIar3cX697', // デフォルト承認サーバーを使用する場合はコメントアウトまたは指定しない
+};
+
+async function generateJwtAssertion(config: IAuth0Config) {
+    const privateKeyPEM = crypto.createPrivateKey(readFileSync(PRIVATE_KEY_FILE_PATH, 'utf8'));
+
+    return new SignJWT({})
+        .setProtectedHeader({
+            alg: 'RS256' // or RS384 or PS256
+            // kid: '(OPTIONAL) KID_GENERATED_BY_AUTH0'
+        })
+        .setIssuedAt()
+        .setIssuer(config.clientId)
+        .setSubject(config.clientId)
+        .setAudience(`https://${config.auth0Domain}/`)
+        .setExpirationTime('1m')
+        .setJti(uuid.v4())
+        .sign(privateKeyPEM);
+}
+
+async function getToken() {
+    try {
+        const jwtAssertion = await generateJwtAssertion(auth0config);
+        console.log('jwtAssertion:', jwtAssertion);
+
+        const body = new URLSearchParams({
+            grant_type: 'client_credentials',
+            client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+            client_assertion: jwtAssertion,
+            audience: auth0config.audience
+            // scope: config.scopes,
+        }).toString();
+        const response = await fetch(
+            `https://${auth0config.auth0Domain}/oauth/token`,
+            {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: body
+            });
+
+        if (!response.ok) {
+            console.log(await response.json());
+            throw new Error('Network response was not ok');
+        }
+
+        const data = await response.json();
+        console.log(data);
+
+        return data;
+    } catch (error) {
+        console.error('Error fetching token:', error);
+    }
+}
+
+export async function main() {
+    const token = await getToken();
+    console.log(token);
+}
+
+main()
+    .catch(console.error);

package/example/src/regex.ts

@@ -0,0 +1,31 @@
+// tslint:disable:no-console
+const projectIdMustBe = /^[0-9a-z-]+$/; // 記号はhyphenのみ許可
+
+let projectId: string;
+
+projectId = 'projectId';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = 'projectid';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = 'abcd1234-test';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = 'a-z';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = '0-9';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = '---';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = '-';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = '&';
+console.log(projectId, ':', projectIdMustBe.test(projectId));
+
+projectId = 'A';
+console.log(projectId, ':', projectIdMustBe.test(projectId));