@streamr/cli-tools 102.2.0-rc.3 → 103.0.0-rc.1

package/src/permission.ts

@@ -1,53 +0,0 @@
-import { Argument } from 'commander'
-import { PermissionAssignment, Stream, StreamPermission, StreamrClient } from '@streamr/sdk'
-import { createClientCommand } from './command'
-
-const PUBLIC_USER_ID = 'public'
-
-export const PERMISSIONS = new Map<string, StreamPermission>([
-    ['subscribe', StreamPermission.SUBSCRIBE],
-    ['publish', StreamPermission.PUBLISH],
-    ['edit', StreamPermission.EDIT],
-    ['delete', StreamPermission.DELETE],
-    ['grant', StreamPermission.GRANT]
-])
-
-export const getPermission = (id: string): StreamPermission | never => {
-    const result = PERMISSIONS.get(id)
-    if (result === undefined) {
-        throw new Error(`unknown permission: ${id}`)
-    }
-    return result
-}
-
-export const getPermissionId = (permission: StreamPermission): string => {
-    return Array.from(PERMISSIONS.entries()).find(([_id, p]) => p === permission)![0]
-}
-
-export const runModifyPermissionsCommand = (
-    modify: (stream: Stream, assignment: PermissionAssignment) => Promise<void>,
-    modification: string,
-): void => {
-    createClientCommand(async (client: StreamrClient, streamId: string, user: string, permissionIds: string[]) => {
-        const stream = await client.getStream(streamId)
-        const permissions: StreamPermission[] = permissionIds.map((permissionId) => getPermission(permissionId))
-        let assignment: PermissionAssignment
-        if (user === PUBLIC_USER_ID) {
-            assignment = {
-                permissions,
-                public: true
-            }
-        } else {
-            assignment = {
-                permissions,
-                userId: user
-            }
-        }
-        await modify(stream, assignment) 
-    })
-        .addArgument(new Argument('<streamId>'))
-        .addArgument(new Argument('<user>'))
-        .addArgument(new Argument('<permissions...>').choices(Array.from(PERMISSIONS.keys())))
-        .description(`${modification} permission: use keyword "public" as a user to ${modification} a public permission`)
-        .parseAsync(process.argv)
-}

package/src/resend.ts

@@ -1,37 +0,0 @@
-import { StreamrClient, ResendOptions } from '@streamr/sdk'
-
-export const assertBothOrNoneDefined = <T extends object>(
-    option1: keyof T,
-    option2: keyof T,
-    errorMessage: string,
-    commandOptions: T
-): void | never => { 
-    if ((option1 in commandOptions && !(option2 in commandOptions)) || (option2 in commandOptions && !(option1 in commandOptions))) {
-        console.error(`option ${errorMessage}`)
-        process.exit(1)
-    }
-}
-
-export const resend = async (
-    streamId: string,
-    resendOpts: ResendOptions,
-    client: StreamrClient,
-    subscribe: boolean
-): Promise<void> => {
-    try {
-        const handler = (message: any) => {
-            console.info(JSON.stringify(message))
-        }
-        if (subscribe) {
-            await client.subscribe({
-                stream: streamId,
-                resend: resendOpts
-            }, handler)
-        } else {
-            await client.resend(streamId, resendOpts, handler)
-        }
-    } catch (err) {
-        console.error(err.message ? err.message : err)
-        process.exit(1)
-    }
-}

package/test/environment.test.ts

