Étendre l'objet de requête express à l'aide de Typescript

J'essaie d'ajouter une propriété pour exprimer un objet de requête à partir d'un middleware en utilisant du typographie. Cependant, je ne peux pas comprendre comment ajouter des propriétés supplémentaires à l'objet. Je préférerais ne pas utiliser la notation entre crochets si possible.

Je recherche une solution qui me permettrait d'écrire quelque chose de similaire (si possible):

app.use((req, res, next) => {
    req.property = setProperty(); 
    next();
});

Vous souhaitez créer une définition personnalisée et utiliser une fonctionnalité dans Typescript appelée Fusion de déclaration . Ceci est couramment utilisé, par exemple dans method-override.

Créez un fichier custom.d.tset assurez-vous de l'inclure dans votre section tsconfig.jsons, le filescas échéant. Le contenu peut se présenter comme suit:

declare namespace Express {
   export interface Request {
      tenant?: string
   }
}

Cela vous permettra, à tout moment de votre code, d'utiliser quelque chose comme ceci:

router.use((req, res, next) => {
    req.tenant = 'tenant-X'
    next()
})

router.get('/whichTenant', (req, res) => {
    res.status(200).send('This is your tenant: '+req.tenant)
})

Comme suggéré par les commentaires dans leindex.d.ts , vous déclarez simplement à l' Expressespace de noms global tous les nouveaux membres. Exemple:

declare global {
  namespace Express {
    interface Request {
      context: Context
    }
  }
}

Exemple complet:

import * as express from 'express';

export class Context {
  constructor(public someContextVariable) {
  }

  log(message: string) {
    console.log(this.someContextVariable, { message });
  }
}

declare global {
  namespace Express {
    interface Request {
      context: Context
    }
  }
}

const app = express();

app.use((req, res, next) => {
  req.context = new Context(req.url);
  next();
});

app.use((req, res, next) => {
  req.context.log('about to return')
  res.send('hello world world');
});

app.listen(3000, () => console.log('Example app listening on port 3000!'))

L'extension des espaces de noms globaux est plus abordée dans mon GitBook .

Pour les versions plus récentes d'Express, vous devez augmenter le express-serve-static-coremodule.

Ceci est nécessaire car maintenant l'objet Express vient de là: https://github.com/DefinitelyTyped/DefinatelyTyped/blob/8fb0e959c2c7529b5fa4793a44b41b797ae671b9/types/express/index.d.ts#L19

En gros, utilisez ce qui suit:

declare module 'express-serve-static-core' {
  interface Request {
    myField?: string
  }
  interface Response {
    myField?: string
  }
}

La réponse acceptée (comme les autres) ne fonctionne pas pour moi mais

declare module 'express' {
    interface Request {
        myProperty: string;
    }
}

fait. J'espère que cela aidera quelqu'un.

Après avoir essayé environ 8 réponses et sans succès. J'ai finalement réussi à le faire fonctionner avec jd291 commentaire de pointage à 3mards repo .

Créez un fichier dans la base appelé types/express/index.d.ts. Et écrivez-y:

declare namespace Express {
    interface Request {
        yourProperty: <YourType>;
    }
}

et incluez-le tsconfig.jsonavec:

{
    "compilerOptions": {
        "typeRoots": ["./types"]
    }
}

Ensuite, yourPropertydevrait être accessible sous chaque demande:

import express from 'express';

const app = express();

app.get('*', (req, res) => {
    req.yourProperty = 
});

Aucune des solutions proposées n'a fonctionné pour moi. J'ai fini par étendre simplement l'interface de requête:

import {Request} from 'express';

export interface RequestCustom extends Request
{
    property: string;
}

Alors pour l'utiliser:

import {NextFunction, Response} from 'express';
import {RequestCustom} from 'RequestCustom';

someMiddleware(req: RequestCustom, res: Response, next: NextFunction): void
{
    req.property = '';
}

Edit : Les versions récentes de TypeScript se plaignent de cela. Au lieu de cela, j'ai dû faire:

someMiddleware(expressRequest: Request, res: Response, next: NextFunction): void
{
    const req = expressRequest as RequestCustom;
    req.property = '';
}

