fix: apply most linter suggestions

Author: elribonazo

packages/sdk-analytics/src/analytics.test.ts

@@ -1,7 +1,9 @@
+import nock from 'nock';
+/* eslint-disable-next-line id-length */
 import * as t from 'vitest';
+
 import Analytics from './analytics';
-import nock from 'nock';
-import * as schema from './schema';
+import type * as schema from './schema';
 
 t.describe('Analytics Integration', () => {
   let analytics: Analytics;
@@ -17,6 +19,7 @@ t.describe('Analytics Integration', () => {
   };
 
   t.afterAll(() => {
+    /* eslint-disable-next-line import-x/no-named-as-default-member */
     nock.cleanAll();
   });
 
@@ -28,7 +31,11 @@ t.describe('Analytics Integration', () => {
         return true; // Accept any body to proceed with the intercept
       })
       .optionally()
-      .reply(200, { status: 'success' }, { 'Content-Type': 'application/json' });
+      .reply(
+        200,
+        { status: 'success' },
+        { 'Content-Type': 'application/json' },
+      );
 
     analytics = new Analytics('http://127.0.0.1');
     analytics.track(event.name, { ...event });
@@ -49,7 +56,11 @@ t.describe('Analytics Integration', () => {
         captured = body; // Capture the request body directly
         return true; // Accept any body to proceed with the intercept
       })
-      .reply(200, { status: 'success' }, { 'Content-Type': 'application/json' });
+      .reply(
+        200,
+        { status: 'success' },
+        { 'Content-Type': 'application/json' },
+      );
 
     analytics = new Analytics('http://127.0.0.2');
     analytics.enable();
@@ -63,8 +74,10 @@ t.describe('Analytics Integration', () => {
     await new Promise((resolve) => setTimeout(resolve, 300));
 
     // Verify the captured payload
-    t.expect(captured).toEqual([{ ...event, dapp_id: 'some-non-global-property' }]);
+    t.expect(captured).toEqual([
+      { ...event, dapp_id: 'some-non-global-property' },
+    ]);
 
     scope.done();
   });
-});
+});

packages/sdk-analytics/src/analytics.ts

@@ -1,18 +1,22 @@
+/* eslint-disable no-restricted-syntax */
 import createClient from 'openapi-fetch';
