@streamr/cli-tools 6.0.0-alpha.4 → 6.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/cli-tools",
-  "version": "6.0.0-alpha.4",
+  "version": "6.0.0-beta.2",
   "description": "Command line tools for Streamr.",
   "bin": {
     "streamr": "dist/bin/streamr.js"
@@ -33,15 +33,14 @@
     "easy-table": "^1.1.1",
     "event-stream": "^4.0.1",
     "lodash": "^4.17.21",
-    "streamr-client": "^6.0.0-alpha.26",
-    "streamr-client-protocol": "^11.0.0",
+    "streamr-client": "^6.0.0-beta.3",
+    "streamr-client-protocol": "^12.0.0",
     "streamr-test-utils": "^2.0.0"
   },
   "devDependencies": {
     "@streamr/dev-config": "^1.0.0",
     "@types/easy-table": "0.0.32",
     "@types/event-stream": "^3.3.34",
-    "@types/jest": "^27.0.2",
     "@types/lodash": "^4.14.175",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",

package/src/client.ts

@@ -1,13 +1,13 @@
-import _ from 'lodash'
+import { merge, omit } from 'lodash'
 import { BrubeckClientConfig, StreamrClient, ConfigTest } from 'streamr-client'
 import { GlobalCommandLineArgs } from './common'
 import { getConfig } from './config'
 
 const getClientConfig = (commandLineArgs: GlobalCommandLineArgs, overridenOptions: BrubeckClientConfig) => {
-    const environmentOptions = (commandLineArgs.dev !== undefined) ? _.omit(ConfigTest, 'auth') : undefined
+    const environmentOptions = (commandLineArgs.dev !== undefined) ? omit(ConfigTest, 'auth') : undefined
     const configFileJson = getConfig(commandLineArgs.config)?.client
     const authenticationOptions = (commandLineArgs.privateKey !== undefined) ? { auth: { privateKey: commandLineArgs.privateKey } } : undefined
-    return _.merge(
+    return merge(
         environmentOptions,
         configFileJson,
         authenticationOptions,

package/src/common.ts

@@ -4,6 +4,21 @@ export interface GlobalCommandLineArgs {
     privateKey?: string
 }
 
+export enum OptionType {
+    FLAG, // e.g. "--enable"
+    ARGUMENT  // e.g. "--private-key 0x1234"
+}
+
+export const getOptionType = (value: string | boolean): OptionType | never => {
+    if (typeof value === 'boolean') {
+        return OptionType.FLAG
+    } else if (typeof value === 'string') {
+        return OptionType.ARGUMENT
+    } else {
+        throw new Error(`unknown option type (value: ${value})`)
+    }
+}
+
 export function createFnParseInt(name: string): (s: string) => number {
     return (str: string) => {
         const n = parseInt(str, 10)

package/src/permission.ts

@@ -1,17 +1,9 @@
 import { Argument } from 'commander'
-import { Stream, StreamPermission, StreamrClient } from 'streamr-client'
+import { PermissionAssignment, Stream, StreamPermission, StreamrClient } from 'streamr-client'
 import { createClientCommand } from './command'
 
 const PUBLIC_USER_ID = 'public'
 
-const getTarget = (user: string): string|undefined => {
-    if (user === PUBLIC_USER_ID) {
-        return undefined
-    } else {
-        return user
-    }
-}
-
 export const PERMISSIONS = new Map<string,StreamPermission>([
     ['subscribe', StreamPermission.SUBSCRIBE],
     ['publish', StreamPermission.PUBLISH],
@@ -20,26 +12,38 @@ export const PERMISSIONS = new Map<string,StreamPermission>([
     ['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 = (
-    modifyUserPermission: (stream: Stream, permission: StreamPermission, target: string) => Promise<void>,
-    modifyPublicPermission: (stream: Stream, permission: StreamPermission) => Promise<void>,
+    modify: (stream: Stream, assignment: PermissionAssignment) => Promise<void>,
     modification: string,
 ): void => {
     createClientCommand(async (client: StreamrClient, streamId: string, user: string, permissionIds: string[]) => {
-        const target = getTarget(user)
         const stream = await client.getStream(streamId)
-        for await (const permissionId of permissionIds) {
-            const permission = PERMISSIONS.get(permissionId)!
-            if (target !== undefined) {
-                await modifyUserPermission(stream, permission, target) 
-            } else {
-                await modifyPublicPermission(stream, permission)
+        const permissions: StreamPermission[] = permissionIds.map((permissionId) => getPermission(permissionId))
+        let assignment: PermissionAssignment
+        if (user === PUBLIC_USER_ID) {
+            assignment = {
+                permissions,
+                public: true
+            }
+        } else {
+            assignment = {
+                permissions,
+                user
             }
         }
+        await modify(stream, assignment) 
     })
         .addArgument(new Argument('<streamId>'))
         .addArgument(new Argument('<user>'))

package/src/resend.ts

@@ -19,17 +19,16 @@ export const resend = async (
     subscribe: boolean
 ): Promise<void> => {
     try {
-        const subscribeOpts = {
-            stream: streamId,
-            resend: resendOpts
-        }
         const handler = (message: any) => {
             console.info(JSON.stringify(message))
         }
         if (subscribe) {
-            await client.subscribe(subscribeOpts, handler)
+            await client.subscribe({
+                stream: streamId,
+                resend: resendOpts
+            }, handler)
         } else {
-            await client.resend(subscribeOpts, handler)
+            await client.resend(streamId, resendOpts, handler)
         }
     } catch (err) {
         console.error(err.message ? err.message : err)