Support arrays of objects

[stefanprobst]

hi, i was wondering if arrays of objects are (yet) supported? i am getting a type error when trying out the following:

import { factory, oneOf, primaryKey } from "@mswjs/data";
import f from "faker";

export const db = factory({
  dataset: {
    id: primaryKey(f.datatype.uuid),
    contributor: [
      {
        actor: oneOf("actor"),
        role: oneOf("actorRole"),
      },
    ],
  },
  actor: {
    id: primaryKey(f.datatype.uuid),
  },
  actorRole: {
    id: primaryKey(f.datatype.uuid),
  },
});

thanks!

[stefanprobst]

would adding Array<NestedModuleDefinition> like here make sense?

[kettanaito]

Hi, @stefanprobst.

While we've added the array support for primitive values (#113), we don't currently support arrays of objects as shown above. Adding those TypeScript changes will satisfy type-checking but we won't parse such model definition correctly.

Overall, we'd have to think about the expectations here.

Plain values must use getters

If you have a model which property is an array of plain values (numbers, strings), it must use a value getter:

factory({
  user: { 
    numbers: () => [1, 2, 3]
  }
})

This will both infer the type of user.numbers and use that getter function to populate the value of numbers if it's not provided when called user.create().

Arrays of objects become confusing

factory({
  dataset: {
    contributors: [
      { actor: oneOf('actor'), role: oneOf('role') }
    ]
  }
})

Here, dataset.contributors equals an array directly (notice no function). But here, we're describing the shape of the data, with each array member being an object (nested model definition).

This raises a series of questions:

1. How to explain users when to go with p: () => [1] and when with p: [{}]?
2. What data type is allowed as the array item's values? Should we limit them to objects only? Should each individual array item support a value getter (p: [() => 1]) or a relation (p: [oneOf('a'), manyOf('b')])?
3. How does one declare a nested array (p: [[a]])?

[stefanprobst]

thanks for the detailed response -- very good questions, i'll need to think about this some more!

[jmaldon1]

@kettanaito Is there an alternative to working with this kind of data?

[kettanaito]

No, there is no alternative. You can use type casting in TypeScript. Otherwise, a proper API needs to be designed around this (see my points above, I'd really appreciate some feedback).

[jmaldon1]

So just wondering, what is the difference between these 2 options:

Option 1:

factory({
  dataset: {
    contributors: [
      { actor: oneOf('actor'), role: oneOf('role') }
    ]
  }
})

Option 2:

factory({
 dataset: {
    contributors: manyOf('contributor')
  },
  contributor: { actor: oneOf('actor'), role: oneOf('role') }
})

[SevenOutman]

Looks like the difference would be whether contributor is queryable via db