@@ -1,32 +0,0 @@
-import { randomString } from '@streamr/utils'
-import fs from 'fs/promises'
-import { runCommand } from './utils'
-import { StreamrClientConfig } from '@streamr/sdk'
-
-const POLYGON_AMOY_CHAIN_ID = 80002
-
-describe('env command line option', () => {
-
-    it('takes precedence over client.environment config', async () => {
-        const configFileName = `test-${randomString(10)}.json`
-        await fs.writeFile(configFileName, JSON.stringify({
-            client: {
-                environment: 'dev2'
-            }
-        }))
-        const outputLines = await runCommand(`internal show-sdk-config --env polygonAmoy --config ${configFileName}`, {
-            devEnvironment: false
-        })
-        const outputJson: StreamrClientConfig = JSON.parse(outputLines.join(''))
-        await fs.unlink(configFileName)
-        expect(outputJson.contracts!.ethereumNetwork!.chainId).toBe(POLYGON_AMOY_CHAIN_ID)
-    })
-
-    it('invalid value', async () => {
-        const outputLines = await runCommand('stream show foobar --env invalid-environment', {
-            devEnvironment: false
-        })
-        expect(outputLines).toHaveLength(1)
-        expect(outputLines[0]).toEqual('env must be one of: "polygon", "polygonAmoy", "dev2"')
-    }, 60 * 1000)
-})

package/test/internal-operator.test.ts

@@ -1,57 +0,0 @@
-import { _operatorContractUtils } from '@streamr/sdk'
-import { createTestPrivateKey, createTestWallet } from '@streamr/test-utils'
-import { wait } from '@streamr/utils'
-import { parseEther } from 'ethers'
-import { createTestClient, runCommand } from './utils'
-
-const DELEGATION_AMOUNT = '20000'
-const STAKE_AMOUNT = '10000'
-const SELF_DELEGATION_AMOUNT = '100000'
-const MINIMUM_DELEGATION_SECONDS = 1  // the config value defined in StreamrEnvDeployer in network-contracts repo
-
-describe('operator', () => {
-
-    it('happy path', async () => {
-        const client = createTestClient(await createTestPrivateKey({ gas: true }))
-        const stream = await client.createStream('/test')
-        const sponsorshipContract = await _operatorContractUtils.deploySponsorshipContract({ 
-            streamId: stream.id,
-            deployer: await createTestWallet({ gas: true })
-        })
-        const sponsorshipAddress: string = await sponsorshipContract.getAddress()
-        const operator = await createTestWallet({ gas: true, tokens: true })
-        const operatorContract = await _operatorContractUtils.deployOperatorContract({
-            deployer: operator
-        })
-        await _operatorContractUtils.delegate(operator, await operatorContract.getAddress(), parseEther(SELF_DELEGATION_AMOUNT))
-        const delegator = await createTestWallet({ gas: true, tokens: true })
-        const operatorAddress: string = await operatorContract.getAddress()
-
-        // delegate
-        await runCommand(`internal operator-delegate ${operatorAddress} ${DELEGATION_AMOUNT}`, {
-            privateKey: delegator.privateKey
-        })
-        expect(await operatorContract.balanceInData(await delegator.getAddress())).toEqual(parseEther(DELEGATION_AMOUNT))
-
-        // stake
-        await runCommand(`internal operator-stake ${operatorAddress} ${sponsorshipAddress} ${STAKE_AMOUNT}`, {
-            privateKey: operator.privateKey
-        })
-        expect(await operatorContract.totalStakedIntoSponsorshipsWei()).toEqual(parseEther(STAKE_AMOUNT))
-
-        // unstake
-        await runCommand(`internal operator-unstake ${operatorAddress} ${sponsorshipAddress}`, {
-            privateKey: operator.privateKey
-        })
-        expect(await operatorContract.totalStakedIntoSponsorshipsWei()).toEqual(0n)
-
-        // undelegate
-        await wait(MINIMUM_DELEGATION_SECONDS)
-        await runCommand(`internal operator-undelegate ${operatorAddress} ${DELEGATION_AMOUNT}`, {
-            privateKey: delegator.privateKey
-        })
-        expect(await operatorContract.balanceInData(await delegator.getAddress())).toEqual(0n)
-
-        await client.destroy()
-    }, 30 * 1000)
-})

package/test/internal-sponsorship-sponsor.test.ts

