Estendi l'oggetto Richiesta Express utilizzando Typescript

Sto cercando di aggiungere una proprietà per esprimere l'oggetto della richiesta da un middleware utilizzando il dattiloscritto. Tuttavia non riesco a capire come aggiungere proprietà extra all'oggetto. Preferirei non usare la notazione tra parentesi se possibile.

Sto cercando una soluzione che mi permetta di scrivere qualcosa di simile a questo (se possibile):

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

Si desidera creare una definizione personalizzata e utilizzare una funzionalità in Typescript chiamata Dichiarazione di unione . Questo è comunemente usato, ad esempio in method-override.

Creare un file custom.d.tse fare in modo di includere nel vostro tsconfig.json's files-sezione se del caso. I contenuti possono apparire come segue:

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

Ciò ti consentirà, in qualsiasi punto del codice, di utilizzare qualcosa del genere:

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)
})

Come suggerito dai commenti inindex.d.ts , devi semplicemente dichiarare allo Expressspazio dei nomi globale eventuali nuovi membri. Esempio:

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

Esempio completo:

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'estensione degli spazi dei nomi globali è trattata di più nel mio GitBook .

Per le versioni più recenti di express, è necessario aumentare il express-serve-static-coremodulo.

Questo è necessario perché ora l'oggetto Express proviene da lì: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/8fb0e959c2c7529b5fa4793a44b41b797ae671b9/types/express/index.d.ts#L19

Fondamentalmente, usa quanto segue:

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

La risposta accettata (come le altre) non funziona per me ma

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

fatto. Spero che possa aiutare qualcuno.

Dopo aver provato circa 8 risposte e non aver avuto successo. Alla fine sono riuscito a farlo funzionare con il commento di jd291 che punta al repository 3mards .

Crea un file nella base chiamato types/express/index.d.ts. E in esso scrivi:

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

e includilo tsconfig.jsoncon:

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

Quindi yourPropertydovrebbe essere accessibile ad ogni richiesta:

import express from 'express';

const app = express();

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

Nessuna delle soluzioni offerte ha funzionato per me. Ho finito per estendere semplicemente l'interfaccia della richiesta:

import {Request} from 'express';

export interface RequestCustom extends Request
{
    property: string;
}

Quindi per usarlo:

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

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

Modifica : le versioni recenti di TypeScript si lamentano di questo. Invece ho dovuto fare:

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

In TypeScript, le interfacce sono aperte. Ciò significa che puoi aggiungervi proprietà da qualsiasi luogo semplicemente ridefinendole.

Considerando che stai utilizzando questo file express.d.ts , dovresti essere in grado di ridefinire l' interfaccia della richiesta per aggiungere il campo extra.

interface Request {
  property: string;
}

Quindi nella funzione middleware, anche il parametro req dovrebbe avere questa proprietà. Dovresti essere in grado di usarlo senza modifiche al tuo codice.

Sebbene questa sia una domanda molto vecchia, ultimamente mi sono imbattuto in questo problema.La risposta accettata funziona bene ma avevo bisogno di aggiungere un'interfaccia personalizzata a Request- un'interfaccia che avevo utilizzato nel mio codice e che non funzionava così bene con risposta. Logicamente, ho provato questo:

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

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

Ma ciò non ha funzionato perché Typescript tratta i .d.tsfile come importazioni globali e quando contengono importazioni vengono trattati come normali moduli. Ecco perché il codice sopra non funziona su un'impostazione di dattiloscritto standard.

Ecco cosa ho finito per fare

// typings/common.d.ts

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

// interfaces/ITenant.ts

export interface ITenant {
    ...
}

Forse questo problema ha avuto una risposta, ma voglio condividere solo un po ', ora a volte un'interfaccia come le altre risposte può essere un po' troppo restrittiva, ma possiamo effettivamente mantenere le proprietà richieste e quindi aggiungere eventuali proprietà aggiuntive da aggiungere creando un chiave con un tipo di stringcon tipo di valore diany

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();
});

Quindi ora, possiamo anche aggiungere qualsiasi proprietà aggiuntiva che vogliamo a questo oggetto.

Tutte queste risposte sembrano essere sbagliate o obsolete in un modo o nell'altro.

Questo ha funzionato per me a maggio 2020:

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

