@chevre/domain 22.10.0-alpha.9 → 22.10.0

package/example/src/chevre/adminIdentities.ts

@@ -4,14 +4,14 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
-const IDENTIFIER = 'xxx';
+const IDENTIFIER = 'sampleidentity20250528';
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const identityRepo = await chevre.repository.Identity.createInstance(mongoose.connection);
 
-    let docs = await identityRepo.projectFields(
+    let docs = await identityRepo.projectIdentityFields(
         {
             project: { id: { $eq: project.id } },
             about: { id: { $eq: IDENTIFIER } }
@@ -22,14 +22,14 @@ async function main() {
     console.log(docs.length, 'docs found');
 
     if (docs.length > 0) {
-        await identityRepo.deleteById({
+        await identityRepo.deleteIdentityById({
             project: { id: docs[0].project.id },
             id: docs[0].id
         });
         console.log('deleted', docs[0].id);
     }
 
-    await identityRepo.projectFields(
+    await identityRepo.projectIdentityFields(
         {
             project: { id: { $eq: project.id } },
             about: { id: { $eq: IDENTIFIER } }
@@ -39,7 +39,7 @@ async function main() {
     console.log('docs:', docs);
     console.log(docs.length, 'docs found');
 
-    await identityRepo.save({
+    await identityRepo.saveIdentity({
         attributes: {
             project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
             typeOf: chevre.factory.creativeWorkType.Certification,
@@ -47,15 +47,15 @@ async function main() {
                 id: IDENTIFIER,
                 typeOf: chevre.factory.creativeWorkType.WebApplication
             },
-            issuedBy: {
+            issuedBy: [{
                 identifier: 'https://example.com',
                 typeOf: chevre.factory.organizationType.Organization
-            }
+            }]
         }
     });
     console.log('created.');
 
-    docs = await await identityRepo.projectFields(
+    docs = await await identityRepo.projectIdentityFields(
         {
             project: { id: { $eq: project.id } },
             about: { id: { $eq: IDENTIFIER } }

package/example/src/chevre/assetTransaction/processReserve.ts

@@ -18,7 +18,10 @@ async function main() {
     await redisClient.connect();
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance(redisClient);
+    const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
     const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
 
     const { transactionNumber } = await transactionNumberRepo.publishByTimestamp({ startDate: new Date() });

package/example/src/chevre/concurrentLock/lockOfferRateLimit.ts

@@ -0,0 +1,64 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const rateLimitRepo = await chevre.repository.rateLimit.Offer.createInstance(
+        client
+    );
+
+    // await rateLimitRepo.unlock({
+    //     project: { id: project.id },
+    //     reservedTicket: {
+    //         ticketType: {
+    //             validRateLimit: {
+    //                 scope: 'scope2',
+    //                 unitInSeconds: 60
+    //             }
+    //         }
+    //     },
+    //     reservationFor: {
+    //         startDate: new Date()
+    //     },
+    //     reservationNumber: 'xxx'
+    // });
+    // console.log('unlocked');
+    await rateLimitRepo.lock({
+        project: { id: project.id },
+        reservedTicket: {
+            ticketType: {
+                validRateLimit: {
+                    scope: 'scope2',
+                    unitInSeconds: 60
+                }
+            }
+        },
+        reservationFor: {
+            startDate: new Date()
+        },
+        reservationNumber: 'xxx'
+    });
+    console.log('locked');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/concurrentLock/lockTransactionProcess.ts

@@ -0,0 +1,44 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const processRepo = await chevre.repository.TransactionProcess.createInstance(
+        client,
+        { lockExpiresInSeconds: 60 }
+    );
+
+    // await processRepo.unlock({
+    //     id: 'xxx',
+    //     typeOf: chevre.factory.transactionType.PlaceOrder
+    // });
+    // console.log('unlocked');
+    await processRepo.lock({
+        id: 'xxx',
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        project: { id: project.id }
+    });
+    console.log('locked');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createTaskIfNotExistByAlternateName.ts

@@ -5,7 +5,7 @@ import { chevre } from '../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
 
-chevre.eventEmitter.task.onTaskStatusChanged((event) => {
+chevre.eventEmitter.task.taskEventEmitter.onTaskStatusChanged((event) => {
     console.log('onTaskStatusChanged', event);
 });
 

package/example/src/chevre/findOneAvailableHours.ts

@@ -17,17 +17,17 @@ async function main() {
         ['opens', 'typeOf']
     );
     console.log('setting:', setting);
-    // const result = await availableHourRepo.saveOne(
-    //     {
-    //         // opens: '09:00:00',
-    //         validFrom: moment('2025-05-15T00:00:00Z')
-    //             .toDate(),
-    //         validThrough: moment('2025-05-15T01:00:00Z')
-    //             .toDate(),
-    //         typeOf: 'OpeningHoursSpecification'
-    //     }
-    // );
-    // console.log('saved', result);
+    const result = await availableHourRepo.saveOne(
+        {
+            // opens: '09:00:00',
+            validFrom: moment('2025-05-19T17:00:00Z')
+                .toDate(),
+            validThrough: moment('2025-05-19T20:00:00Z')
+                .toDate(),
+            typeOf: 'OpeningHoursSpecification'
+        }
+    );
+    console.log('saved', result);
 }
 
 main()

package/example/src/chevre/identity/getCommonClients.ts

@@ -0,0 +1,126 @@
+// tslint:disable:no-console
+import { CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
+// tslint:disable-next-line:no-submodule-imports
+import type { UserPoolClientType } from '@aws-sdk/client-cognito-identity-provider/dist-types/models/models_0';
+import { fromEnv } from '@aws-sdk/credential-providers';
+import * as fs from 'fs';
+// tslint:disable-next-line:no-implicit-dependencies
+import * as json2csv from 'json2csv';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+const userPoolId = `${process.env.COGNITO_USER_POOL_ID}`;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const awsCredentials = fromEnv();
+    const cognitoIdentityServiceProvider = new CognitoIdentityProvider({
+        apiVersion: 'latest',
+        region: 'ap-northeast-1',
+        credentials: awsCredentials
+    });
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+
+    const cursor = memberRepo.getCursor(
+        {
+            'project.id': { $eq: '*' }
+            // _id: { $eq: '67de46777ec0510590b68922' }
+        },
+        {
+            _id: 1,
+            member: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    // let commonClients: {
+    //     clientId?: string;
+    //     clientSecret?: string;
+    //     name?: string;
+    // }[] = [];
+    const commonClients: {
+        projectId: string;
+        clientId: string;
+        clientSecret: string;
+        name: string;
+        memberName: string;
+    }[] = [];
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const member: Pick<
+            chevre.factory.iam.IMember,
+            'member' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        const client = await new Promise<UserPoolClientType>(async (resolve, reject) => {
+            cognitoIdentityServiceProvider.describeUserPoolClient(
+                {
+                    ClientId: member.member.id,
+                    UserPoolId: userPoolId
+                },
+                {},
+                (err, data) => {
+                    if (err instanceof Error) {
+                        reject(err);
+                    } else {
+                        if (data?.UserPoolClient === undefined) {
+                            reject(new chevre.factory.errors.NotFound('UserPoolClient'));
+                        } else {
+                            resolve(data.UserPoolClient);
+                        }
+                    }
+                }
+            );
+        });
+
+        if (typeof client.ClientId !== 'string'
+            || typeof client.ClientSecret !== 'string'
+            || typeof client.ClientName !== 'string') {
+            throw new Error('invalid client');
+        }
+
+        const allowClientCredentials = client.AllowedOAuthFlows?.includes('client_credentials') === true;
+        if (allowClientCredentials) {
+            commonClients.push({
+                projectId: member.project.id,
+                clientId: client.ClientId,
+                clientSecret: client.ClientSecret,
+                name: client.ClientName,
+                memberName: String(member.member.name)
+            });
+        }
+    });
+
+    console.log(commonClients);
+
+    // tslint:disable-next-line:no-null-keyword
+    const json = JSON.stringify(commonClients, null, '');
+    // tslint:disable-next-line:non-literal-fs-path
+    fs.writeFileSync(`${__dirname}/../../../commonClients.json`, json);
+    console.log(i, 'docs checked');
+
+    const parser = new json2csv.Parser({
+        fields: ['projectId', 'clientId', 'clientSecret', 'name', 'memberName']
+    });
+    const csv = parser.parse(commonClients.sort(
+        (a, b) => {
+            return (String(a.name) > String(b.name)) ? 1 : -1;
+        }
+    ));
+    // tslint:disable-next-line:non-literal-fs-path
+    fs.writeFileSync(`${__dirname}/../../../commonClients.csv`, csv);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/identity/migrateClients2oauth.ts

@@ -0,0 +1,200 @@
+// tslint:disable:no-console
+// tslint:disable:no-console
+import { CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
+// tslint:disable-next-line:no-submodule-imports
+import type { UserPoolClientType } from '@aws-sdk/client-cognito-identity-provider/dist-types/models/models_0';
+import { fromEnv } from '@aws-sdk/credential-providers';
+import * as fs from 'fs';
+// tslint:disable-next-line:no-implicit-dependencies
+import * as json2csv from 'json2csv';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+const userPoolId = `${process.env.COGNITO_USER_POOL_ID}`;
+const oldProvider = `https://cognito-idp.ap-northeast-1.amazonaws.com/${userPoolId}`;
+const NEW_ISS = process.env.NEW_ISS;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    if (typeof NEW_ISS !== 'string') {
+        throw new Error('process.env.NEW_ISS undefined');
+    }
+
+    const awsCredentials = fromEnv();
+    const cognitoIdentityServiceProvider = new CognitoIdentityProvider({
+        apiVersion: 'latest',
+        region: 'ap-northeast-1',
+        credentials: awsCredentials
+    });
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const identityRepo = await chevre.repository.Identity.createInstance(mongoose.connection);
+    const identityProviderRepo = await chevre.repository.IdentityProvider.createInstance(mongoose.connection);
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+
+    const cursor = identityRepo.getCursor(
+        {
+            'issuedBy.identifier': { $eq: oldProvider }
+            // _id: { $eq: '67de46777ec0510590b68922' }
+        },
+        {
+            _id: 1,
+            about: 1,
+            project: 1,
+            typeOf: 1,
+            issuedBy: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    const creatingClients: {
+        projectId: string;
+        clientId: string;
+        clientSecret: string;
+        name: string;
+        memberName: string;
+    }[] = [];
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const identity: Pick<
+            chevre.factory.creativeWork.certification.webApplication.ICertification,
+            'about' | 'project' | 'typeOf' | 'id' | 'issuedBy'
+        > = doc.toObject();
+
+        const iamMember = (await memberRepo.projectFieldsByProjectId(
+            { id: identity.project.id },
+            {
+                limit: 1,
+                member: {
+                    id: { $eq: identity.about.id },
+                    typeOf: { $eq: chevre.factory.creativeWorkType.WebApplication }
+                }
+            },
+            ['member']
+        )).shift();
+        if (iamMember === undefined) {
+            throw new Error(`iamMember not found ${identity.project.id} ${identity.about.id}`);
+        }
+
+        const client = await new Promise<UserPoolClientType>(async (resolve, reject) => {
+            cognitoIdentityServiceProvider.describeUserPoolClient(
+                {
+                    ClientId: identity.about.id,
+                    UserPoolId: userPoolId
+                },
+                {},
+                (err, data) => {
+                    if (err instanceof Error) {
+                        reject(err);
+                    } else {
+                        if (data?.UserPoolClient === undefined) {
+                            reject(new chevre.factory.errors.NotFound('UserPoolClient'));
+                        } else {
+                            resolve(data.UserPoolClient);
+                        }
+                    }
+                }
+            );
+        });
+
+        if (typeof client.ClientId !== 'string'
+            || typeof client.ClientSecret !== 'string'
+            || typeof client.ClientName !== 'string') {
+            throw new Error('invalid client');
+        }
+
+        creatingClients.push({
+            projectId: identity.project.id,
+            clientId: client.ClientId,
+            clientSecret: client.ClientSecret,
+            name: client.ClientName,
+            memberName: String(iamMember.member.name)
+        });
+
+        const issuedBy = identity.issuedBy;
+        const numIssuedBy = (Array.isArray(identity.issuedBy)) ? identity.issuedBy.length : 1;
+
+        const alreadyMigrated = (Array.isArray(issuedBy))
+            // tslint:disable-next-line:no-magic-numbers
+            && issuedBy.length === 2
+            && issuedBy.some(({ identifier }) => identifier === NEW_ISS);
+
+        if (alreadyMigrated) {
+            console.log('already migrated.', identity.project.id, identity.about.id, identity.id, numIssuedBy, i);
+        } else {
+            if (typeof identity.id !== 'string') {
+                throw new Error(`id undefined ${identity.id}`);
+            }
+
+            // プロバイダー追加
+            const existingProvider = (await identityProviderRepo.projectFields(
+                {
+                    limit: 1,
+                    project: { id: { $eq: identity.project.id } },
+                    identifier: { $eq: NEW_ISS }
+                },
+                ['identifier']
+            )).shift();
+            if (existingProvider === undefined) {
+                await identityProviderRepo.save({
+                    attributes: {
+                        identifier: NEW_ISS,
+                        project: { id: identity.project.id, typeOf: chevre.factory.organizationType.Project },
+                        typeOf: chevre.factory.organizationType.Organization
+                    }
+                });
+                console.log('provider saved.', identity.project.id, identity.about.id, identity.id, numIssuedBy, i);
+            }
+
+            // identity更新
+            const newIssuedBy = (Array.isArray(issuedBy)) ? issuedBy : [issuedBy];
+            if (newIssuedBy.length !== 1) {
+                throw new Error('newIssuedBy.length must be 1');
+            }
+            newIssuedBy.push({
+                identifier: NEW_ISS,
+                typeOf: chevre.factory.organizationType.Organization
+            });
+            console.log(newIssuedBy);
+            await identityRepo.updateIssuedBy2array({
+                id: identity.id,
+                issuedBy: newIssuedBy
+            });
+            updateCount += 1;
+            console.log(
+                'updated.', identity.project.id, identity.about.id, identity.id, numIssuedBy, i);
+        }
+    });
+
+    console.log(creatingClients.map(({ clientId }) => clientId));
+    // tslint:disable-next-line:non-literal-fs-path no-null-keyword
+    // fs.writeFileSync(`${__dirname}/../../../creatingClients.json`, JSON.stringify(creatingClients, null, '    '));
+    // tslint:disable-next-line:non-literal-fs-path no-null-keyword
+    const json = JSON.stringify(creatingClients, null, '');
+    // tslint:disable-next-line:non-literal-fs-path
+    fs.writeFileSync(`${__dirname}/../../../creatingClients.json`, json);
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+
+    const parser = new json2csv.Parser({
+        fields: ['projectId', 'clientId', 'clientSecret', 'name', 'memberName']
+    });
+    const csv = parser.parse(creatingClients.sort(
+        (a, b) => {
+            return (a.projectId > b.projectId) ? 1 : -1;
+        }
+    ));
+    // tslint:disable-next-line:non-literal-fs-path
+    fs.writeFileSync(`${__dirname}/../../../creatingClients.csv`, csv);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/issuer/adminMemberProgramTiers.ts

@@ -0,0 +1,55 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const IDENTIFIER = 'DefaultMemberProgram';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const memberProgramRepo = await chevre.repository.MemberProgram.createInstance(mongoose.connection);
+
+    const memberPrograms = await memberProgramRepo.projectMemberPrograms(
+        {
+            project: { id: { $eq: project.id } },
+            identifier: { $eq: IDENTIFIER }
+        }
+    );
+    console.log('docs:', memberPrograms);
+    console.log(memberPrograms.length, 'docs found');
+
+    if (memberPrograms.length > 0) {
+        const memberProgram = memberPrograms[0];
+        await memberProgramRepo.updateOne({
+            project: { id: project.id },
+            identifier: memberProgram.identifier,
+            hostingOrganization: { id: 'xxx' },
+            hasTiers: [
+                { identifier: 'bronze' },
+                { identifier: 'silver' },
+                { identifier: 'gold' }
+            ]
+        });
+        console.log('updated.');
+
+        const tiers = await memberProgramRepo.projectMemberProgramTiers(
+            {
+                limit: 10,
+                page: 1,
+                project: { id: { $eq: project.id } },
+                isTierOf: {
+                    identifier: { $eq: memberProgram.identifier }
+                }
+            }
+        );
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(tiers, { depth: null });
+        console.log(tiers.length, 'tiers found');
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);