Estenda o objeto Express Request usando Typescript

Estou tentando adicionar uma propriedade para expressar o objeto de solicitação de um middleware usando o typescript. No entanto, não consigo descobrir como adicionar propriedades extras ao objeto. Eu prefiro não usar a notação de colchetes, se possível.

Estou procurando uma solução que me permita escrever algo semelhante a isto (se possível):

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

Você deseja criar uma definição personalizada e usar um recurso do texto digitalizado chamado Mesclagem de declarações . Isso é comumente usado, por exemplo, em method-override.

Criar um arquivo custom.d.tse certifique-se de incluí-lo em sua tsconfig.json's files-section se houver. O conteúdo pode ser o seguinte:

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

Isso permitirá que você, em qualquer ponto de seu código, use algo assim:

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

Conforme sugerido pelos comentários noindex.d.ts , você simplesmente declara ao Expressnamespace global quaisquer novos membros. Exemplo:

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

Exemplo 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!'))

A extensão de namespaces globais é mais abordada em meu GitBook .

Para versões mais recentes do express, você precisa aumentar o express-serve-static-coremódulo.

Isso é necessário porque agora o objeto Express vem de lá: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/8fb0e959c2c7529b5fa4793a44b41b797ae671b9/types/express/index.d.ts#L19

Basicamente, use o seguinte:

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

A resposta aceita (como as outras) não funciona para mim, mas

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

fez. Espero que ajude alguém.

Depois de tentar 8 ou mais respostas e não ter sucesso. Eu finalmente consegui fazê-lo funcionar com jd291 comentário de apontamento para 3mards repo .

Crie um arquivo na base chamada types/express/index.d.ts. E nele escreva:

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

e incluí-lo em tsconfig.json:

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

Em seguida, yourPropertydeve estar acessível em todas as solicitações:

import express from 'express';

const app = express();

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

Nenhuma das soluções oferecidas funcionou para mim. Acabei simplesmente estendendo a interface do Request:

import {Request} from 'express';

export interface RequestCustom extends Request
{
    property: string;
}

Então, para usá-lo:

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

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

Edit : Versões recentes do TypeScript reclamam disso. Em vez disso, tive que fazer:

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

No TypeScript, as interfaces são abertas. Isso significa que você pode adicionar propriedades a eles de qualquer lugar apenas redefinindo-os.

Considerando que você está usando este arquivo express.d.ts , você deve ser capaz de redefinir a interface de solicitação para adicionar o campo extra.

interface Request {
  property: string;
}

Então, em sua função de middleware, o parâmetro req também deve ter essa propriedade. Você deve ser capaz de usá-lo sem nenhuma alteração em seu código.

Embora esta seja uma pergunta muito antiga, eu tropecei neste problema recentemente. A resposta aceita funciona bem, mas eu precisava adicionar uma interface personalizada Request- uma interface que eu estava usando em meu código e que não funcionava tão bem com o aceito responda. Logicamente, tentei isso:

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

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

Mas isso não funcionou porque o Typescript trata os .d.tsarquivos como importações globais e quando eles têm importações são tratados como módulos normais. É por isso que o código acima não funciona em uma configuração de texto digitado padrão.

Aqui está o que acabei fazendo

// typings/common.d.ts

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

// interfaces/ITenant.ts

export interface ITenant {
    ...
}

Talvez este problema tenha sido respondido, mas eu quero compartilhar um pouco, agora às vezes uma interface como outras respostas pode ser um pouco restritiva, mas podemos realmente manter as propriedades necessárias e, em seguida, adicionar quaisquer propriedades adicionais a serem adicionadas, criando um chave com um tipo de stringcom tipo de valor 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();
});

Portanto, agora também podemos adicionar qualquer propriedade adicional que quisermos a este objeto.

Se você está procurando uma solução que funcione com o express4, aqui está:

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

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

Todas essas respostas parecem estar erradas ou desatualizadas de uma forma ou de outra.

