refactor(sdk): Improve InternalPermissionQuery type safety

packages/sdk/src/Stream.ts

@@ -15,8 +15,7 @@ import {
     PermissionAssignment,
     PublicPermissionQuery,
     UserPermissionQuery,
-    toInternalPermissionAssignment,
-    toInternalPermissionQuery
+    toInternalPermissionAssignment
 } from './permission'
 
 /**
@@ -52,10 +51,10 @@ export class Stream {
      * @category Important
      */
     async hasPermission(query: Omit<UserPermissionQuery, 'streamId'> | Omit<PublicPermissionQuery, 'streamId'>): Promise<boolean> {
-        return this.client.hasPermission(toInternalPermissionQuery({
+        return this.client.hasPermission({
             streamId: this.id,
             ...query
-        }))
+        })
     }
 
     /**

packages/sdk/src/StreamrClient.ts

@@ -473,8 +473,8 @@ export class StreamrClient {
     /**
      * Checks whether the given permission is in effect.
      */
-    hasPermission(query: PermissionQuery): Promise<boolean> {
-        return this.streamRegistry.hasPermission(toInternalPermissionQuery(query))
+    async hasPermission(query: PermissionQuery): Promise<boolean> {
+        return this.streamRegistry.hasPermission(await toInternalPermissionQuery(query, this.streamIdBuilder))
     }
 
     /**

packages/sdk/src/contracts/StreamRegistry.ts

@@ -369,14 +369,13 @@ export class StreamRegistry {
     // --------------------------------------------------------------------------------------------
 
     async hasPermission(query: InternalPermissionQuery): Promise<boolean> {
-        const streamId = await this.streamIdBuilder.toStreamID(query.streamId)
         if (isPublicPermissionQuery(query)) {
             const permissionType = streamPermissionToSolidityType(query.permission)
-            return this.streamRegistryContractReadonly.hasPublicPermission(streamId, permissionType)
+            return this.streamRegistryContractReadonly.hasPublicPermission(query.streamId, permissionType)
         } else {
             const chainPermissions = query.allowPublic
-                ? await this.streamRegistryContractReadonly.getPermissionsForUserId(streamId, query.userId)
-                : await this.streamRegistryContractReadonly.getDirectPermissionsForUserId(streamId, query.userId)
+                ? await this.streamRegistryContractReadonly.getPermissionsForUserId(query.streamId, query.userId)
+                : await this.streamRegistryContractReadonly.getDirectPermissionsForUserId(query.streamId, query.userId)
             const permissions = convertChainPermissionsToStreamPermissions(chainPermissions)
             return permissions.includes(query.permission)
         }

packages/sdk/src/permission.ts

@@ -1,5 +1,6 @@
-import { ChangeFieldType, HexString, toUserId, UserID } from '@streamr/utils'
+import { ChangeFieldType, HexString, StreamID, toUserId, UserID } from '@streamr/utils'
 import { MaxUint256 } from 'ethers'
+import { StreamIDBuilder } from './StreamIDBuilder'
 
 export enum StreamPermission {
     EDIT = 'edit',
@@ -24,7 +25,9 @@ export interface PublicPermissionQuery {
 
 export type PermissionQuery = UserPermissionQuery | PublicPermissionQuery
 
-export type InternalPermissionQuery = ChangeFieldType<UserPermissionQuery, 'userId', UserID> | PublicPermissionQuery
+export type InternalUserPermissionQuery = ChangeFieldType<ChangeFieldType<UserPermissionQuery, 'streamId', StreamID>, 'userId', UserID>
+export type InternalPublicPermissionQuery = ChangeFieldType<PublicPermissionQuery, 'streamId', StreamID>
+export type InternalPermissionQuery = InternalUserPermissionQuery | InternalPublicPermissionQuery
 
 export interface UserPermissionAssignment {
     permissions: StreamPermission[]
@@ -55,14 +58,18 @@ export interface ChainPermissions {
     canGrant: boolean
 }
 
-export const isPublicPermissionQuery = (query: InternalPermissionQuery): query is PublicPermissionQuery => {
-    return (query as PublicPermissionQuery).public === true
+export const isPublicPermissionQuery = (query: InternalPermissionQuery): query is InternalPublicPermissionQuery => {
+    return (query as InternalPublicPermissionQuery).public === true
 }
 
-export const toInternalPermissionQuery = (query: PermissionQuery): InternalPermissionQuery => {
-    return ('userId' in query) 
-        ? { ...query, userId: toUserId(query.userId) }
-        : query
+export const toInternalPermissionQuery = async (query: PermissionQuery, streamIdBuilder: StreamIDBuilder): Promise<InternalPermissionQuery> => {
+    const typedBaseQuery = {
+        ...query,
+        streamId: await streamIdBuilder.toStreamID(query.streamId)
+    }
+    return ('userId' in typedBaseQuery)
+        ? { ...typedBaseQuery, userId: toUserId(typedBaseQuery.userId) }
+        : typedBaseQuery
 }
 
 export const isPublicPermissionAssignment = (assignment: InternalPermissionAssignment): assignment is PublicPermissionAssignment => {

packages/sdk/test/test-utils/fake/FakeStreamRegistry.ts

@@ -177,12 +177,12 @@ export class FakeStreamRegistry implements Methods<StreamRegistry> {
         // no-op
     }
 
-    async isStreamPublisher(streamIdOrPath: string, userId: UserID): Promise<boolean> {
-        return this.hasPermission({ streamId: streamIdOrPath, userId, permission: StreamPermission.PUBLISH, allowPublic: true })
+    async isStreamPublisher(streamId: StreamID, userId: UserID): Promise<boolean> {
+        return this.hasPermission({ streamId, userId, permission: StreamPermission.PUBLISH, allowPublic: true })
     }
 
-    async isStreamSubscriber(streamIdOrPath: string, userId: UserID): Promise<boolean> {
-        return this.hasPermission({ streamId: streamIdOrPath, userId, permission: StreamPermission.SUBSCRIBE, allowPublic: true })
+    async isStreamSubscriber(streamId: StreamID, userId: UserID): Promise<boolean> {
+        return this.hasPermission({ streamId, userId, permission: StreamPermission.SUBSCRIBE, allowPublic: true })
     }
 
     // eslint-disable-next-line class-methods-use-this