Fix type issues

Author: andreiborza

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject/index.ts

@@ -21,16 +21,12 @@ export const TestDurableObject = Sentry.instrumentDurableObjectWithSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
     tracesSampleRate: 1.0,
-    beforeSendTransaction: transaction => {
-      console.log('beforeSendTransaction', transaction);
-      return transaction;
-    },
   }),
   TestDurableObjectBase,
 );
 
 export default {
-  async fetch(request, env): Promise<Response> {
+  async fetch(request: Request, env: Env): Promise<Response> {
     const id: DurableObjectId = env.TEST_DURABLE_OBJECT.idFromName('test');
     const stub = env.TEST_DURABLE_OBJECT.get(id) as unknown as TestDurableObjectBase;
 

packages/cloudflare/src/durableobject.ts

@@ -304,7 +304,7 @@ function instrumentPrototype<T extends NewableFunction>(target: T): void {
 
   while (current && current !== Object.prototype) {
     Object.getOwnPropertyNames(current).forEach(name => {
-      if (name !== 'constructor' && typeof current[name] === 'function') {
+      if (name !== 'constructor' && typeof (current as Record<string, unknown>)[name] === 'function') {
         methodNames.add(name);
       }
     });
@@ -313,20 +313,24 @@ function instrumentPrototype<T extends NewableFunction>(target: T): void {
 
   // Instrument each method on the prototype
   methodNames.forEach(methodName => {
-    const originalMethod = proto[methodName];
+    const originalMethod = (proto as Record<string, unknown>)[methodName];
 
     if (!originalMethod || isInstrumented(originalMethod)) {
       return;
     }
 
     // Create a wrapper that gets context/options from the instance at runtime
-    const wrappedMethod = function (this: any, ...args: any[]) {
-      const instanceContext = this.__SENTRY_CONTEXT__;
-      const instanceOptions = this.__SENTRY_OPTIONS__;
+    const wrappedMethod = function (this: any, ...args: any[]): unknown {
+      const thisWithSentry = this as {
+        __SENTRY_CONTEXT__: DurableObjectState;
+        __SENTRY_OPTIONS__: CloudflareOptions;
+      };
+      const instanceContext = thisWithSentry.__SENTRY_CONTEXT__;
+      const instanceOptions = thisWithSentry.__SENTRY_OPTIONS__;
 
       if (!instanceOptions) {
         // Fallback to original method if no Sentry data found
-        return originalMethod.apply(this, args);
+        return (originalMethod as (...args: any[]) => any).apply(this, args);
       }
 
       // Use the existing wrapper but with instance-specific context/options
@@ -337,12 +341,12 @@ function instrumentPrototype<T extends NewableFunction>(target: T): void {
           spanName: methodName,
           spanOp: 'rpc',
         },
-        originalMethod,
+        originalMethod as (...args: any[]) => any,
         undefined,
         true, // noMark = true since we'll mark the prototype method
       );
 
-      return wrapper.apply(this, args);
+      return (wrapper as (...args: any[]) => any).apply(this, args);
     };
 
     markAsInstrumented(wrappedMethod);

packages/cloudflare/test/durableobject.test.ts

@@ -51,7 +51,7 @@ describe('instrumentDurableObjectWithSentry', () => {
     } as any;
     const mockEnv = {} as any; // Environment mock
     const initCore = vi.spyOn(SentryCore, 'initAndBind');
-    const getClientSpy = vi.spyOn(SentryCore, 'getClient').mockReturnValue(undefined);
+    vi.spyOn(SentryCore, 'getClient').mockReturnValue(undefined);
     const options = vi
       .fn()
       .mockReturnValueOnce({
@@ -63,12 +63,18 @@ describe('instrumentDurableObjectWithSentry', () => {
     const testClass = class {
       method() {}
     };
-    const instance1 = Reflect.construct(instrumentDurableObjectWithSentry(options, testClass as any), [mockContext, mockEnv]) as any;
+    const instance1 = Reflect.construct(instrumentDurableObjectWithSentry(options, testClass as any), [
+      mockContext,
+      mockEnv,
+    ]) as any;
     instance1.method();
-    
-    const instance2 = Reflect.construct(instrumentDurableObjectWithSentry(options, testClass as any), [mockContext, mockEnv]) as any;
+
+    const instance2 = Reflect.construct(instrumentDurableObjectWithSentry(options, testClass as any), [
+      mockContext,
+      mockEnv,
+    ]) as any;
     instance2.method();
-    
+
     expect(initCore).nthCalledWith(1, expect.any(Function), expect.objectContaining({ orgId: 1 }));
     expect(initCore).nthCalledWith(2, expect.any(Function), expect.objectContaining({ orgId: 2 }));
   });