refactor: fix merge

Author: BioPhoton

packages/utils/mocks/sink.mock.ts

@@ -1,18 +1,14 @@
-import type {
-  RecoverResult,
-  Recoverable,
-  Sink,
-} from '../src/lib/sink-source.type';
+import type { AppendableSink, RecoverResult } from '../src/lib/wal';
 
-export class MockSink implements Sink<string, string> {
+export class MockAppendableSink implements AppendableSink<string> {
   private writtenItems: string[] = [];
   private closed = true;
 
   open = vi.fn((): void => {
     this.closed = false;
   });
 
-  write = vi.fn((input: string): void => {
+  append = vi.fn((input: string): void => {
     this.writtenItems.push(input);
   });
 
@@ -24,6 +20,16 @@ export class MockSink implements Sink<string, string> {
     return this.closed;
   });
 
+  recover = vi.fn((): RecoverResult<string> => {
+    return {
+      records: [...this.writtenItems],
+      errors: [],
+      partialTail: null,
+    };
+  });
+
+  repack = vi.fn((): void => {});
+
   encode = vi.fn((input: string): string => {
     return `${input}-${this.constructor.name}-encoded`;
   });
@@ -33,20 +39,14 @@ export class MockSink implements Sink<string, string> {
   });
 }
 
-export class MockTraceEventFileSink extends MockSink implements Recoverable {
-  recover = vi.fn(
-    (): {
-      records: unknown[];
-      errors: { lineNo: number; line: string; error: Error }[];
-      partialTail: string | null;
-    } => {
-      return {
-        records: this.getWrittenItems(),
-        errors: [],
-        partialTail: null,
-      } satisfies RecoverResult<string>;
-    },
-  );
+export class MockTraceEventFileSink extends MockAppendableSink {
+  override recover = vi.fn((): RecoverResult<string> => {
+    return {
+      records: this.getWrittenItems(),
+      errors: [],
+      partialTail: null,
+    };
+  });
 
   repack = vi.fn((): void => {});
 

packages/utils/src/lib/performance-observer.int.test.ts

@@ -1,21 +1,21 @@
 import { type PerformanceEntry, performance } from 'node:perf_hooks';
 import type { MockedFunction } from 'vitest';
-import { MockFileSink } from '../../mocks/sink.mock';
+import { MockAppendableSink } from '../../mocks/sink.mock.js';
 import {
   type PerformanceObserverOptions,
   PerformanceObserverSink,
 } from './performance-observer.js';
 
 describe('PerformanceObserverSink', () => {
   let encode: MockedFunction<(entry: PerformanceEntry) => string[]>;
-  let sink: MockFileSink;
+  let sink: MockAppendableSink;
   let options: PerformanceObserverOptions<string>;
 
   const awaitObserverCallback = () =>
     new Promise(resolve => setTimeout(resolve, 10));
 
   beforeEach(() => {
-    sink = new MockFileSink();
+    sink = new MockAppendableSink();
     sink.open();
     encode = vi.fn((entry: PerformanceEntry) => [
       `${entry.name}:${entry.entryType}`,
@@ -139,9 +139,9 @@ describe('PerformanceObserverSink', () => {
   });
 
   it('keeps items in queue when sink write fails', async () => {
-    const failingSink = new MockSink();
+    const failingSink = new MockAppendableSink();
     failingSink.open();
-    failingSink.write.mockImplementation(() => {
+    failingSink.append.mockImplementation(() => {
       throw new Error('Sink write failed');
     });
 
@@ -163,7 +163,7 @@ describe('PerformanceObserverSink', () => {
   });
 
   it('keeps items in queue when sink is closed during flush', async () => {
-    const closedSink = new MockSink();
+    const closedSink = new MockAppendableSink();
     closedSink.open();
     closedSink.close();
 

packages/utils/src/lib/performance-observer.ts

@@ -5,7 +5,6 @@ import {
 } from 'node:perf_hooks';
 import { isEnvVarEnabled } from './env.js';
 import { PROFILER_DEBUG_ENV_VAR } from './profiler/constants.js';
-import type { Buffered, Observer, Sink } from './sink-source.type';
 import type { AppendableSink } from './wal.js';
 
 /**
@@ -85,9 +84,9 @@ export function validateFlushThreshold(
 export type PerformanceObserverOptions<T> = {
   /**
    * The sink where encoded performance entries will be written.
-   * Must implement the Sink interface for handling the encoded data.
+   * Must implement the AppendableSink interface for handling the encoded data.
    */
-  sink: Sink<T, unknown>;
+  sink: AppendableSink<T>;
 
   /**
    * Function that encodes raw PerformanceEntry objects into domain-specific types.
@@ -178,7 +177,7 @@ export class PerformanceObserverSink<T> {
   #maxQueueSize: number;
 
   /** The target sink where encoded performance data is written */
-  #sink: Sink<T, unknown>;
+  #sink: AppendableSink<T>;
 
   /** Node.js PerformanceObserver instance, undefined when not subscribed */
   #observer: PerformanceObserver | undefined;

packages/utils/src/lib/performance-observer.unit.test.ts

@@ -1,15 +1,14 @@
 import { type PerformanceEntry, performance } from 'node:perf_hooks';
 import type { MockedFunction } from 'vitest';
 import { MockPerformanceObserver } from '@code-pushup/test-utils';
-import { MockFileSink } from '../../mocks/sink.mock';
+import { MockAppendableSink } from '../../mocks/sink.mock';
 import {
   DEFAULT_FLUSH_THRESHOLD,
   DEFAULT_MAX_QUEUE_SIZE,
   type PerformanceObserverOptions,
   PerformanceObserverSink,
   validateFlushThreshold,
 } from './performance-observer.js';
-import type { Codec } from './wal.js';
 
 describe('validateFlushThreshold', () => {
   it.each([
@@ -56,12 +55,12 @@ describe('validateFlushThreshold', () => {
 
 describe('PerformanceObserverSink', () => {
   let encodePerfEntry: MockedFunction<(entry: PerformanceEntry) => string[]>;
-  let sink: MockFileSink;
+  let sink: MockAppendableSink;
   let options: PerformanceObserverOptions<string>;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    sink = new MockFileSink();
+    sink = new MockAppendableSink();
     sink.open();
     encodePerfEntry = vi.fn((entry: PerformanceEntry) => [
       `${entry.name}:${entry.entryType}`,
@@ -669,17 +668,27 @@ describe('PerformanceObserverSink', () => {
     const customSink = {
       // eslint-disable-next-line functional/immutable-data
       append: (item: string) => collectedItems.push(item),
+      isClosed: () => false,
+      recover: () => ({
+        records: [],
+        errors: [],
+        partialTail: null,
+      }),
+      repack: () => {},
     };
 
     const observer = new PerformanceObserverSink({
       sink: customSink,
-      encode: (entry: PerformanceEntry) => [`${entry.name}:${entry.duration}`],
+      encodePerfEntry: (entry: PerformanceEntry) => [
+        `${entry.name}:${entry.duration}`,
+      ],
     });
 
     observer.subscribe();
 
     const mockObserver = MockPerformanceObserver.lastInstance();
-    mockObserver?.emitMark('test-mark');
+    performance.mark('test-mark');
+    mockObserver?.triggerObserverCallback();
 
     observer.flush();
 

packages/utils/src/lib/profiler/profiler.ts

@@ -6,7 +6,6 @@ import {
   type PerformanceObserverOptions,
   PerformanceObserverSink,
 } from '../performance-observer.js';
-import type { Recoverable, Sink } from '../sink-source.type.js';
 import { objectToEntries } from '../transform.js';
 import {
   type ActionTrackConfigs,
@@ -23,6 +22,7 @@ import type {
   EntryMeta,
   MarkerPayload,
 } from '../user-timing-extensibility-api.type.js';
+import type { AppendableSink } from '../wal.js';
 import {
   PROFILER_DEBUG_ENV_VAR,
   PROFILER_ENABLED_ENV_VAR,
@@ -264,7 +264,7 @@ export type NodejsProfilerOptions<
     /** Sink for buffering and flushing performance data
      * @NOTE this is dummy code and will be replaced by PR #1210
      **/
-    sink: Sink<DomainEvents, unknown> & Recoverable;
+    sink: AppendableSink<DomainEvents>;
 
     /**
      * Name of the environment variable to check for debug mode.
@@ -297,7 +297,7 @@ export class NodejsProfiler<
     ActionTrackEntryPayload
   >,
 > extends Profiler<Tracks> {
-  #sink: Sink<DomainEvents, unknown> & Recoverable;
+  #sink: AppendableSink<DomainEvents>;
   #performanceObserverSink: PerformanceObserverSink<DomainEvents>;
   #state: 'idle' | 'running' | 'closed' = 'idle';
   #debug: boolean;
@@ -377,15 +377,15 @@ export class NodejsProfiler<
     switch (transition) {
       case 'idle->running':
         super.setEnabled(true);
-        this.#sink.open();
+        this.#sink.open?.();
         this.#performanceObserverSink.subscribe();
         break;
 
       case 'running->idle':
       case 'running->closed':
         super.setEnabled(false);
         this.#performanceObserverSink.unsubscribe();
-        this.#sink.close();
+        this.#sink.close?.();
         break;
 
       case 'idle->closed':

packages/utils/src/lib/profiler/profiler.unit.test.ts

@@ -4,7 +4,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { MockTraceEventFileSink } from '../../../mocks/sink.mock.js';
 import type { PerformanceEntryEncoder } from '../performance-observer.js';
 import * as PerfObserverModule from '../performance-observer.js';
-import type { ActionTrackEntryPayload } from '../user-timing-extensibility-api.type.js';
+import type {
+  ActionTrackEntryPayload,
+  UserTimingDetail,
+} from '../user-timing-extensibility-api.type.js';
 import {
   NodejsProfiler,
   type NodejsProfilerOptions,
@@ -23,6 +26,7 @@ describe('getProfilerId', () => {
     );
   });
 });
+
 describe('Profiler', () => {
   const getProfiler = (overrides?: Partial<ProfilerOptions>) =>
     new Profiler({
@@ -491,8 +495,8 @@ describe('NodejsProfiler', () => {
 
     const mockPerfObserverSink = {
       subscribe: vi.fn(),
-      unsubscribe: vi.fn(function (this: typeof mockPerfObserverSink) {
-        this.flush();
+      unsubscribe: vi.fn(() => {
+        mockPerfObserverSink.flush();
       }),
       isSubscribed: vi.fn().mockReturnValue(false),
       encode: vi.fn(),
@@ -1212,9 +1216,10 @@ describe('NodejsProfiler', () => {
     // Verify marker was created with correct name and includes stats in detail
     expect(transitionMark?.name).toBe('idle->running');
     expect(transitionMark?.detail).toBeDefined();
-    expect(transitionMark?.detail.devtools).toBeDefined();
-    expect(transitionMark?.detail.devtools.dataType).toBe('marker');
-    expect(transitionMark?.detail.devtools.properties).toBeDefined();
+    const detail = transitionMark?.detail as UserTimingDetail;
+    expect(detail.devtools).toBeDefined();
+    expect(detail.devtools?.dataType).toBe('marker');
+    expect(detail.devtools?.properties).toBeDefined();
   });
 
   it('setEnabled override: should enable profiling when setEnabled(true)', () => {

packages/utils/src/lib/sink-source.type.ts

@@ -21,8 +21,21 @@ export type InvalidEntry<O = string> = { __invalid: true; raw: O };
  * Interface for sinks that can append items.
  * Allows for different types of appendable storage (WAL, in-memory, etc.)
  */
-export type AppendableSink<T> = {
+export type AppendableSink<T> = Recoverable & {
   append: (item: T) => void;
+  isClosed: () => boolean;
+  open?: () => void;
+  close?: () => void;
+};
+
+/**
+ * Interface for sinks that support recovery operations.
+ * Represents the recoverable subset of AppendableSink functionality.
+ */
+export type Recoverable = {
+  recover: () => RecoverResult<unknown>;
+  repack: (out?: string) => void;
+  finalize?: (opt?: Record<string, unknown>) => void;
 };
 
 /**