chore(server): add route parameter types for @types/express-serve-static-core 5.1.1 compatibility

packages/server/src/middlewares/userData.ts

@@ -23,8 +23,15 @@ const VALID_RESOURCES = [
   'streams',
 ];
 
+interface UserDataParams {
+  uuid?: string;
+  encryptedPassword?: string;
+  // match Express.Request<ParamsDictionary> to keep middleware flexible
+  [key: string]: string | string[] | undefined;
+}
+
 export const userDataMiddleware = async (
-  req: Request,
+  req: Request<UserDataParams>,
   res: Response,
   next: NextFunction
 ) => {
@@ -82,7 +89,7 @@ export const userDataMiddleware = async (
 
     // decrypt the encrypted password
     const { success: successfulDecryption, data: decryptedPassword } =
-      decryptString(encryptedPassword!);
+      decryptString(encryptedPassword);
     if (!successfulDecryption) {
       if (constants.RESOURCES.includes(resource as Resource)) {
         res.status(200).json(

packages/server/src/routes/api/debrid.ts

@@ -38,23 +38,23 @@ router.use((req: Request, res: Response, next: NextFunction) => {
   }
 });
 
+interface PlaybackParams {
+  encryptedStoreAuth: string;
+  fileInfo: string;
+  metadataId: string;
+  filename: string;
+}
+
 router.get(
   '/playback/:encryptedStoreAuth/:fileInfo/:metadataId/:filename',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<PlaybackParams>, res: Response, next: NextFunction) => {
     try {
       const {
         encryptedStoreAuth,
         fileInfo: encodedFileInfo,
         metadataId,
         filename,
       } = req.params;
-      if (!encodedFileInfo || !metadataId || !filename) {
-        throw new APIError(
-          constants.ErrorCode.BAD_REQUEST,
-          undefined,
-          'Encrypted store auth, file info, metadata id and filename are required'
-        );
-      }
 
       let fileInfo: FileInfo | undefined;
 

packages/server/src/routes/api/proxy.ts

@@ -192,9 +192,14 @@ router.get(
   }
 );
 
+interface ProxyParams {
+  encryptedAuthAndData: string;
+  filename?: string; // optional
+}
+
 router.all(
   '/:encryptedAuthAndData{/:filename}',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<ProxyParams>, res: Response, next: NextFunction) => {
     const startTime = Date.now();
     const requestId = Math.random().toString(36).substring(7);
     let upstreamResponse: Dispatcher.ResponseData | undefined;

packages/server/src/routes/builtins/easynews.ts

@@ -18,9 +18,13 @@ import { createResponse } from '../../utils/responses.js';
 const router: Router = Router();
 const logger = createLogger('server');
 
+interface EasynewsManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<EasynewsManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
 
     try {
@@ -37,9 +41,15 @@ router.get(
   }
 );
 
+interface EasynewsStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<EasynewsStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
 
     try {
@@ -63,6 +73,15 @@ router.get(
  * NZB endpoint - fetches NZB from Easynews and serves it
  * This endpoint is needed because Easynews requires a POST request to fetch NZBs
  */
+interface EasynewsNzbParams {
+  encodedAuth: string;
+  encodedParams: string;
+  aiostreamsAuth?: string; // optional
+  filename: string;
+  // match Express.Request<ParamsDictionary> to allow chaining of easynewsNzbRateLimiter middleware
+  [key: string]: string | string[] | undefined;
+}
+
 router.get(
   '/nzb/:encodedAuth/:encodedParams{/:aiostreamsAuth}/:filename.nzb',
   easynewsNzbRateLimiter,
@@ -71,7 +90,8 @@ router.get(
       encodedAuth,
       encodedParams,
       aiostreamsAuth: encodedAiostreamsAuth,
-    } = req.params;
+      filename,
+    } = req.params as EasynewsNzbParams;
 
     try {
       // Decode and validate auth credentials

packages/server/src/routes/builtins/eztv.ts

@@ -1,11 +1,15 @@
 import { Router, Request, Response, NextFunction } from 'express';
-import { EztvAddon, fromUrlSafeBase64 } from '@aiostreams/core';
+import { EztvAddon, fromUrlSafeBase64, APIError, constants } from '@aiostreams/core';
 
 const router: Router = Router();
 
+interface EztvManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<EztvManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
     try {
       const manifest = new EztvAddon(
@@ -21,9 +25,15 @@ router.get(
   }
 );
 
+interface EztvStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<EztvStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
 
     try {

packages/server/src/routes/builtins/gdrive.ts

@@ -1,12 +1,16 @@
 import { Router, Request, Response, NextFunction } from 'express';
-import { createLogger, fromUrlSafeBase64, GDriveAddon } from '@aiostreams/core';
+import { createLogger, fromUrlSafeBase64, GDriveAddon, APIError, constants } from '@aiostreams/core';
 const router: Router = Router();
 
 const logger = createLogger('server');
 
+interface GDriveManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '{/:encodedConfig}/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<GDriveManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
     const config = encodedConfig
       ? JSON.parse(fromUrlSafeBase64(encodedConfig))
@@ -23,9 +27,15 @@ router.get(
   }
 );
 
+interface GDriveMetaParams {
+  encodedConfig: string;
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/meta/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<GDriveMetaParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
     const config = JSON.parse(fromUrlSafeBase64(encodedConfig));
 
@@ -41,9 +51,16 @@ router.get(
   }
 );
 
+interface GDriveCatalogParams {
+  encodedConfig: string;
+  type: string;
+  id: string;
+  extras?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/catalog/:type/:id{/:extras}.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<GDriveCatalogParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id, extras } = req.params;
     const config = JSON.parse(fromUrlSafeBase64(encodedConfig));
 
@@ -59,9 +76,15 @@ router.get(
   }
 );
 
+interface GDriveStreamParams {
+  encodedConfig: string;
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<GDriveStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
     const config = JSON.parse(fromUrlSafeBase64(encodedConfig));
 

packages/server/src/routes/builtins/knaben.ts

@@ -1,13 +1,16 @@
 import { Router, Request, Response, NextFunction } from 'express';
-import { KnabenAddon, fromUrlSafeBase64 } from '@aiostreams/core';
-import { createLogger } from '@aiostreams/core';
+import { KnabenAddon, fromUrlSafeBase64, createLogger, APIError, constants } from '@aiostreams/core';
 const router: Router = Router();
 
 const logger = createLogger('server');
 
+interface KnabenManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<KnabenManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
     try {
       const manifest = new KnabenAddon(
@@ -23,9 +26,15 @@ router.get(
   }
 );
 
+interface KnabenStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<KnabenStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
 
     try {

packages/server/src/routes/builtins/newznab.ts

@@ -3,14 +3,20 @@ import {
   NewznabAddon,
   createLogger,
   fromUrlSafeBase64,
+  APIError,
+  constants,
 } from '@aiostreams/core';
 const router: Router = Router();
 
 const logger = createLogger('server');
 
+interface NewznabManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<NewznabManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
 
     try {
@@ -27,9 +33,15 @@ router.get(
   }
 );
 
+interface NewznabStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<NewznabStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
 
     try {

packages/server/src/routes/builtins/prowlarr.ts

@@ -1,13 +1,16 @@
 import { Router, Request, Response, NextFunction } from 'express';
-import { ProwlarrAddon, fromUrlSafeBase64 } from '@aiostreams/core';
-import { createLogger } from '@aiostreams/core';
+import { ProwlarrAddon, fromUrlSafeBase64, createLogger, APIError, constants } from '@aiostreams/core';
 const router: Router = Router();
 
 const logger = createLogger('server');
 
+interface ProwlarrManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<ProwlarrManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
 
     try {
@@ -24,9 +27,15 @@ router.get(
   }
 );
 
+interface ProwlarrStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<ProwlarrStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
 
     try {

packages/server/src/routes/builtins/seadex.ts

@@ -1,13 +1,16 @@
 import { Router, Request, Response, NextFunction } from 'express';
-import { SeaDexAddon, fromUrlSafeBase64 } from '@aiostreams/core';
-import { createLogger } from '@aiostreams/core';
+import { SeaDexAddon, fromUrlSafeBase64, createLogger, APIError, constants } from '@aiostreams/core';
 const router: Router = Router();
 
 const logger = createLogger('server');
 
+interface SeaDexManifestParams {
+  encodedConfig?: string; // optional
+}
+
 router.get(
   '/:encodedConfig/manifest.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<SeaDexManifestParams>, res: Response, next: NextFunction) => {
     const { encodedConfig } = req.params;
     try {
       const manifest = new SeaDexAddon(
@@ -24,9 +27,15 @@ router.get(
   }
 );
 
+interface SeaDexStreamParams {
+  encodedConfig?: string; // optional
+  type: string;
+  id: string;
+}
+
 router.get(
   '/:encodedConfig/stream/:type/:id.json',
-  async (req: Request, res: Response, next: NextFunction) => {
+  async (req: Request<SeaDexStreamParams>, res: Response, next: NextFunction) => {
     const { encodedConfig, type, id } = req.params;
     try {
       const streams = await new SeaDexAddon(