add and export pass-through wrapper functions

Author: lobsterkatie

packages/nextjs/src/config/wrappers/index.ts

@@ -0,0 +1,3 @@
+export { withSentryGSPaths } from './withSentryGSPaths';
+export { withSentryGSProps } from './withSentryGSProps';
+export { withSentryGSSP } from './withSentryGSSP';

packages/nextjs/src/config/wrappers/types.ts

@@ -0,0 +1,37 @@
+import type {
+  GetServerSideProps,
+  GetServerSidePropsContext,
+  GetServerSidePropsResult,
+  GetStaticPaths,
+  GetStaticPathsContext,
+  GetStaticPathsResult,
+  GetStaticProps,
+  GetStaticPropsContext,
+  GetStaticPropsResult,
+} from 'next';
+
+type Paths = { [key: string]: string | string[] };
+type Props = { [key: string]: unknown };
+
+export type GSPaths = {
+  fn: GetStaticPaths;
+  wrappedFn: GetStaticPaths;
+  context: GetStaticPathsContext;
+  result: GetStaticPathsResult<Paths>;
+};
+
+export type GSProps = {
+  fn: GetStaticProps;
+  wrappedFn: GetStaticProps;
+  context: GetStaticPropsContext;
+  result: GetStaticPropsResult<Props>;
+};
+
+export type GSSP = {
+  fn: GetServerSideProps;
+  wrappedFn: GetServerSideProps;
+  context: GetServerSidePropsContext;
+  result: GetServerSidePropsResult<Props>;
+};
+
+export type DataFetchingFunction = GSPaths | GSProps | GSSP;

packages/nextjs/src/config/wrappers/withSentryGSPaths.ts

@@ -0,0 +1,16 @@
+import type { GSPaths } from './types';
+import { callOriginal } from './wrapperUtils';
+
+/**
+ * Create a wrapped version of the user's exported `getStaticPaths` function
+ *
+ * @param origGSPaths: The user's `getStaticPaths` function
+ * @returns A wrapped version of the function
+ */
+export function withSentryGSPaths(origGSPaths: GSPaths['fn']): GSPaths['wrappedFn'] {
+  const wrappedGSPaths = async function (context: GSPaths['context']): Promise<GSPaths['result']> {
+    return callOriginal<GSPaths>(origGSPaths, context);
+  };
+
+  return wrappedGSPaths;
+}

packages/nextjs/src/config/wrappers/withSentryGSProps.ts

@@ -0,0 +1,16 @@
+import { GSProps } from './types';
+import { callOriginal } from './wrapperUtils';
+
+/**
+ * Create a wrapped version of the user's exported `getStaticProps` function
+ *
+ * @param origGSProps: The user's `getStaticProps` function
+ * @returns A wrapped version of the function
+ */
+export function withSentryGSProps(origGSProps: GSProps['fn']): GSProps['wrappedFn'] {
+  const wrappedGSProps = async function (context: GSProps['context']): Promise<GSProps['result']> {
+    return callOriginal<GSProps>(origGSProps, context);
+  };
+
+  return wrappedGSProps;
+}

packages/nextjs/src/config/wrappers/withSentryGSSP.ts

@@ -0,0 +1,16 @@
+import { GSSP } from './types';
+import { callOriginal } from './wrapperUtils';
+
+/**
+ * Create a wrapped version of the user's exported `getServerSideProps` function
+ *
+ * @param origGSSP: The user's `getServerSideProps` function
+ * @returns A wrapped version of the function
+ */
+export function withSentryGSSP(origGSSP: GSSP['fn']): GSSP['wrappedFn'] {
+  const wrappedGSSP = async function (context: GSSP['context']): Promise<GSSP['result']> {
+    return callOriginal<GSSP>(origGSSP, context);
+  };
+
+  return wrappedGSSP;
+}

packages/nextjs/src/config/wrappers/wrapperUtils.ts

@@ -0,0 +1,25 @@
+import { DataFetchingFunction } from './types';
+
+/**
+ * Pass-through wrapper for the original function, used as a first step in eventually wrapping the data-fetching
+ * functions with code for tracing.
+ *
+ * @template T Types for `getStaticPaths`, `getStaticProps`, and `getServerSideProps`
+ * @param origFunction The user's exported `getStaticPaths`, `getStaticProps`, or `getServerSideProps` function
+ * @param context The context object passed by nextjs to the function
+ * @returns The result of calling the user's function
+ */
+export async function callOriginal<T extends DataFetchingFunction>(
+  origFunction: T['fn'],
+  context: T['context'],
+): Promise<T['result']> {
+  let pathsOrProps;
+
+  // TODO: Can't figure out how to tell TS that the types are correlated - that a `GSPropsFunction` will only get passed
+  // `GSPropsContext` and never, say, `GSSPContext`. That's what wrapping everything in objects and using the generic
+  // and pulling the types from the generic rather than specifying them directly was supposed to do, but... no luck.
+  // eslint-disable-next-line prefer-const, @typescript-eslint/no-explicit-any
+  pathsOrProps = await (origFunction as any)(context);
+
+  return pathsOrProps;
+}

packages/nextjs/src/index.server.ts

@@ -124,8 +124,9 @@ function addServerIntegrations(options: NextjsOptions): void {
 
 export type { SentryWebpackPluginOptions } from './config/types';
 export { withSentryConfig } from './config';
-export { withSentry } from './utils/withSentry';
 export { isBuild } from './utils/isBuild';
+export { withSentryGSProps, withSentryGSSP, withSentryGSPaths } from './config/wrappers';
+export { withSentry } from './utils/withSentry';
 
 // Wrap various server methods to enable error monitoring and tracing. (Note: This only happens for non-Vercel
 // deployments, because the current method of doing the wrapping a) crashes Next 12 apps deployed to Vercel and