build: clientjs-ci

clients/client-js/sonar-project.properties

@@ -1,13 +1,6 @@
 sonar.projectKey=bancolombia_async-dataflow-client-js
 sonar.organization=grupo-bancolombia
 sonar.projectName=async-dataflow-client-js
-sonar.javascript.lcov.reportPaths=./coverage/lcov.info
 sonar.sources=src
 sonar.tests=test
-
-
-# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
-#sonar.sources=.
-
-# Encoding of the source code. Default is default system encoding
-#sonar.sourceEncoding=UTF-8
+sonar.javascript.lcov.reportPaths=./coverage/lcov.info

clients/client-js/src/async-client.ts

@@ -5,12 +5,12 @@ import { ChannelMessage } from "./channel-message";
 export class AsyncClient {
     private currentTransport: Transport;
     private currentTransportIndex: number = 0;
-    private bindings = [];
-    private cache: Cache = undefined;
+    private readonly bindings = [];
+    private readonly cache: Cache = undefined;
     private closeWasClean: boolean = false;
     private retriesByTransport = 0;
 
-    constructor(private config: AsyncConfig, private transports: Array<string> | null, private mockTransport: any = null) {
+    constructor(private readonly config: AsyncConfig, private readonly transports: Array<string> | null, private readonly mockTransport: any = null) {
         if (!config.dedupCacheDisable) {
             this.cache = new Cache(config.dedupCacheMaxSize, config.dedupCacheTtl);
         }

clients/client-js/src/cache.ts

@@ -2,7 +2,7 @@ import { LRUCache } from 'lru-cache'
 
 export class Cache {
 
-    private cacheImpl: LRUCache<string, string, any>;
+    private readonly cacheImpl: LRUCache<string, string, any>;
 
     private static readonly MAX_SIZE = 100;
     private static readonly DEFAULT_MAX_ELEMENTS = 500;

clients/client-js/src/decoder/binary-decoder.ts

@@ -6,7 +6,7 @@ import { MessageDecoder } from "./message-decoder";
 
 export class BinaryDecoder implements MessageDecoder {
 
-    private textDecoder: TextDecoder;
+    private readonly textDecoder: TextDecoder;
 
     constructor() {
         this.textDecoder = new TextDecoder();

clients/client-js/src/retry-timer.ts

@@ -8,11 +8,11 @@ export class RetryTimer {
     private limitReachedNotified: boolean = false;
 
     constructor(
-        private callback: () => void,
-        private initial: number = 10,
-        private jitterFn: (x: number) => number,
-        private maxRetries: number = 10,
-        private limitReachedCallback: () => void = () => { }) {
+        private readonly callback: () => void,
+        private readonly initial: number = 10,
+        private readonly jitterFn: (x: number) => number,
+        private readonly maxRetries: number = 10,
+        private readonly limitReachedCallback: () => void = () => { }) {
     }
 
     public reset(): void {

clients/client-js/src/transport/sse-transport.ts

@@ -10,7 +10,7 @@ export class SseTransport implements Transport {
 
     private actualToken;
     private eventSource: EventSourcePlus;
-    private serializer: MessageDecoder;
+    private readonly serializer: MessageDecoder;
     private errorCount = 0;
     private controller: EventSourceController;
     private tokenUpdated: boolean = false;
@@ -25,9 +25,9 @@ export class SseTransport implements Transport {
         return new SseTransport(config, handleMessage, errorCallback, transport);
     }
 
-    private constructor(private config: AsyncConfig,
-        private handleMessage: (_message: ChannelMessage) => void,
-        private errorCallback: (_error: TransportError) => void,
+    private constructor(private readonly config: AsyncConfig,
+        private readonly handleMessage: (_message: ChannelMessage) => void,
+        private readonly errorCallback: (_error: TransportError) => void,
         private readonly transport: typeof EventSourcePlus) {
         this.serializer = new JsonDecoder();
         this.actualToken = config.channel_secret;

clients/client-js/src/transport/ws-transport.ts

@@ -13,16 +13,16 @@ export class WsTransport implements Transport {
     private socket: WebSocket;
     public isOpen: boolean = false;
     public isActive: boolean = false;
-    private stateCallbacks = { open: [], close: [], error: [], message: [] }
+    private readonly stateCallbacks = { open: [], close: [], error: [], message: [] }
     private ref = 0;
     private pendingHeartbeatRef: string = null;
     private closeWasClean: boolean = false;
     private heartbeatTimer = null;
     private readonly heartbeatIntervalMs: number;
     private tearingDown: boolean = false;
-    private reconnectTimer: RetryTimer;
+    private readonly reconnectTimer: RetryTimer;
     private serializer: MessageDecoder;
-    private subProtocols: string[] = [Protocol.JSON]
+    private readonly subProtocols: string[] = [Protocol.JSON]
 
     private readonly HEARTBEAT_TIMEOUT = 3051;
 
@@ -34,9 +34,9 @@ export class WsTransport implements Transport {
         return new WsTransport(config, handleMessage, errorCallback, transport);
     }
 
-    private constructor(private config: AsyncConfig,
-        private handleMessage: (_message: ChannelMessage) => void,
-        private errorCallback: (_error: TransportError) => void,
+    private constructor(private readonly config: AsyncConfig,
+        private readonly handleMessage: (_message: ChannelMessage) => void,
+        private readonly errorCallback: (_error: TransportError) => void,
         private readonly transport: any = null) {
 
         const intWindow = typeof window !== "undefined" ? window : null;