Typescript, check if request body has type User otherwise throw error

Question

I'm stuck trying to solve a problem. I'm using express js to build a rest api. I want the user to be able to update their profile.

I've created a User model:

export type User = {
    email: string
    creation_date: number
    first_name?: string
    last_name?: string
    payment_detals?: {
        iban: string
        last_updated: string
    }
    address?: {
        city: string
        street: string
        house_number: string
        postal_code: string
    }
    products?: string[]
}

But I want to receive the request body and update the value for that user in the database (No SQL, Firebase). But I don't want the user to add fields which are not specified in the User type.

How do I check if the request body has type User, if not throw an error?

The route:

const edit = async (req: Request, res: Response) => {
    try {
        let data = req.body
        if (data instanceof User)
    } catch (err) {
        return res.status(501).json({ error: err.message })
    }
    return res.status(200).json({ status: 'ok' })

I can't find any help on the internet, so maybe someone could help me out?

So for example, if the payload of the post request is:

{
  "name": "Jack"
}

It should throw an error, because name is not a member of User.

How can I solve this? All help is appreciated!

---

Updated now trying with classes:

export class CUser {
    email: string
    creation_date: number
    first_name?: string
    last_name?: string
    payment_detals?: {
        iban: string
        last_updated: string
    }
    address?: {
        city: string
        street: string
        house_number: string
        postal_code: string
    }
    products?: string[]
}

The route

const edit = async (req: Request, res: Response) => {
    let data = req.body
    console.log(data instanceof CUser)
    return res.status(200).json({ status: 'ok' })
}

When the request.body is:

{
    "email": "mike@gmail.com",
    "creation_date": 849349388935
}

The data instanceof CUser will always result to false. Wait is it maybe because data is an object?..

Answer 1

Types or interfaces that you define in Typescript are stripped when it's converted into Javascript, so you won't be able to able to check the type during runtime.

What you'll need to do is create a type-guard function that asserts true or false whether or not your request has those specific User properties.

For a good example see: How to check the object type on runtime in TypeScript?

Answer 2

You can create a constructor or function in a typescript class , which will take the req.body and only pick the required keys from the object, assign to this member variable and return you a new instance of the User object.

Now you can apply the checks on User instance or also can create a validateObject method inside the User class

Answer 3

I've solved this by writing a function which compares the request body with the types that I expect, and it works great! If there is something wrong with the fields or the required is wrong, the server will throw an error immediately. Here are some code snippets:

The functions

export type Schema = {
    fields: { [key: string]: string }
    required?: string[]
}

const required = (obj: any, required: string[]) => {
    for (let key of required) {
        if (obj[key] === undefined) return false
    }
    return true
}

export const validate = async (obj: any, model: Schema) => {
    if (model.required) {
        const status = required(obj, model.required)
        if (!status) return false
    }

    for (let key of Object.keys(obj)) {
        if (model.fields[key] === undefined) return false
        else if (typeof obj[key] !== model.fields[key]) return false
    }
    return true
}

Example type

import { Schema } from './'

export type User = {
    email: string
    creation_date: number
    subscription: string
    first_name?: string
    last_name?: string
    payment_detals?: {
        iban: string
        last_updated: string
    }
    address?: {
        city: string
        street: string
        house_number: string
        postal_code: string
    }
    categories?: string[]
    products?: {
        ean: number
        category?: string
        notes?: string
    }[]
}

export const UserSchema: Schema = {
    fields: {
        email: 'string',
        subscription: 'string',
        first_name: 'string',
        last_name: 'string',
        payment_details: 'object',
        address: 'object',
        categories: 'object',
        products: 'object',
    },
    required: ['email']
}

On the server

let status = await validate(body, UserSchema)
if (!status) return res.status(422).json(Message.error.wrong_request_body)

// else continue