Unpacking objects in Typescript

Question

Unpacking objects in Typescript

I am facing an issue with the following code. I'm not sure what is causing the error or how to fix it. The specific error message is:

Type 'CookieSessionObject | null | undefined' is not assignable to type '{ token: string; refreshToken: string; }'.
  Type 'undefined' is not assignable to type '{ token: string; refreshToken: string; }'

...
  namespace CookieSessionInterfaces {
    interface CookieSessionObject {
      token?: string;
      refreshToken?: string;
    }
  }
}

const currentUser = async (req: Request, res: Response, next: NextFunction) => {
  const { token, refreshToken }: { token: string, refreshToken: string } = req.session;
...

Additionally, req.session?.token and req.session?.refreshToken are functioning properly.

typescript express

Answer 1

Answer №1

req.session may be null or undefined. Therefore, in this scenario, you can address it as follows:

type Tokens  = {
    token?: string, 
    refreshToken?: string
}

const { token, refreshToken }: Tokens = req.session || {token: null, refreshToken: null}

Alternatively, if session is either undefined or null, you could choose to throw an exception which can be caught later and managed accordingly.

if (!req.session) {
        throw new UnauthorizeException()
}

const { token, refreshToken }: Tokens = req.session

Your UnauthorizeException might be a custom exception or you could opt for a generic one instead.

In case you are implementing a callback function, remember to call the callback instead of throwing an exception.

Answer 2

req.session may be null or undefined. Therefore, in this scenario, you can address it as follows:

type Tokens  = {
    token?: string, 
    refreshToken?: string
}

const { token, refreshToken }: Tokens = req.session || {token: null, refreshToken: null}

Alternatively, if session is either undefined or null, you could choose to throw an exception which can be caught later and managed accordingly.

if (!req.session) {
        throw new UnauthorizeException()
}

const { token, refreshToken }: Tokens = req.session

Your UnauthorizeException might be a custom exception or you could opt for a generic one instead.

In case you are implementing a callback function, remember to call the callback instead of throwing an exception.

Unpacking objects in Typescript

Answer №1

Similar questions

The function 'Message.Create' cannot be implemented in the Sequelize CLI

Eliminate square brackets from URL containing an array of IDs using Request.js

Is it advisable to utilize TypeScript interfaces for declaration files and React component prop definitions?

Sending the outcome of an asynchronous task from a Node.js web server

Tips for differentiating between elements with identical values in an HTML datalist using Angular

Tips for obtaining the OneSignal playerID

The res.send() method in Restify was not triggered within the callback function of an event

Create and save data to a local file using Angular service

Is it possible to dynamically check values in TypeScript?

Encounter the error "Attempting to access object using Object.keys on a non-object" when attempting to retrieve all fields in request.body in Node.js?

How can I retrieve the name of a constant enum member in TypeScript as a string?

In Angular, when a component is clicked, it is selecting entire arrays instead of just a single item at a

Intercepting Nested Requests in a Nest.js Application

Validating a single field name with various DTO types based on conditions in a NestJS application

Having difficulties transmitting numerical values through res.send() in express with node

When attempting to open the HTML file through an Express application, the background image specified by `background-image: url()` may

Building a Vuetify Form using a custom template design

When the variable type is an interface, should generics be included in the implementation of the constructor?

Unable to utilize class identifiers in TypeScript because of 'incompatible call signatures' restriction

How is it possible that TypeScript does not provide a warning when a function is called with a different number of arguments than what is expected?