Modelling Objects

[mauriceoc]

I have a model instance in the form of:

{
  "things": [ "hey" ],
  "stuff": {
      "a16422d1": {
              "foo": "bar"
       }
  }
}

Anybody know how I would specify the stuff object as correctly as possible in the model definitions for the factory function?

Right now I have:

export const db = factory({
  modelName: {
       things: Array
       stuff: ???
  },
})

Maybe I need to convert it into an Array and reconstruct after it is fetched from the db?

export const db = factory({
  modelName: {
       things: Array
       stuff: Array
  },
})

Thanks!

[kettanaito]

Hey, @mauriceoc.

I assume the keys in the stuff object are random, is that correct?

You can pass a function to model property to generate its value.

import { factory } from '@mswjs/data'

export const db = factory({
  modelName: {
    things: Array,
    stuff: () => {
      const randomKey = generateKey()

      return {
        [randomKey]: {
          foo: 'bar'
        }
      }
    }
  }
})

I think currently you can't nest model definitions this way, so { foo: 'bar' } is an object literal and not a model definition (you cannot describe it as foo: String).

Would this achieve your goal? If not, please let me know more about it.

[mauriceoc]

@kettanaito thanks for the suggestions!

I used the model definition as you suggested.

This gets me somewhat closer, it now accepts models that match the model definition and data is returned.

The only issue is the nested structure, as you mentioned.

I can add data with:

db.modelName.create({
  "things": [ "hey" ],
  "stuff": {
      "d354d241": { // note key
              "foo": "zap" // note zap value
       }
  }
});

And I can write a query like: db.modelName.getAll(), but the data is returned like so:

[
{
  "id": "f12433d1"
  "things": [ "hey" ],
  "stuff": {
      "a16422d1": { // key is overridden by random value from model definition
              "foo": "bar" // zap value is overridden by bar value from model definition
       }
  }
}
]

Is it the case that the model definition should always override whatever values I submit in the model instance when I create it with db.modelName.create?

I would like to be able to supply the keys in stuff and the value for foo when I call db.modelName.create.

[mauriceoc]

To solve this I just converted the stuff map to an Array.

So stuff became:

"stuff" : [
     "id": "d354d241",
    "foo": "zap"
]

This satisfied the following model definitions:

factory(
  modelName: {
     things: Array,
     stuff: Array
  }
});

Transformed it back to object after retrieving from the db and passed back to client in the msw handler.

This is not ideal but will revise at some point in future when I figure out a proper solution.

[kettanaito]

Update

Since v1.0, Data no longer provides an object modeling syntax. Instead, it relies on a Standard Schema that you provide, using any Standard Schema-compliant libraries out there. For example, here's how you would describe your original factory using Zod:

const users = new Collection({
  schema: z.object({
    things: z.array(z.string()),
    // Use `z.record()` in Zod to describe an object
    // with dynamic keys.
    stuff: z.record(
      z.string(),
      z.object({
        foo: z.string(),
      }),
    ),
  }),
})

Data will respect this schema whenever you create/update/query properties.