@@ -1,28 +0,0 @@
-import { _operatorContractUtils } from '@streamr/sdk'
-import { createTestPrivateKey, createTestWallet } from '@streamr/test-utils'
-import { parseEther } from 'ethers'
-import { createTestClient, runCommand } from './utils'
-
-const SPONSOR_AMOUNT = '12345'
-
-describe('sponsorship-sponsor', () => {
-
-    it('happy path', async () => {
-        const client = createTestClient(await createTestPrivateKey({ gas: true }))
-        const stream = await client.createStream('/test')
-        const sponsorshipContract = await _operatorContractUtils.deploySponsorshipContract({ 
-            streamId: stream.id,
-            deployer: await createTestWallet({ gas: true })
-        })
-
-        const sponsorer = await createTestWallet({ gas: true, tokens: true })
-        const sponsorshipAddress: string = await sponsorshipContract.getAddress()
-        await runCommand(`internal sponsorship-sponsor ${sponsorshipAddress} ${SPONSOR_AMOUNT}`, {
-            privateKey: sponsorer.privateKey
-        })
-
-        const remainingWei = await sponsorshipContract.connect(sponsorer, _operatorContractUtils.getProvider()).remainingWei()
-        expect(remainingWei).toEqual(parseEther(SPONSOR_AMOUNT))
-        await client.destroy()
-    })
-})

package/test/mock-data.test.ts

@@ -1,33 +0,0 @@
-import { collect } from '@streamr/utils'
-import 'jest-extended'
-import { startCommand } from './utils'
-
-describe('mock-data', () => {
-
-    it('generate', async () => {
-        const abortController = new AbortController()
-        const outputIterable = startCommand('mock-data generate', {
-            abortSignal: abortController.signal,
-            devEnvironment: false
-        })
-        const firstLine = (await collect(outputIterable, 1))[0]
-        abortController.abort()
-        const json = JSON.parse(firstLine)
-        expect(json).toBeObject()
-    })
-
-    it('generate binary', async () => {
-        const abortController = new AbortController()
-        const outputIterable = startCommand('mock-data generate --binary --min-length 32 --max-length 64', {
-            abortSignal: abortController.signal,
-            devEnvironment: false
-        })
-        const firstLine = (await collect(outputIterable, 1))[0]
-        abortController.abort()
-        expect(firstLine).toMatch(/^[0-9a-f]+$/)
-        const lengthInBytes = firstLine.length / 2
-        expect(lengthInBytes).toBeGreaterThanOrEqual(32)
-        expect(lengthInBytes).toBeLessThanOrEqual(64)
-    })
-
-})

package/test/storage-node.test.ts

@@ -1,62 +0,0 @@
-import { StreamID } from '@streamr/sdk'
-import { createTestPrivateKey, createTestWallet } from '@streamr/test-utils'
-import { until } from '@streamr/utils'
-import 'jest-extended'
-import { DOCKER_DEV_STORAGE_NODE, createTestClient, runCommand } from './utils'
-
-const isStored = async (streamId: StreamID): Promise<boolean> => {
-    const output = await runCommand(`storage-node list-streams ${DOCKER_DEV_STORAGE_NODE}`)
-    return output.join().includes(streamId)
-}
-
-describe('storage node', () => {
-
-    it('add and remove stream', async () => {
-        const privateKey = await createTestPrivateKey({ gas: true })
-        const client = createTestClient(privateKey)
-        const stream = await client.createStream(`/${Date.now()}`)
-        await client.destroy()
-        await runCommand(`storage-node add-stream ${DOCKER_DEV_STORAGE_NODE} ${stream.id}`, {
-            privateKey
-        })
-        await until(async () => await isStored(stream.id) === true, 15 * 1000, 1000)
-        await runCommand(`storage-node remove-stream ${DOCKER_DEV_STORAGE_NODE} ${stream.id}`, {
-            privateKey
-        })
-        await until(async () => await isStored(stream.id) === false, 15 * 1000, 1000)
-    }, 80 * 1000)
-
-    it('list nodes', async () => {
-        const outputLines = await runCommand('storage-node list')
-        expect(outputLines.join()).toMatch(DOCKER_DEV_STORAGE_NODE.toLowerCase())
-    })
-
-    it('register storage node, show info, and finally unregister', async () => {
-        const { privateKey, address } = await createTestWallet({ gas: true })
-
-        const urls = 'http://foobar.com,http://foobar.org'
-        await runCommand(`storage-node register ${urls}`, {
-            privateKey
-        })
-
-        // account for The Graph delay
-        await until(async () => {
-            const outputLines = await runCommand('storage-node list')
-            return outputLines.join().includes(address.toLowerCase())
-        }, 10 * 1000, 500)
-
-        const outputLines = await runCommand(`storage-node show ${address}`)
-        expect(outputLines.join()).toContain('http://foobar.com')
-        expect(outputLines.join()).toContain('http://foobar.org')
-
-        await runCommand('storage-node unregister', {
-            privateKey
-        })
-
-        // account for The Graph delay
-        await until(async () => {
-            const outputLines = await runCommand('storage-node list')
-            return !outputLines.join().includes(address.toLowerCase())
-        }, 10 * 1000, 500)
-    }, 80 * 1000)
-})

