core: add getDefaultExport method

This was implemented for the portable Express integration, but others
will need the same functionality, so we should have a reusable to save
on bundle size.

Author: isaacs

packages/core/src/integrations/express/index.ts

@@ -33,12 +33,10 @@ import { DEBUG_BUILD } from '../../debug-build';
 import type {
   ExpressApplication,
   ExpressErrorMiddleware,
-  ExpressExport,
   ExpressHandlerOptions,
   ExpressIntegrationOptions,
   ExpressLayer,
   ExpressMiddleware,
-  ExpressModuleExport,
   ExpressRequest,
   ExpressResponse,
   ExpressRouter,
@@ -49,16 +47,13 @@ import type {
 import {
   defaultShouldHandleError,
   getLayerPath,
-  hasDefaultProp,
   isExpressWithoutRouterPrototype,
   isExpressWithRouterPrototype,
 } from './utils';
 import { wrapMethod } from '../../utils/object';
 import { patchLayer } from './patch-layer';
 import { setSDKProcessingMetadata } from './set-sdk-processing-metadata';
-
-const getExpressExport = (express: ExpressModuleExport): ExpressExport =>
-  hasDefaultProp(express) ? express.default : (express as ExpressExport);
+import { getDefaultExport } from '../../utils/get-default-export';
 
 /**
  * This is a portable instrumentatiton function that works in any environment
@@ -73,7 +68,7 @@ const getExpressExport = (express: ExpressModuleExport): ExpressExport =>
  */
 export const patchExpressModule = (options: ExpressIntegrationOptions) => {
   // pass in the require() or import() result of express
-  const express = getExpressExport(options.express);
+  const express = getDefaultExport(options.express);
   const routerProto: ExpressRouterv4 | ExpressRouterv5 | undefined = isExpressWithRouterPrototype(express)
     ? express.Router.prototype // Express v5
     : isExpressWithoutRouterPrototype(express)

packages/core/src/integrations/express/utils.ts

@@ -30,7 +30,6 @@
 import type { SpanAttributes } from '../../types-hoist/span';
 import { getStoredLayers } from './request-layer-store';
 import type {
-  ExpressExport,
   ExpressIntegrationOptions,
   ExpressLayer,
   ExpressLayerType,
@@ -254,14 +253,6 @@ const isExpressRouterPrototype = (routerProto?: unknown): routerProto is Express
 export const isExpressWithoutRouterPrototype = (express: unknown): express is ExpressExportv4 =>
   isExpressRouterPrototype((express as ExpressExportv4).Router) && !isExpressWithRouterPrototype(express);
 
-// dynamic puts the default on .default, require or normal import are fine
-export const hasDefaultProp = (
-  express: unknown,
-): express is {
-  [k: string]: unknown;
-  default: ExpressExport;
-} => !!express && typeof express === 'object' && 'default' in express && typeof express.default === 'function';
-
 function getStatusCodeFromResponse(error: MiddlewareError): number {
   const statusCode = error.status || error.statusCode || error.status_code || error.output?.statusCode;
   return statusCode ? parseInt(statusCode as string, 10) : 500;

packages/core/src/utils/get-default-export.ts

@@ -0,0 +1,24 @@
+/**
+ * Often we patch a module's default export, but we want to be able to do
+ * something like this:
+ *
+ * ```ts
+ * patchTheThing(await import('the-thing'));
+ * ```
+ *
+ * Or like this:
+ *
+ * ```ts
+ * import theThing from 'the-thing';
+ * patchTheThing(theThing);
+ * ```
+ */
+export function getDefaultExport<T>(moduleExport: T | { default: T }): T {
+  return (
+    (!!moduleExport &&
+      typeof moduleExport === 'object' &&
+      'default' in moduleExport &&
+      (moduleExport as { default: T }).default) ||
+    (moduleExport as T)
+  );
+}

packages/core/test/lib/utils/get-default-export.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { getDefaultExport } from '../../../src/utils/get-default-export';
+
+describe('getDefaultExport', () => {
+  it('returns the default export if there is one', () => {
+    const mod = {
+      default: () => {}
+    };
+    expect(getDefaultExport(mod)).toBe(mod.default)
+  });
+  it('returns the module export if no default', () => {
+    const mod = {};
+    expect(getDefaultExport(mod)).toBe(mod)
+  });
+  it('returns the module if a function and not plain object', () => {
+    const mod = Object.assign(function () {}, {
+      default: () => {}
+    });
+    expect(getDefaultExport(mod)).toBe(mod)
+  });
+  it('returns the module if a default is falsey', () => {
+    const mod = Object.assign(function () {}, {
+      default: false,
+    });
+    expect(getDefaultExport(mod)).toBe(mod)
+  });
+});