-import * as schema from './schema';
+
+import type * as schema from './schema';
 import Sender from './sender';
 
 type Event = schema.components['schemas']['Event'];
 
 class Analytics {
-  private enabled: boolean = false;
-  private sender: Sender<Event>;
+  private enabled = false;
+
+  private readonly sender: Sender<Event>;
+
   private properties: Record<string, string> = {};
 
   constructor(baseUrl: string) {
     const client = createClient<schema.paths>({ baseUrl });
 
-    const sendFn = async (batch: Event[]) => {
+    const sendFn = async (batch: Event[]): Promise<void> => {
       const res = await client.POST('/v1/events', { body: batch });
       if (res.response.status !== 200) {
         throw new Error(res.error);
@@ -22,21 +26,24 @@ class Analytics {
     this.sender = new Sender({ batchSize: 100, baseIntervalMs: 200, sendFn });
   }
 
-  public enable() {
-    if (this.enabled) return;
-    this.enabled = true;
-    this.sender.start();
+  public enable(): void {
+    if (!this.enabled) {
+      this.enabled = true;
+      this.sender.start();
+    }
   }
 
-  public setGlobalProperty(key: string, value: string) {
+  public setGlobalProperty(key: string, value: string): void {
     this.properties[key] = value;
   }
 
-  public track<T extends Event>(name: T['name'], properties: Partial<T>) {
-    if (!this.enabled) return;
+  public track<T extends Event>(name: T['name'], properties: Partial<T>): void {
+    if (!this.enabled) {
+      return;
+    }
 
-    const event: Event = {
-      name: name,
+    const event = {
+      name,
       ...this.properties,
       ...properties,
     } as T;

packages/sdk-analytics/src/sender.test.ts

@@ -1,4 +1,6 @@
+/* eslint-disable-next-line id-length */
 import * as t from 'vitest';
+
 import Sender from './sender';
 
 t.describe('Sender', () => {
@@ -24,60 +26,71 @@ t.describe('Sender', () => {
   t.it('should flush periodically', async () => {
     sender.start();
     sender.enqueue('event1');
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 100));
     t.expect(sendFn).toHaveBeenCalledWith(['event1']);
   });
 
-  t.it('should handle failure and reset interval after successful send', async () => {
-    let sendCount = 0;
-    sendFn = t.vi.fn().mockImplementation(() => {
-      sendCount++;
-      return sendCount === 1 ? Promise.reject(new Error('Failed')) : Promise.resolve();
-    });
-    sender = new Sender({ batchSize: 100, baseIntervalMs: 50, sendFn }); // Short interval
-    sender.start();
+  t.it(
+    'should handle failure and reset interval after successful send',
+    async () => {
+      let sendCount = 0;
+      sendFn = t.vi.fn().mockImplementation(async () => {
+        sendCount += 1;
+        return sendCount === 1
+          ? Promise.reject(new Error('Failed'))
+          : Promise.resolve();
+      });
+      sender = new Sender({ batchSize: 100, baseIntervalMs: 50, sendFn }); // Short interval
+      sender.start();
 
-    sender.enqueue('event1');
-    t.expect(sendFn).toHaveBeenCalledTimes(0);
+      sender.enqueue('event1');
+      t.expect(sendFn).toHaveBeenCalledTimes(0);
 
-    // Wait for initial send
-    await new Promise(resolve => setTimeout(resolve, 51));
-    t.expect(sendFn).toHaveBeenCalledTimes(1);
+      // Wait for initial send
+      await new Promise((resolve) => setTimeout(resolve, 51));
+      t.expect(sendFn).toHaveBeenCalledTimes(1);
 
-    // Wait for first attempt + retry
-    await new Promise(resolve => setTimeout(resolve, 101));
-    t.expect(sendFn).toHaveBeenCalledTimes(2); // First attempt fails, then succeeds
+      // Wait for first attempt + retry
+      await new Promise((resolve) => setTimeout(resolve, 101));
+      t.expect(sendFn).toHaveBeenCalledTimes(2); // First attempt fails, then succeeds
 
-    // Wait for next scheduled send (should happen at original interval)
-    sender.enqueue('event2');
-    await new Promise(resolve => setTimeout(resolve, 51));
-    t.expect(sendFn).toHaveBeenCalledTimes(3);
-    t.expect(sendFn).toHaveBeenCalledWith(['event2']);
-  });
+      // Wait for next scheduled send (should happen at original interval)
+      sender.enqueue('event2');
+      await new Promise((resolve) => setTimeout(resolve, 51));
+      t.expect(sendFn).toHaveBeenCalledTimes(3);
+      t.expect(sendFn).toHaveBeenCalledWith(['event2']);
+    },
+  );
 
   t.it('should not send when batch is empty', async () => {
     sender.start();
-    await new Promise(resolve => setTimeout(resolve, 51));
+    await new Promise((resolve) => setTimeout(resolve, 51));
     t.expect(sendFn).not.toHaveBeenCalled(); // No send if batch is empty
   });
 
   t.it('should handle concurrent sends properly', async () => {
-    let resolveSend: (value?: unknown) => void;
-    sendFn = t.vi.fn().mockImplementation(() => new Promise(resolve => { resolveSend = resolve; }));
+    let resolveSend!: (value?: unknown) => void;
+    sendFn = t.vi.fn().mockImplementation(
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      () =>
+        new Promise((resolve) => {
+          resolveSend = resolve;
+        }),
+    );
     sender = new Sender({ batchSize: 100, baseIntervalMs: 1000, sendFn });
     sender.start();
 
     sender.enqueue('event1');
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await new Promise((resolve) => setTimeout(resolve, 1000));
     t.expect(sendFn).toHaveBeenCalledWith(['event1']);
 
     sender.enqueue('event2'); // Enqueue while sending
-    resolveSend!(); // Finish the first send
+    resolveSend(); // Finish the first send
     await Promise.resolve(); // Allow async flush to complete
 
     // Wait for next scheduled send
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await new Promise((resolve) => setTimeout(resolve, 1000));
     t.expect(sendFn).toHaveBeenCalledWith(['event2']);
     t.expect(sendFn).toHaveBeenCalledTimes(2);
   });
-});
+});

packages/sdk-analytics/src/sender.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-restricted-syntax */
 type SenderOptions<T> = {
   batchSize: number;
   baseIntervalMs: number;
@@ -9,14 +10,17 @@ type SenderOptions<T> = {
  * It also uses exponential backoff to handle errors.
  */
 class Sender<T> {
-  private sendFn: (batch: T[]) => Promise<void>;
+  private readonly sendFn: (batch: T[]) => Promise<void>;
 
   private batch: T[] = [];
 
-  private batchSize: number;
-  private baseIntervalMs: number;
+  private readonly batchSize: number;
+
+  private readonly baseIntervalMs: number;
+
   private currentIntervalMs: number;
-  private maxIntervalMs: number = 30_000; // 30 seconds
+
+  private readonly maxIntervalMs: number = 30_000; // 30 seconds
 
   private intervalId: NodeJS.Timeout | null = null;
 
@@ -29,40 +33,48 @@ class Sender<T> {
     this.sendFn = options.sendFn;
   }
 
-  public enqueue(item: T) {
+  public enqueue(item: T): void {
     this.batch.push(item);
     if (this.batch.length >= this.batchSize && !this.isSending) {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       this.flush();
     }
   }
 
-  public start() {
-    if (this.intervalId) return;
+  public start(): void {
+    if (this.intervalId) {
+      return;
+    }
     this.scheduleNextSend();
   }
 
-  private scheduleNextSend() {
+  private scheduleNextSend(): void {
     if (this.intervalId) {
       clearTimeout(this.intervalId);
     }
-    this.intervalId = setTimeout(() => this.flush(), this.currentIntervalMs);
+    this.intervalId = setTimeout(() => {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      this.flush();
+    }, this.currentIntervalMs);
   }
 
-  private async flush() {
-    if (this.isSending || this.batch.length === 0) return;
-
+  private async flush(): Promise<void> {
+    if (this.isSending || this.batch.length === 0) {
+      return;
+    }
     this.isSending = true;
-
     const current = [...this.batch];
-
     this.batch = [];
 
     try {
       await this.sendFn(current);
       this.currentIntervalMs = this.baseIntervalMs; // reset on success
     } catch {
       this.batch = [...current, ...this.batch];
-      this.currentIntervalMs = Math.min(this.currentIntervalMs * 2, this.maxIntervalMs); // exponential backoff on error
+      this.currentIntervalMs = Math.min(
+        this.currentIntervalMs * 2,
+        this.maxIntervalMs,
+      ); // exponential backoff on error
     } finally {
       this.isSending = false;
       this.scheduleNextSend();