package/test/stream-create.test.ts

@@ -1,26 +0,0 @@
-import { createTestPrivateKey } from '@streamr/test-utils'
-import { Wallet } from 'ethers'
-import { createTestClient, runCommand } from './utils'
-
-describe('create stream', () => {
-
-    it('happy path', async () => {
-        const privateKey = await createTestPrivateKey({ gas: true })
-        const address = new Wallet(privateKey).address.toLowerCase()
-        const path = `/${Date.now()}`
-        const streamId = `${address}${path}`
-        const outputLines = await runCommand(`stream create ${path}`, {
-            privateKey
-        })
-        const outputJson = JSON.parse(outputLines.join(''))
-        expect(outputJson).toMatchObject({
-            id: streamId,
-            partitions: 1
-        })
-        const client = createTestClient()
-        const stream = await client.getStream(streamId)
-        expect(await stream.getPartitionCount()).toBe(1)
-        await client.destroy()
-    }, 20 * 1000)
-
-})

package/test/stream-permission.test.ts

@@ -1,29 +0,0 @@
-import { StreamPermission } from '@streamr/sdk'
-import { createTestPrivateKey, randomUserId } from '@streamr/test-utils'
-import 'jest-extended'
-import { createTestClient, runCommand } from './utils'
-
-describe('permission', () => {
-
-    it('grant and revoke', async () => {
-        const privateKey = await createTestPrivateKey({ gas: true })
-        const client = createTestClient(privateKey)
-        const stream = await client.createStream(`/${Date.now()}`)
-        const otherUser = randomUserId()
-        const hasPermission = () => client.hasPermission({
-            userId: otherUser,
-            permission: StreamPermission.PUBLISH,
-            streamId: stream.id,
-            allowPublic: false
-        })
-        await runCommand(`stream grant-permission ${stream.id} ${otherUser} publish`, {
-            privateKey
-        })
-        expect(await hasPermission()).toBeTrue()
-        await runCommand(`stream revoke-permission ${stream.id} ${otherUser} publish`, {
-            privateKey
-        })
-        expect(await hasPermission()).toBeFalse()
-        await client.destroy()
-    }, 40 * 1000)
-})

package/test/stream-publish-subscribe.test.ts

