How to make all class properties optional in Typescript

There is a way to make this:

<!-- begin snippet: ts hide: false console: true babel: false -->

<!-- language: lang-js -->

interface CreateDTO {
    id: string;
    name: string;
    price: number;
}
  
interface UpdateDTO extends Partial<CreateDTO> {}

<!-- end snippet -->

But using classes, something like this:

<!-- begin snippet: ts hide: false console: true babel: false -->

<!-- language: lang-js -->

class CreateDTO {
    id: string;
    name: string;
    price: number;
}
  
class UpdateDTO extends Partial<CreateDTO> {}

<!-- end snippet -->

The problem is that I have to use classes instead of interfaces because I have to add decorators for the validations.

It's problematic to think of this as transforming one class definition (CreateDTO) into another class definition (UpdateDTO). First, your candidate class definition

class CreateDTO {
    id: string; // error!
    name: string; // error!
    price: number; // error!
}

is failing to initialize its required properties. If you enable the --strictPropertyInitialization compiler option which is included in the --strict suite of compiler features (and you should), this results in compiler errors. Fixing those errors forces you to think about how an instance of the class should actually be constructed, say, by passing constructor arguments for the properties:

class CreateDTO {
    id: string;
    name: string;
    price: number;
    constructor(id: string, name: string, price: number) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
}

And then you can't say class UpdateDTO extends Partial<CreateDTO> because Partial acts only on types, and you need to extend the CreateDTO class constructor* value. You could write a Partial function to widen class constructors of a generic type T to that of Partial<T>:

function Partial<A extends any[], T extends object>(ctor: new (...args: A) => T) {        
    const ret: new (...args: A) => Partial<T> = ctor;
    return ret;
}

and apply it:

class UpdateDTO extends Partial(CreateDTO) { } // okay

But this doesn't really solve the issue, because your new class still requires those constructor arguments, since it just derives from CreateDTO:

const u = new UpdateDTO(); // error!
// -----> ~~~~~~~~~~~~~~~
// Expected 3 arguments, but got 0.

Presumably the point of UpdateDTO is that it doesn't need such arguments. You could keep pushing in this direction, but it feels like the rewards are not worth the cost.

Conceptually, the class UpdateDTO doesn't really derive from the class CreateDTO. They're really more like two separate classes which somehow derive from your interface definitions CreateDTO and Partial<CreateDTO>.

Therefore it might be more fruitful to think of this as transforming interface definitions into class definitions. Let's make a factory function which takes an object type definition and produces a class constructor that takes a constructor argument of that type and produces an instance of a class also of that type. Like this:

function DTOClass<T extends object>() {
    return class {
        constructor(arg: any) {
            Object.assign(this, arg)
        }
    } as (new (arg: T) => T);
}

The implementation uses the Object.assign() method to spread the input argument into the instance being constructed. Then you could make your CreateDTO and UpdateDTO classes with it:

interface CreateDTO {
    id: string;
    name: string;
    price: number;
}
const CreateDTO = DTOClass<CreateDTO>();

const c = new CreateDTO({ id: "abc", name: "def", price: 123 });
c.price = 456;
console.log(c); // { "id": "abc", "name": "def", "price": 456 }

}

interface UpdateDTO extends Partial<CreateDTO> { }
const UpdateDTO = DTOClass<UpdateDTO>();
const u = new UpdateDTO({});
u.name = "ghi";
console.log(u); // { "name": "ghi" } 

Looks good. The compiler understands that the class constructors produce instances of the relevant object types, and it works as desired at runtime.

The only thing I might change here is that in the case where the object type has no required properties, it would be nice not to require the class constructor to accept an argument. If I'm going to call new UpdateDTO({}) then new UpdateDTO() should also work. So we can use a conditional type in DTOClass to make the argument optional if {} would be an acceptable input:

function DTOClass<T extends object>() {
    return class {
        constructor(arg: any) {
            Object.assign(this, arg)
        }
    } as {} extends T ? (new (arg?: T) => T) : (new (arg: T) => T);
}

And now you can write

const u = new UpdateDTO();

as well.

Playground link to code