Internal properties and methods

src/Session.ts

@@ -47,21 +47,21 @@ export default class Session extends EventEmitter {
         if (typeof this.options.privateKey !== 'undefined') {
             const wallet = new Wallet(this.options.privateKey)
             this.loginFunction = async () => (
-                this._client.loginEndpoints.loginWithChallengeResponse((d: string) => wallet.signMessage(d), wallet.address)
+                this._client.loginWithChallengeResponse((d: string) => wallet.signMessage(d), wallet.address)
             )
         } else if (typeof this.options.ethereum !== 'undefined') {
             const provider = new Web3Provider(this.options.ethereum)
             const signer = provider.getSigner()
             this.loginFunction = async () => (
-                this._client.loginEndpoints.loginWithChallengeResponse((d: string) => signer.signMessage(d), await signer.getAddress())
+                this._client.loginWithChallengeResponse((d: string) => signer.signMessage(d), await signer.getAddress())
             )
         } else if (typeof this.options.apiKey !== 'undefined') {
             this.loginFunction = async () => (
-                this._client.loginEndpoints.loginWithApiKey(this.options.apiKey!)
+                this._client.loginWithApiKey(this.options.apiKey!)
             )
         } else if (typeof this.options.username !== 'undefined' && typeof this.options.password !== 'undefined') {
             this.loginFunction = async () => (
-                this._client.loginEndpoints.loginWithUsernamePassword(this.options.username!, this.options.password!)
+                this._client.loginWithUsernamePassword(this.options.username!, this.options.password!)
             )
         } else {
             if (!this.options.sessionToken) {
@@ -128,7 +128,7 @@ export default class Session extends EventEmitter {
         }
 
         this.updateState(State.LOGGING_OUT)
-        await this._client.loginEndpoints.logoutEndpoint()
+        await this._client.logoutEndpoint()
         this.options.sessionToken = undefined
         this.updateState(State.LOGGED_OUT)
     }

src/StreamrClient.ts

@@ -9,7 +9,7 @@ import StreamrEthereum from './Ethereum'
 import Session from './Session'
 import Connection, { ConnectionError } from './Connection'
 import Publisher from './publish'
-import { Subscriber } from './subscribe'
+import { Subscriber, Subscription } from './subscribe'
 import { getUserId } from './user'
 import { Todo, MaybeAsync, EthereumAddress } from './types'
 import { StreamEndpoints } from './rest/StreamEndpoints'
@@ -141,18 +141,24 @@ export interface StreamrClient extends StreamEndpoints, LoginEndpoints {}
 
 // eslint-disable-next-line no-redeclare
 export class StreamrClient extends EventEmitter {
+    /** @internal */
     id: string
+    /** @internal */
     debug: Debug.Debugger
+    /** @internal */
     options: StrictStreamrClientOptions
     /** @internal */
     session: Session
+    /** @internal */
     connection: StreamrConnection
+    /** @internal */
     publisher: Todo
+    /** @internal */
     subscriber: Subscriber
+    /** @internal */
     cached: StreamrCached
+    /** @internal */
     ethereum: StreamrEthereum
-    streamEndpoints: StreamEndpoints
-    loginEndpoints: LoginEndpoints
 
     constructor(options: StreamrClientOptions = {}, connection?: StreamrConnection) {
         super()
@@ -189,25 +195,29 @@ export class StreamrClient extends EventEmitter {
         this.subscriber = new Subscriber(this)
         this.ethereum = new StreamrEthereum(this)
 
-        this.streamEndpoints = Plugin(this, new StreamEndpoints(this))
-        this.loginEndpoints = Plugin(this, new LoginEndpoints(this))
+        Plugin(this, new StreamEndpoints(this))
+        Plugin(this, new LoginEndpoints(this))
         this.cached = new StreamrCached(this)
     }
 
+    /** @internal */
     async onConnectionConnected() {
         this.debug('Connected!')
         this.emit('connected')
     }
 
+    /** @internal */
     async onConnectionDisconnected() {
         this.debug('Disconnected.')
         this.emit('disconnected')
     }
 
+    /** @internal */
     onConnectionError(err: Todo) {
         this.emit('error', new ConnectionError(err))
     }
 
+    /** @internal */
     getErrorEmitter(source: Todo) {
         return (err: Todo) => {
             if (!(err instanceof ConnectionError || err.reason instanceof ConnectionError)) {
@@ -219,19 +229,20 @@ export class StreamrClient extends EventEmitter {
         }
     }
 
+    /** @internal */
     _onError(err: Todo, ...args: Todo) {
         // @ts-expect-error
         this.onError(err, ...args)
     }
 
+    /** @internal */
     async send(request: Todo) {
         return this.connection.send(request)
     }
 
     /**
      * Override to control output
-     */
-
+     * @internal */
     onError(error: Todo) { // eslint-disable-line class-methods-use-this
         console.error(error)
     }
@@ -256,6 +267,7 @@ export class StreamrClient extends EventEmitter {
         return this.connection.connect()
     }
 
+    /** @internal */
     async nextConnection() {
         return this.connection.nextConnection()
     }
@@ -297,10 +309,12 @@ export class StreamrClient extends EventEmitter {
         return getUserId(this)
     }
 
+    /** @internal */
     setNextGroupKey(...args: Todo) {
         return this.publisher.setNextGroupKey(...args)
     }
 
+    /** @internal */
     rotateGroupKey(...args: Todo) {
         return this.publisher.rotateGroupKey(...args)
     }
@@ -340,7 +354,7 @@ export class StreamrClient extends EventEmitter {
         await this.subscriber.unsubscribe(opts)
     }
 
-    async resend(opts: Todo, onMessage?: OnMessageCallback) {
+    async resend(opts: Todo, onMessage?: OnMessageCallback): Promise<Subscription> {
         const task = this.subscriber.resend(opts)
         if (typeof onMessage !== 'function') {
             return task
@@ -367,11 +381,11 @@ export class StreamrClient extends EventEmitter {
         return this.connection.enableAutoDisconnect(...args)
     }
 
-    getAddress() {
+    getAddress(): EthereumAddress {
         return this.ethereum.getAddress()
     }
 
-    async getPublisherId() {
+    async getPublisherId(): Promise<EthereumAddress> {
         return this.getAddress()
     }
 
@@ -406,6 +420,7 @@ export class StreamrClient extends EventEmitter {
         return DataUnion._deploy(options, this) // eslint-disable-line no-underscore-dangle
     }
 
+    /** @internal */
     _getDataUnionFromName({ dataUnionName, deployerAddress }: { dataUnionName: string, deployerAddress: EthereumAddress}) {
         return DataUnion._fromName({ // eslint-disable-line no-underscore-dangle
             dataUnionName,

src/dataunion/DataUnion.ts

@@ -68,10 +68,11 @@ const log = debug('StreamrClient::DataUnion')
 
 export class DataUnion {
 
-    contractAddress: EthereumAddress
-    sidechainAddress: EthereumAddress
-    client: StreamrClient
+    private contractAddress: EthereumAddress
+    private sidechainAddress: EthereumAddress
+    private client: StreamrClient
 
+    /** @internal */
     constructor(contractAddress: EthereumAddress, sidechainAddress: EthereumAddress, client: StreamrClient) {
         // validate and convert to checksum case
         this.contractAddress = getAddress(contractAddress)
@@ -460,6 +461,7 @@ export class DataUnion {
      * Create a new DataUnionMainnet contract to mainnet with DataUnionFactoryMainnet
      * This triggers DataUnionSidechain contract creation in sidechain, over the bridge (AMB)
      * @return that resolves when the new DU is deployed over the bridge to side-chain
+     * @internal
      */
     static async _deploy(options: DataUnionDeployOptions = {}, client: StreamrClient): Promise<DataUnion> {
         const deployerAddress = client.getAddress()
@@ -513,18 +515,21 @@ export class DataUnion {
 
     // Internal functions
 
+    /** @internal */
     static _fromContractAddress(contractAddress: string, client: StreamrClient) {
         const contracts = new Contracts(client)
         const sidechainAddress = contracts.getDataUnionSidechainAddress(getAddress(contractAddress)) // throws if bad address
         return new DataUnion(contractAddress, sidechainAddress, client)
     }
 
+    /** @internal */
     static _fromName({ dataUnionName, deployerAddress }: { dataUnionName: string, deployerAddress: string}, client: StreamrClient) {
         const contracts = new Contracts(client)
         const contractAddress = contracts.getDataUnionMainnetAddress(dataUnionName, getAddress(deployerAddress)) // throws if bad address
         return DataUnion._fromContractAddress(contractAddress, client) // eslint-disable-line no-underscore-dangle
     }
 
+    /** @internal */
     async _getContract() {
         const ret = this.getContracts().getMainnetContract(this.contractAddress)
         // @ts-expect-error

src/rest/LoginEndpoints.ts

@@ -28,12 +28,14 @@ async function getSessionToken(url: string, props: any) {
 /** TODO the class should be annotated with at-internal, but adding the annotation hides the methods */
 export class LoginEndpoints {
 
+    /** @internal */
     client: StreamrClient
 
     constructor(client: StreamrClient) {
         this.client = client
     }
 
+    /** @internal */
     async getChallenge(address: string) {
         this.client.debug('getChallenge %o', {
             address,
@@ -48,6 +50,7 @@ export class LoginEndpoints {
         )
     }
 
+    /** @internal */
     async sendChallengeResponse(challenge: { challenge: string }, signature: string, address: string) {
         this.client.debug('sendChallengeResponse %o', {
             challenge,
@@ -63,6 +66,7 @@ export class LoginEndpoints {
         return getSessionToken(url, props)
     }
 
+    /** @internal */
     async loginWithChallengeResponse(signingFunction: (challenge: string) => Promise<string>, address: string) {
         this.client.debug('loginWithChallengeResponse %o', {
             address,
@@ -72,6 +76,7 @@ export class LoginEndpoints {
         return this.sendChallengeResponse(challenge, signature, address)
     }
 
+    /** @internal */
     async loginWithApiKey(apiKey: string) {
         this.client.debug('loginWithApiKey %o', {
             apiKey,
@@ -83,6 +88,7 @@ export class LoginEndpoints {
         return getSessionToken(url, props)
     }
 
+    /** @internal */
     async loginWithUsernamePassword(username: string, password: string) {
         this.client.debug('loginWithUsernamePassword %o', {
             username,
@@ -110,6 +116,7 @@ export class LoginEndpoints {
         return authFetch<UserDetails>(`${this.client.options.restUrl}/users/me`, this.client.session)
     }
 
+    /** @internal */
     async logoutEndpoint(): Promise<void> {
         this.client.debug('logoutEndpoint')
         await authFetch(`${this.client.options.restUrl}/logout`, this.client.session, {

src/rest/StreamEndpoints.ts

@@ -79,6 +79,7 @@ function getKeepAliveAgentForUrl(url: string) {
 /** TODO the class should be annotated with at-internal, but adding the annotation hides the methods */
 export class StreamEndpoints {
 
+    /** @internal */
     client: StreamrClient
 
     constructor(client: StreamrClient) {
@@ -171,7 +172,7 @@ export class StreamEndpoints {
         return json.addresses.map((a: string) => a.toLowerCase())
     }
 
-    async isStreamPublisher(streamId: string, ethAddress: string) {
+    async isStreamPublisher(streamId: string, ethAddress: EthereumAddress) {
         this.client.debug('isStreamPublisher %o', {
             streamId,
             ethAddress,
@@ -198,7 +199,7 @@ export class StreamEndpoints {
         return json.addresses.map((a: string) => a.toLowerCase())
     }
 
-    async isStreamSubscriber(streamId: string, ethAddress: string) {
+    async isStreamSubscriber(streamId: string, ethAddress: EthereumAddress) {
         this.client.debug('isStreamSubscriber %o', {
             streamId,
             ethAddress,

src/stream/StorageNode.ts

@@ -1,7 +1,9 @@
 import { EthereumAddress } from '../types'
 
 export default class StorageNode {
-    _address: EthereumAddress
+
+    private _address: EthereumAddress
+
     constructor(address: EthereumAddress) {
         this._address = address
     }

src/stream/index.ts

@@ -70,17 +70,21 @@ function getFieldType(value: any): (Field['type'] | undefined) {
 }
 
 export class Stream {
-    // TODO add field definitions for all fields
     // @ts-expect-error
     id: string
     // @ts-expect-error
     name: string
+    description?: string
     config: {
         fields: Field[];
     } = { fields: [] }
+    partitions?: number
+    /** @internal */
     _client: StreamrClient
     requireEncryptedData?: boolean
     requireSignedData?: boolean
+    storageDays?: number
+    inactivityThresholdHours?: number
 
     constructor(client: StreamrClient, props: StreamProperties) {
         this._client = client
@@ -99,6 +103,7 @@ export class Stream {
         return json ? new Stream(this._client, json) : undefined
     }
 
+    /** @internal */
     toObject() {
         const result = {}
         Object.keys(this).forEach((key) => {