ref: Make baseclient hooks typesafe when using generics

Author: mydea

packages/core/src/baseclient.ts

@@ -9,8 +9,7 @@ import type {
   Event,
   EventDropReason,
   EventHint,
-  HookCallback,
-  HookName,
+  Hook,
   HookStore,
   Integration,
   IntegrationClass,
@@ -359,24 +358,21 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
   /**
    * @inheritDoc
    */
-  public on(hook: HookName, callback: HookCallback): void {
+  public on<HookType extends Hook>(hook: HookType['name'], callback: HookType['callback']): void {
     if (!this._hooks[hook]) {
       this._hooks[hook] = [];
     }
 
-    // @ts-ignore we cannot enforce the callback to match the hook
-    // while saving bundle size
-    this._hooks[hook].push(callback);
+    (this._hooks[hook] as HookType['callback'][]).push(callback);
   }
 
   /**
    * @inheritDoc
    */
-  public emit(hook: HookName, ...args: Parameters<HookCallback>): void {
+  public emit<HookType extends Hook>(hook: HookType['name'], ...args: Parameters<HookType['callback']>): void {
     if (this._hooks[hook]) {
-      // @ts-ignore we cannot enforce the callback to match the hook
-      // while saving bundle size
-      this._hooks[hook].forEach((callback: HookCallback) => callback(...args));
+      // @ts-ignore it does not like ...args, but we know this is correct
+      (this._hooks[hook] as HookType['callback'][]).forEach(callback => callback(...args));
     }
   }
 

packages/types/src/client.ts

@@ -2,7 +2,7 @@ import type { EventDropReason } from './clientreport';
 import type { DataCategory } from './datacategory';
 import type { DsnComponents } from './dsn';
 import type { Event, EventHint } from './event';
-import type { EnvelopeHookCallback, EnvelopeHookName, TransactionHookCallback, TransactionHookName } from './hooks';
+import type { EnvelopeHook, TransactionHook } from './hooks';
 import type { Integration, IntegrationClass } from './integration';
 import type { ClientOptions } from './options';
 import type { Scope } from './scope';
@@ -155,22 +155,22 @@ export interface Client<O extends ClientOptions = ClientOptions> {
   /**
    * Register a callback for transaction start and finish.
    */
-  on?(hook: TransactionHookName, callback: TransactionHookCallback): void;
+  on?(hook: TransactionHook['name'], callback: TransactionHook['callback']): void;
 
   /**
    * Register a callback for envelope creation and sending.
    */
-  on?(hook: EnvelopeHookName, callback: EnvelopeHookCallback): void;
+  on?(hook: EnvelopeHook['name'], callback: EnvelopeHook['callback']): void;
 
   /**
    * Fire a hook event for transaction start and finish. Expects to be given a transaction as the
    * second argument.
    */
-  emit?(hook: TransactionHookName, ...params: Parameters<TransactionHookCallback>): void;
+  emit?(hook: TransactionHook['name'], ...params: Parameters<TransactionHook['callback']>): void;
 
   /*
    * Fire a hook event for envelope creation and sending. Expects to be given an envelope as the
    * second argument.
    */
-  emit?(hook: EnvelopeHookName, ...params: Parameters<EnvelopeHookCallback>): void;
+  emit?(hook: EnvelopeHook['name'], ...params: Parameters<EnvelopeHook['callback']>): void;
 }

packages/types/src/hooks.ts

@@ -1,19 +1,20 @@
 import type { Envelope } from './envelope';
 import type { Transaction } from './transaction';
 
-export type TransactionHookName = 'startTransaction' | 'transactionFinish';
-export type TransactionHookCallback = (transaction: Transaction) => void;
+// Hooks related to transaction start/finish
+export type TransactionHook = {
+  name: 'startTransaction' | 'transactionFinish';
+  callback: (transaction: Transaction) => void;
+};
 
-export type EnvelopeHookName = 'beforeEnvelope';
-export type EnvelopeHookCallback = (envelope: Envelope) => void;
+// Hooks related to envelope create and send
+export type EnvelopeHook = {
+  name: 'beforeEnvelope';
+  callback: (envelope: Envelope) => void;
+};
 
-export type HookName = TransactionHookName | EnvelopeHookName;
-export type HookCallback = TransactionHookCallback | EnvelopeHookCallback;
+export type Hook = TransactionHook | EnvelopeHook;
 
-export type HookStoreItem<N extends HookName, C extends HookCallback> = Partial<{ [key in N]: C[] }>;
+export type HookStoreItem<T extends Hook> = Partial<Record<T['name'], T['callback'][]>>;
 
-export type HookStore =
-  // Hooks related to transaction start/finish
-  HookStoreItem<TransactionHookName, TransactionHookCallback> &
-    // Hooks related to envelope create and send
-    HookStoreItem<EnvelopeHookName, EnvelopeHookCallback>;
+export type HookStore = HookStoreItem<EnvelopeHook> & HookStoreItem<TransactionHook>;

packages/types/src/index.ts

@@ -96,4 +96,4 @@ export type { WrappedFunction } from './wrappedfunction';
 export type { Instrumenter } from './instrumenter';
 
 export type { BrowserClientReplayOptions } from './browseroptions';
-export type { HookStore, HookName, HookCallback } from './hooks';
+export type { HookStore, Hook, TransactionHook, EnvelopeHook } from './hooks';