fix(types): decouple V1orV2Endpoint type from EndpointBearer type

Author: kuhe

packages/middleware-serde/src/serdePlugin.ts

@@ -5,6 +5,7 @@ import {
   MetadataBearer,
   MiddlewareStack,
   Pluggable,
+  Provider,
   RequestSerializer,
   ResponseDeserializer,
   SerializeHandlerOptions,
@@ -30,22 +31,22 @@ export const serializerMiddlewareOption: SerializeHandlerOptions = {
 
 // Type the modifies the EndpointBearer to make it compatible with Endpoints 2.0 change.
 // Must be removed after all clients has been onboard the Endpoints 2.0
-export type V1OrV2Endpoint<T extends EndpointBearer> = T & {
+export type V1OrV2Endpoint = {
+  // for v2
   urlParser?: UrlParser;
+
+  // for v1
+  endpoint?: Provider<Endpoint>;
 };
 
-export function getSerdePlugin<
-  InputType extends object,
-  SerDeContext extends EndpointBearer,
-  OutputType extends MetadataBearer
->(
-  config: V1OrV2Endpoint<SerDeContext>,
-  serializer: RequestSerializer<any, SerDeContext>,
+export function getSerdePlugin<InputType extends object, SerDeContext, OutputType extends MetadataBearer>(
+  config: V1OrV2Endpoint,
+  serializer: RequestSerializer<any, SerDeContext & EndpointBearer>,
   deserializer: ResponseDeserializer<OutputType, any, SerDeContext>
 ): Pluggable<InputType, OutputType> {
   return {
     applyToStack: (commandStack: MiddlewareStack<InputType, OutputType>) => {
-      commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
+      commandStack.add(deserializerMiddleware(config as SerDeContext, deserializer), deserializerMiddlewareOption);
       commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
     },
   };

packages/middleware-serde/src/serializerMiddleware.ts

@@ -12,21 +12,21 @@ import type { V1OrV2Endpoint } from "./serdePlugin";
 
 export const serializerMiddleware =
   <Input extends object, Output extends object, RuntimeUtils extends EndpointBearer>(
-    options: V1OrV2Endpoint<RuntimeUtils>,
+    options: V1OrV2Endpoint,
     serializer: RequestSerializer<any, RuntimeUtils>
   ): SerializeMiddleware<Input, Output> =>
   (next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output> =>
   async (args: SerializeHandlerArguments<Input>): Promise<SerializeHandlerOutput<Output>> => {
     const endpoint =
       context.endpointV2?.url && options.urlParser
         ? async () => options.urlParser!(context.endpointV2!.url as URL)
-        : options.endpoint;
+        : options.endpoint!;
 
     if (!endpoint) {
       throw new Error("No valid endpoint provider available.");
     }
 
-    const request = await serializer(args.input, { ...options, endpoint });
+    const request = await serializer(args.input, { ...options, endpoint } as RuntimeUtils);
 
     return next({
       ...args,