Revert AppLoadContext back to an interface for module augmentation su…

…pport

.changeset/lemon-dodos-crash.md

@@ -0,0 +1,5 @@
+---
+"@remix-run/server-runtime": patch
+---
+
+[REMOVE] Revert AppLoadContext back to an interface for use with module augmentation

packages/remix-server-runtime/data.ts

@@ -1,19 +1,25 @@
-import type { ActionFunction, LoaderFunction } from "@remix-run/router";
-
 import {
   redirect,
   json,
   isDeferredData,
   isResponse,
   isRedirectStatusCode,
 } from "./responses";
-import type { DataFunctionArgs } from "./routeModules";
+import type {
+  ActionFunction,
+  DataFunctionArgs,
+  LoaderFunction,
+} from "./routeModules";
 
 /**
- * An unknown type for route loaders and actions provided by the server's
- * `getLoadContext()` function.
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
  */
-export type AppLoadContext = unknown;
+export interface AppLoadContext {
+  [key: string]: unknown;
+}
 
 /**
  * Data for a route that was returned from a `loader()`.

packages/remix-server-runtime/routeModules.ts

@@ -8,19 +8,40 @@ import type {
   Params,
 } from "@remix-run/router";
 
-import type { AppData } from "./data";
+import type { AppData, AppLoadContext } from "./data";
 import type { LinkDescriptor } from "./links";
 import type { SerializeFrom } from "./serialize";
 
 export interface RouteModules<RouteModule> {
   [routeId: string]: RouteModule;
 }
 
-export type ActionFunctionArgs = RRActionFunctionArgs<unknown>;
-export type ActionFunction = RRActionFunction<unknown>;
-export type LoaderFunctionArgs = RRLoaderFunctionArgs<unknown>;
-export type LoaderFunction = RRLoaderFunction<unknown>;
-export type DataFunctionArgs = LoaderFunctionArgs | ActionFunctionArgs;
+// Context is always provided in Remix, and typed for module augmentation support.
+// RR also doesn't export DataFunctionArgs so we extend the two interfaces here
+// even tough they're identical under the hood
+export interface DataFunctionArgs
+  extends RRActionFunctionArgs,
+    RRLoaderFunctionArgs {
+  context: AppLoadContext;
+}
+
+/**
+ * A function that handles data mutations for a route.
+ */
+export type ActionFunction = (
+  args: ActionFunctionArgs
+) => ReturnType<RRActionFunction>;
+
+export type ActionFunctionArgs = DataFunctionArgs;
+
+/**
+ * A function that loads data for a route.
+ */
+export type LoaderFunction = (
+  args: LoaderFunctionArgs
+) => ReturnType<RRLoaderFunction>;
+
+export type LoaderFunctionArgs = DataFunctionArgs;
 
 export type HeadersArgs = {
   loaderHeaders: Headers;

packages/remix-server-runtime/routes.ts

@@ -1,12 +1,12 @@
-import type { AgnosticDataRouteObject } from "@remix-run/router";
+import type {
+  AgnosticDataRouteObject,
+  LoaderFunctionArgs as RRLoaderFunctionArgs,
+  ActionFunctionArgs as RRActionFunctionArgs,
+} from "@remix-run/router";
 
 import { callRouteActionRR, callRouteLoaderRR } from "./data";
 import type { FutureConfig } from "./entry";
-import type {
-  ServerRouteModule,
-  ActionFunctionArgs,
-  LoaderFunctionArgs,
-} from "./routeModules";
+import type { ServerRouteModule } from "./routeModules";
 
 export interface RouteManifest<Route> {
   [routeId: string]: Route;
@@ -87,7 +87,9 @@ export function createStaticHandlerDataRoutes(
       id: route.id,
       path: route.path,
       loader: route.module.loader
-        ? (args: LoaderFunctionArgs) =>
+        ? // Need to use RR's version here to permit the optional context even
+          // though we know it'll always be provided in remix
+          (args: RRLoaderFunctionArgs) =>
             callRouteLoaderRR({
               request: args.request,
               params: args.params,
@@ -97,7 +99,7 @@ export function createStaticHandlerDataRoutes(
             })
         : undefined,
       action: route.module.action
-        ? (args: ActionFunctionArgs) =>
+        ? (args: RRActionFunctionArgs) =>
             callRouteActionRR({
               request: args.request,
               params: args.params,