@@ -1,108 +0,0 @@
-import { StreamPermission } from '@streamr/sdk'
-import { createTestPrivateKey } from '@streamr/test-utils'
-import { collect } from '@streamr/utils'
-import { Wallet } from 'ethers'
-import { createTestClient, runCommand, startCommand } from './utils'
-
-const TIMEOUT = 30 * 1000
-
-describe('publish and subscribe', () => {
-
-    let publisherPrivateKey: string
-    let subscriberPrivateKey: string
-    let streamId: string
-
-    beforeAll(async () => {
-        publisherPrivateKey = await createTestPrivateKey({ gas: true })
-        subscriberPrivateKey = await createTestPrivateKey({ gas: true })
-        const client = createTestClient(publisherPrivateKey)
-        const stream = await client.createStream(`/${Date.now()}`)
-        await stream.grantPermissions({
-            userId: new Wallet(subscriberPrivateKey).address,
-            permissions: [StreamPermission.SUBSCRIBE]
-        })
-        streamId = stream.id
-        await client.destroy()
-    }, TIMEOUT)
-
-    function publishViaCliCommand() {
-        setImmediate(async () => {
-            await runCommand(`stream publish ${streamId}`, {
-                inputLines: [JSON.stringify({ foo: 123 })],
-                privateKey: publisherPrivateKey
-            })
-        })
-    }
-
-    it('happy path', async () => {
-        const subscriberAbortController = new AbortController()
-        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId}`, {
-            privateKey: subscriberPrivateKey,
-            abortSignal: subscriberAbortController.signal
-        })
-        publishViaCliCommand()
-        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
-        subscriberAbortController.abort()
-        expect(JSON.parse(receivedMessage)).toEqual({
-            foo: 123
-        })
-    }, TIMEOUT)
-
-    it('raw subscription', async () => {
-        const subscriberAbortController = new AbortController()
-        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId} --raw`, {
-            privateKey: subscriberPrivateKey,
-            abortSignal: subscriberAbortController.signal,
-        })
-        publishViaCliCommand()
-        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
-        subscriberAbortController.abort()
-        expect(receivedMessage).toMatch(/^[0-9a-fA-F]+$/)
-    }, TIMEOUT)
-
-    it('with metadata', async () => {
-        const subscriberAbortController = new AbortController()
-        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId} --with-metadata`, {
-            privateKey: subscriberPrivateKey,
-            abortSignal: subscriberAbortController.signal,
-        })
-        publishViaCliCommand()
-        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
-        subscriberAbortController.abort()
-        expect(JSON.parse(receivedMessage)).toMatchObject({
-            content: {
-                foo: 123
-            },
-            metadata: {
-                streamId,
-                streamPartition: 0,
-                timestamp: expect.any(Number),
-                sequenceNumber: 0,
-                publisherId: new Wallet(publisherPrivateKey).address.toLowerCase(),
-                msgChainId: expect.stringMatching(/[0-9a-zA-Z]+/)
-            }
-        })
-    }, TIMEOUT)
-
-    it('with metadata and raw', async () => {
-        const subscriberAbortController = new AbortController()
-        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId} --with-metadata --raw`, {
-            privateKey: subscriberPrivateKey,
-            abortSignal: subscriberAbortController.signal,
-        })
-        publishViaCliCommand()
-        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
-        subscriberAbortController.abort()
-        expect(JSON.parse(receivedMessage)).toMatchObject({
-            content: expect.stringMatching(/^[0-9a-fA-F]+$/),
-            metadata: {
-                streamId,
-                streamPartition: 0,
-                timestamp: expect.any(Number),
-                sequenceNumber: 0,
-                publisherId: new Wallet(publisherPrivateKey).address.toLowerCase(),
-                msgChainId: expect.stringMatching(/[0-9a-zA-Z]+/)
-            }
-        })
-    }, TIMEOUT)
-})

package/test/stream-resend.test.ts