import * as express from "express"

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

in tsconfig.json, aggiungi / unisci la proprietà in modo che:

"typeRoots": [ "@types" ]

Saluti.

Se stai cercando una soluzione che funzioni con express4, eccola:

@ types / express / index.d.ts: -------- deve essere /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",
    ]
  }
}

Rif da https://github.com/TypeStrong/ts-node/issues/715#issuecomment-526757308

Una possibile soluzione è utilizzare "double casting to any"

1- definisci un'interfaccia con la tua proprietà

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

2- doppio cast

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

I vantaggi della doppia fusione sono che:

• è disponibile la digitazione
• non inquina le definizioni esistenti ma le amplia, evitando confusione
• poiché il casting è esplicito, compila le multe con il -noImplicitanyflag

In alternativa, c'è il percorso veloce (non tipizzato):

 req['myProperty'] = setProperty()

(non modificare i file di definizione esistenti con le tue proprietà: non è possibile mantenerli. Se le definizioni sono sbagliate, apri una richiesta pull)

MODIFICARE

Vedi il commento qui sotto, il casting semplice funziona in questo caso req as MyRequest

Questa risposta sarà vantaggiosa per coloro che si affidano al pacchetto npm ts-node .

Stavo anche lottando con la stessa preoccupazione di estendere l' oggetto richiesta , ho seguito molte risposte in stack-overflow e ho finito con la strategia sotto menzionata.

Ho dichiarato la digitazione estesa per express nella seguente directory.${PROJECT_ROOT}/api/@types/express/index.d.ts

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

quindi aggiornare il mio tsconfig.jsona qualcosa di simile.

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

anche dopo aver eseguito i passaggi precedenti, lo studio visivo ha smesso di lamentarsi, ma sfortunatamente il ts-nodecompilatore continuava a lanciare.

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

Apparentemente, ts-nodenon è stato possibile individuare le definizioni di tipo estese per la richiesta oggetto .

Alla fine, dopo aver trascorso ore, poiché sapevo che il codice VS non si lamentava ed era in grado di individuare le definizioni di battitura, il che implica che qualcosa non va ts-node compilatore.

Aggiornamento inizio scriptin package.jsonfissa per me.

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

gli --filesargomenti giocano un ruolo chiave qui trovano la determinazione delle definizioni di tipo personalizzato.

Per ulteriori informazioni, visitare: https://github.com/TypeStrong/ts-node#help-my-types-are-missing

Aiutare chiunque stia solo cercando qualcos'altro da provare qui è ciò che ha funzionato per me alla fine di maggio del 2020 quando ho cercato di estendere la richiesta di ExpressJS. Ho dovuto provare più di una dozzina di cose prima di farlo funzionare:

• Cambia l'ordine di ciò che tutti consigliano in "typeRoots" del tuo tsconfig.json (e non dimenticare di eliminare il percorso src se hai un'impostazione rootDir in tsconfig come "./src"). Esempio:

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

• Esempio di estensione personalizzata ("./your-custom-types-dir/express/index.d.ts"). Ho dovuto utilizzare l'importazione in linea e le esportazioni predefinite per utilizzare le classi come tipo nella mia esperienza, quindi anche questo viene mostrato:

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

• Aggiorna il tuo file nodemon.json per aggiungere il comando "--files" a ts-node, esempio:

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

Potrebbe essere già abbastanza tardi per questa risposta, ma comunque ecco come ho risolto:

1. Assicurati di avere la tua fonte di tipi inclusa nel tuo tsconfigfile (questo potrebbe essere un thread completamente nuovo)
2. All'interno della directory dei tipi, aggiungere una nuova directory e denominarla come il pacchetto per il quale si desidera estendere o creare tipi. In questo caso specifico, creerai una directory con il nomeexpress
3. All'interno della expressdirectory creare un file e nominarlo index.d.ts(DEVE ESSERE ESATTAMENTE COME QUELLO)
4. Infine per realizzare l'estensione dei tipi basta inserire un codice come il seguente:

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

perché abbiamo bisogno di fare così tante seccature come nelle risposte accettate sopra, quando possiamo farla franca facendo proprio questo

invece di allegare la nostra proprietà alla richiesta , possiamo allegarla alle intestazioni della richiesta

   req.headers[property] = "hello"