Dans TypeScript, les interfaces sont ouvertes. Cela signifie que vous pouvez leur ajouter des propriétés de n'importe où en les redéfinissant simplement.

Étant donné que vous utilisez ce fichier express.d.ts , vous devriez pouvoir redéfinir l' interface de demande pour ajouter le champ supplémentaire.

interface Request {
  property: string;
}

Ensuite, dans votre fonction middleware, le paramètre req doit également avoir cette propriété. Vous devriez pouvoir l'utiliser sans aucune modification de votre code.

Bien qu'il s'agisse d'une question très ancienne, je suis tombé sur ce problème récemment.La réponse acceptée fonctionne bien mais je devais ajouter une interface personnalisée à Request- une interface que j'avais utilisée dans mon code et qui ne fonctionnait pas si bien avec l'accepté répondre. Logiquement, j'ai essayé ceci:

import ITenant from "../interfaces/ITenant";

declare namespace Express {
    export interface Request {
        tenant?: ITenant;
    }
}

Mais cela n'a pas fonctionné car Typescript traite les .d.tsfichiers comme des importations globales et lorsqu'ils contiennent des importations, ils sont traités comme des modules normaux. C'est pourquoi le code ci-dessus ne fonctionne pas sur un paramètre dactylographié standard.

Voici ce que j'ai fini par faire

// typings/common.d.ts

declare namespace Express {
    export interface Request {
        tenant?: import("../interfaces/ITenant").default;
    }
}

// interfaces/ITenant.ts

export interface ITenant {
    ...
}

Peut-être que ce problème a été résolu, mais je veux partager juste un peu, maintenant parfois une interface comme d'autres réponses peut être un peu trop restrictive, mais nous pouvons en fait maintenir les propriétés requises, puis ajouter des propriétés supplémentaires à ajouter en créant un clé avec un type de stringavec type valeur deany

import { Request, Response, NextFunction } from 'express'

interface IRequest extends Request {
  [key: string]: any
}

app.use( (req: IRequest, res: Response, next: NextFunction) => {
  req.property = setProperty();

  next();
});

Alors maintenant, nous pouvons également ajouter toute propriété supplémentaire que nous voulons à cet objet.

Toutes ces réponses semblent erronées ou dépassées d'une manière ou d'une autre.

Cela a fonctionné pour moi en mai 2020:

dans ${PROJECT_ROOT}/@types/express/index.d.ts:

import * as express from "express"

declare global {
    namespace Express {
        interface Request {
            my_custom_property: TheCustomType
        }
    }
}

dans tsconfig.json, ajoutez / fusionnez la propriété de telle sorte que:

"typeRoots": [ "@types" ]

À votre santé.

Si vous recherchez une solution qui fonctionne avec express4, la voici:

@ types / express / index.d.ts: -------- doit être /index.d.ts

declare namespace Express { // must be namespace, and not declare module "Express" { 
  export interface Request {
    user: any;
  }
}

tsconfig.json:

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es2016",
    "typeRoots" : [
      "@types", // custom merged types must be first in a list
      "node_modules/@types",
    ]
  }
}

Réf de https://github.com/TypeStrong/ts-node/issues/715#issuecomment-526757308

Une solution possible consiste à utiliser la "double coulée vers tout"

1- définir une interface avec votre propriété

export interface MyRequest extends http.IncomingMessage {
     myProperty: string
}

2- double fonte

app.use((req: http.IncomingMessage, res: http.ServerResponse, next: (err?: Error) => void) => {
    const myReq: MyRequest = req as any as MyRequest
    myReq.myProperty = setProperty()
    next()
})

Les avantages de la double coulée sont les suivants:

• les typages sont disponibles
• il ne pollue pas les définitions existantes mais les étend, évitant toute confusion
• puisque le casting est explicite, il compile les amendes avec le -noImplicitanydrapeau

Alternativement, il y a l'itinéraire rapide (non typé):

 req['myProperty'] = setProperty()