@@ -1,66 +0,0 @@
-import { Message, Stream } from '@streamr/sdk'
-import { createTestPrivateKey } from '@streamr/test-utils'
-import { wait } from '@streamr/utils'
-import range from 'lodash/range'
-import { DOCKER_DEV_STORAGE_NODE, createTestClient, runCommand } from './utils'
-
-const parseJSONs = (lines: string[]): any[] => {
-    return lines.map((line) => JSON.parse(line))
-}
-
-describe('resend stream', () => {
-
-    let privateKey: string
-    let stream: Stream
-    const messages: Message[] = []
-
-    beforeAll(async () => {
-        privateKey = await createTestPrivateKey({ gas: true })
-        const client = createTestClient(privateKey)
-        stream = await client.createStream(`/${Date.now()}`)
-        await stream.addToStorageNode(DOCKER_DEV_STORAGE_NODE, { wait: true })
-        for (const msgId of range(10)) {
-            await wait(10) // to prevent duplicate timestamps (to make test assertions simpler)
-            const msg = await stream.publish({ msgId })
-            messages.push(msg)
-        }
-        await wait(10000)
-        await client.destroy()
-    }, 30 * 1000)
-
-    it('last', async () => {
-        const outputLines = await runCommand(`stream resend last 3 ${stream.id}`, {
-            privateKey
-        })
-        expect(parseJSONs(outputLines)).toEqual([
-            { msgId: 7 },
-            { msgId: 8 },
-            { msgId: 9 }
-        ])
-    }, 20 * 1000)
-
-    it('from', async () => {
-        const minTimestamp = new Date(messages[8].timestamp).toISOString()
-        const outputLines = await runCommand(`stream resend from ${minTimestamp} ${stream.id}`, {
-            privateKey
-        })
-        expect(parseJSONs(outputLines)).toEqual([
-            { msgId: 8 },
-            { msgId: 9 }
-        ])
-    }, 20 * 1000)
-
-    it('range', async () => {
-        const minTimestamp = new Date(messages[2].timestamp).toISOString()
-        const maxTimestamp = new Date(messages[4].timestamp).toISOString()
-        const outputLines = await runCommand(`stream resend range ${minTimestamp} ${maxTimestamp} ${stream.id}`, {
-            privateKey
-        })
-        expect(parseJSONs(outputLines)).toEqual([
-            { msgId: 2 },
-            { msgId: 3 },
-            { msgId: 4 }
-        ])
-    }, 20 * 1000)
-
-})

package/test/stream-search.test.ts

@@ -1,24 +0,0 @@
-import { createTestPrivateKey } from '@streamr/test-utils'
-import { randomString } from '@streamr/utils'
-import { createTestClient, runCommand, waitForTheGraphToHaveIndexed } from './utils'
-
-describe('search streams', () => {
-
-    it('happy path', async () => {
-        const testId = randomString(10)
-        const client = createTestClient(await createTestPrivateKey({ gas: true }))
-        const stream1 = await client.createStream(`/${testId}-1`)
-        const stream2 = await client.createStream(`/${testId}-2`)
-        await Promise.all([
-            waitForTheGraphToHaveIndexed(stream1, client),
-            waitForTheGraphToHaveIndexed(stream2, client)
-        ])
-        await client.destroy()
-        const outputLines = await runCommand(`stream search ${testId}`)
-        expect(outputLines).toEqual([
-            stream1.id,
-            stream2.id
-        ])
-    }, 20 * 1000)
-
-})

package/test/stream-show.test.ts

@@ -1,31 +0,0 @@
-import { createTestPrivateKey } from '@streamr/test-utils'
-import { Wallet } from 'ethers'
-import { createTestClient, runCommand, waitForTheGraphToHaveIndexed } from './utils'
-
-describe('show stream', () => {
-
-    it('happy path', async () => {
-        const creatorPrivateKey = await createTestPrivateKey({ gas: true })
-        const client = createTestClient(creatorPrivateKey)
-        const stream = await client.createStream(`/${Date.now()}`)
-        await waitForTheGraphToHaveIndexed(stream, client)
-        await client.destroy()
-        const outputLines = await runCommand(`stream show ${stream.id} --include-permissions`)
-        const outputJson = JSON.parse(outputLines.join(''))
-        expect(outputJson).toMatchObject({
-            id: stream.id,
-            partitions: 1,
-            permissions: [{
-                permissions: [
-                    'edit',
-                    'delete',
-                    'publish',
-                    'subscribe',
-                    'grant'
-                ],
-                user: new Wallet(creatorPrivateKey).address.toLowerCase()
-            }]
-        })
-    }, 20 * 1000)
-
-})