Isso funcionou para mim em maio de 2020:

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

import * as express from "express"

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

em tsconfig.json, adicione / mescle a propriedade de modo que:

"typeRoots": [ "@types" ]

Felicidades.

Uma solução possível é usar "dupla fundição para qualquer"

1- definir uma interface com sua propriedade

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

2- elenco duplo

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

As vantagens da dupla fundição são:

• a digitação está disponível
• não polui as definições existentes, mas as estende, evitando confusão
• uma vez que o elenco é explícito, ele compila as multas com a -noImplicitanybandeira

Como alternativa, existe a rota rápida (não digitada):

 req['myProperty'] = setProperty()

(não edite os arquivos de definição existentes com suas próprias propriedades - isso não pode ser mantido. Se as definições estiverem erradas, abra uma solicitação de pull)

EDITAR

Veja o comentário abaixo, fundição simples funciona neste caso req as MyRequest

Esta resposta será benéfica para aqueles que confiam no pacote npm ts-node.

Eu também estava lutando com a mesma preocupação de estender o objeto de solicitação , segui muitas respostas no estouro de pilha e terminei seguindo a estratégia mencionada abaixo.

Declarei digitação estendida para expresso no seguinte diretório.${PROJECT_ROOT}/api/@types/express/index.d.ts

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

em seguida, atualizando meu tsconfig.jsonpara algo assim.

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

mesmo depois de fazer as etapas acima, o estúdio visual parou de reclamar, mas infelizmente, o ts-nodecompilador ainda costumava jogar.

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

Aparentemente, o ts-nodenão foi capaz de localizar as definições de tipo estendido para o objeto de solicitação .

Eventualmente, depois de passar horas, como eu sabia que o Código VS não estava reclamando e fui capaz de localizar as definições de digitação, sugerindo que algo está errado com o ts-nodecomplier.

Atualizar iniciar scriptem package.jsonconsertou para mim.

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

os --filesargumentos desempenham um papel fundamental aqui, determinando as definições de tipo personalizado.

Para obter mais informações, visite: https://github.com/TypeStrong/ts-node#help-my-types-are-missing

Ajudar qualquer pessoa que esteja apenas procurando outra coisa para tentar aqui é o que funcionou para mim no final de maio de 2020, ao tentar estender a solicitação do ExpressJS. Tive que ter tentado mais de uma dúzia de coisas antes de fazer isso funcionar:

• Inverta a ordem do que todos estão recomendando no "typeRoots" do seu tsconfig.json (e não se esqueça de descartar o caminho src se você tiver uma configuração rootDir no tsconfig, como "./src"). Exemplo:

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

• Exemplo de extensão personalizada ('./your-custom-types-dir/express/index.d.ts "). Tive que usar importação inline e exportações padrão para usar classes como um tipo em minha experiência para que isso também seja mostrado:

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

• Atualize seu arquivo nodemon.json para adicionar o comando "--files" ao ts-node, exemplo:

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

Pode ser que já seja tarde para essa resposta, mas de qualquer forma, aqui está como eu resolvi:

1. Certifique-se de ter sua fonte de tipos incluída em seu tsconfig arquivo (pode ser um novo tópico)
2. Dentro de seu diretório de tipos, adicione um novo diretório e nomeie-o como o pacote que deseja estender ou para o qual criar tipos. Neste caso específico, você criará um diretório com o nomeexpress
3. Dentro do expressdiretório, crie um arquivo e nomeie-oindex.d.ts (DEVE SER EXATAMENTE ASSIM)
4. Finalmente para fazer a extensão dos tipos você só precisa colocar um código como o seguinte:

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

Por que precisamos fazer tanto trabalho como nas respostas aceitas acima, quando podemos nos safar fazendo exatamente isso

em vez de anexar nossa propriedade à solicitação , podemos anexá-la aos cabeçalhos da solicitação

   req.headers[property] = "hello"