(ne modifiez pas les fichiers de définition existants avec vos propres propriétés - cela ne peut pas être maintenu. Si les définitions sont incorrectes, ouvrez une demande d'extraction)

ÉDITER

Voir le commentaire ci-dessous, le casting simple fonctionne dans ce cas req as MyRequest

Cette réponse sera bénéfique pour ceux qui comptent sur le package npm ts-node.

Je luttais également avec le même souci d'étendre l' objet de requête , j'ai suivi beaucoup de réponses dans le stack-overflow et j'ai fini par suivre la stratégie mentionnée ci-dessous.

J'ai déclaré la saisie étendue pour express dans le répertoire suivant.${PROJECT_ROOT}/api/@types/express/index.d.ts

declare namespace Express {
  interface Request {
    decoded?: any;
  }
}

puis mettre tsconfig.jsonà jour mon à quelque chose comme ça.

{
  "compilerOptions": {
     "typeRoots": ["api/@types", "node_modules/@types"]
      ...
  }
}

même après avoir effectué les étapes ci-dessus, le studio visuel a cessé de se plaindre, mais malheureusement, le ts-nodecompilateur avait encore l'habitude de lancer.

 Property 'decoded' does not exist on type 'Request'.

Apparemment, le ts-noden'a pas pu localiser les définitions de type étendues pour l' objet de requête .

Finalement, après avoir passé des heures, car je savais que le code VS ne se plaignait pas et était capable de localiser les définitions de frappe, ce qui implique que quelque chose ne va pas avec le ts-nodecomplier.

Mise à jour de départ scripten package.jsonfixe pour moi.

"start": "ts-node --files api/index.ts",

les --filesarguments jouent ici un rôle clé pour déterminer les définitions de type personnalisées.

Pour plus d'informations, veuillez visiter: https://github.com/TypeStrong/ts-node#help-my-types-are-missing

Aider tous ceux qui recherchent simplement quelque chose d'autre à essayer, voici ce qui a fonctionné pour moi fin mai 2020 en essayant d'étendre la demande d'ExpressJS. J'ai dû essayer plus d'une douzaine de choses avant que cela fonctionne:

• Inversez l'ordre de ce que tout le monde recommande dans le "typeRoots" de votre tsconfig.json (et n'oubliez pas de supprimer le chemin src si vous avez un paramètre rootDir dans tsconfig tel que "./src"). Exemple:

"typeRoots": [
      "./node_modules/@types",
      "./your-custom-types-dir"
]

• Exemple d'extension personnalisée ('./your-custom-types-dir/express/index.d.ts "). J'ai dû utiliser l'importation en ligne et les exportations par défaut pour utiliser des classes comme type dans mon expérience, ce qui est également montré:

declare global {
  namespace Express {
    interface Request {
      customBasicProperty: string,
      customClassProperty: import("../path/to/CustomClass").default;
    }
  }
}

• Mettez à jour votre fichier nodemon.json pour ajouter la commande "--files" à ts-node, exemple:

{
  "restartable": "rs",
  "ignore": [".git", "node_modules/**/node_modules"],
  "verbose": true,
  "exec": "ts-node --files",
  "watch": ["src/"],
  "env": {
    "NODE_ENV": "development"
  },
  "ext": "js,json,ts"
}

Il est peut-être déjà assez tard pour cette réponse, mais de toute façon, voici comment j'ai résolu:

1. Assurez-vous que la source de vos types est incluse dans votre tsconfigfichier (cela pourrait être un tout nouveau fil)
2. Dans votre répertoire de types, ajoutez un nouveau répertoire et nommez-le comme package pour lequel vous souhaitez étendre ou créer des types. Dans ce cas précis, vous allez créer un répertoire avec le nomexpress
3. Dans le expressrépertoire, créez un fichier et nommez-le index.d.ts(DOIT ÊTRE EXACTEMENT COMME CELA)
4. Enfin, pour faire l'extension des types, il vous suffit de mettre un code comme celui-ci:

declare module 'express' {
    export interface Request {
        property?: string;
    }
}

pourquoi avons-nous besoin de faire autant de tracas que dans les réponses acceptées ci-dessus, alors que nous pouvons nous en tirer juste cela

au lieu de joindre notre propriété à la demande , nous pouvons la joindre aux en- têtes de la demande

   req.headers[property] = "hello"