How to type "recursive object of primitives"?

Question

I'm trying to come up with an interface that will behave similarly to any in that properties can be accessed with the dot notation object.foo.bar and will describe "recursive object of primitives" that

can only have keys of type string
can only have values of type Primitive | Primitive[]

Where Primitive can be defined as type Primitive = string | boolean | number and by "nested object" I mean that the value can also be another recursive object of primitives.

So far I've come up with the following:

type Primitive = string | number | boolean

interface IPrimitveObject extends Record<string, IPrimitveObject | IPrimitveObject[] | Primitive | Primitive[]> {}

But this fails right on the second level of property access.

const testObject: IPrimitveObject = {
    foo: 'bar',
    bar: {
        baz: true
    }
}

testObject.bar.baz //compiler error: "Property 'bar' does not exist on type 'string | number | boolean | IPrimitveObject | IPrimitveObject[] | Primitive[]'."

Which makes sense. But how can one overcome this?

jcalz · Accepted Answer · 2020-01-08 18:30:49Z

4

Once you annotate a variable as type IPrimitiveObject, that's it's type, and the compiler won't keep track of any particular properties on it that are not known in the definition of IPrimitiveObject.

If you want to create an object literal and have the compiler check that it is assignable to IPrimitiveObject without actually widening its type to IPrimitiveObject and subsequently forgetting all of its specific properties, you can make a generic helper function which only accepts arguments assignable to IPrimitiveObject, and returns them unchanged:

const asIPrimitiveObject = <T extends IPrimitveObject>(t: T) => t;

And you'd use it instead of annotating:

const testObject = asIPrimitiveObject({
  foo: 'bar',
  bar: {
    baz: true
  }
});
/* const testObject: {
    foo: string;
    bar: {
        baz: true;
    };
} */

testObject.bar.baz; // type true

And if you use something incompatible you should get an error:

const badObject = asIPrimitiveObject({
  foo: "bar", // okay
  bar: { baz: { qux: () => 1 } } // error!
//~~~ <-- Type '{ baz: { qux: () => number; }; }' is not assignable to
 //type 'string | number | boolean | IPrimitveObject | IPrimitveObject[] | Primitive[]'.
});

Okay, hope that helps; good luck!

Playground link to code

answered Jan 8, 2020 at 18:30

jcalz

339k29 gold badges452 silver badges449 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Jen Over a year ago

Thanks for the answer! This nicely solves the case of creating/assigning the object literal. What if one gets the objects from some IO (think JSON.parse()) and wants to annotate it with the IPrimitiveObject type so that access to the object is restricted to primitive values. Like parsedObject.bar is ok but parsedObject.bar() would rise an error since its properties can not be a function.

jcalz Over a year ago

Have you tried it? Seems to work for me

Collectives™ on Stack Overflow

How to type "recursive object of primitives"?

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related