Creating a TypeScript schema with nested maps and arrays using Dynamoose

Question

Creating a TypeScript schema with nested maps and arrays using Dynamoose

I'm currently in the process of developing a schema for a specific example:

{
    "foods": [
        {
            "fruits": [{
                "apple": {
                    "color": "red",
                    "shape": "round"
                }
            }]
        }
    ]
}

Initially, I attempted the following structure, which theoretically should work but encounters a bug as identified in https://github.com/dynamoose/dynamoose/issues/909.

export const FoodsSchema = new dynamoose.Schema({
  foods: {
    type: Array,
    schema: [{
      type: Object,
      schema: {
        fruits: {
          type: Array,
          schema: [{
            apple: {
              type: Object,
              schema: {
                color: String,
                shape: String,
              },
            },
          ],
        },
      },
    }],
  },
});

However, it appears to have some issues. I encountered a

TypeError: Cannot read property 'toLowerCase' of undefined

. This error is likely due to the presence of nested arrays or objects.

In addition, I came across

TypeMismatch: Expected foods.0.fruits to be of type object, instead found type object.

. When attempting to modify the schema in an effort to address this issue, it was not the solution.

This was observed in version 2.7.0.

typescript dynamoose

Answer 1

Answer №1

Resolution: Separate the nested schema into a distinct schema and reference it within the initial one.

const bananaSchema = new dynamoose.Schema({
  banana: {
    type: Object,
    schema: {
      size: String,
      type: String,
    },
  },
});

Subsequently, in the original schema:

        fruits: {
          type: Array,
          schema: [bananaSchema],
        },

Answer 2

Resolution: Separate the nested schema into a distinct schema and reference it within the initial one.

const bananaSchema = new dynamoose.Schema({
  banana: {
    type: Object,
    schema: {
      size: String,
      type: String,
    },
  },
});

Subsequently, in the original schema:

        fruits: {
          type: Array,
          schema: [bananaSchema],
        },

Answer 3

Answer №2

Consider an alternative approach by modifying your schema to the following structure:

export const FoodsSchema = new dynamoose.Schema({
  foods: {
    type: Array,
    schema: [{
      type: Object,
      schema: {
        fruits: {
          type: Array,
          schema: [{
            type: Object,
            schema: {
              apple: {
                type: Object,
                schema: {
                  color: String,
                  shape: String,
              },
            },
          ],
        },
      },
    }],
  },
});

(Hopefully that is accurate).

In the previous fruits schema part, there was an array followed by apple:

schema: [
  apple: {

I may be mistaken, but that doesn't seem like valid JavaScript syntax.

The main idea is that you can achieve what you want within one schema. Alternatively, you could split it into smaller objects rather than schemas for simplicity.

As mentioned in another response, dividing it into schemas is also a viable option!

There are multiple approaches to solving this issue.

Answer 4

Consider an alternative approach by modifying your schema to the following structure:

export const FoodsSchema = new dynamoose.Schema({
  foods: {
    type: Array,
    schema: [{
      type: Object,
      schema: {
        fruits: {
          type: Array,
          schema: [{
            type: Object,
            schema: {
              apple: {
                type: Object,
                schema: {
                  color: String,
                  shape: String,
              },
            },
          ],
        },
      },
    }],
  },
});

(Hopefully that is accurate).

In the previous fruits schema part, there was an array followed by apple:

schema: [
  apple: {

I may be mistaken, but that doesn't seem like valid JavaScript syntax.

The main idea is that you can achieve what you want within one schema. Alternatively, you could split it into smaller objects rather than schemas for simplicity.

As mentioned in another response, dividing it into schemas is also a viable option!

There are multiple approaches to solving this issue.

Creating a TypeScript schema with nested maps and arrays using Dynamoose

Answer №1

Answer №2

Similar questions

Unable to retrieve the updated value from the service variable

Is it possible to utilize Webpack 5's ChunkGroup API with several entries?

The main module's postinstall process is initiated before the sub-module's postinstall process

Does having an excessive amount of variable declarations result in a noticeable decline in performance?

What's the best way to ensure you're linting the correct file type for importing in Web

"Put Jest to the test by running it with the Express

Support for ViewEncapsulation.ShadowDom now available in Edge, Internet Explorer, and legacy browsers

Looking for a button that can be toggled on and off depending on the input fields

Transferring documents from an angular ionic application to a slim php framework on the localhost

How can I call a method from a class using Typescript when getting an error saying that the property does not exist on the

Switching over to Typescript: Sending mapped properties

Having trouble with Angular 2's Output/emit() function not functioning properly

The HttpInterceptor is programmed to identify and capture 401 error responses

Customize the MUISelect style within a universal theme

The types for Cypress are not being detected by my Angular tsconfig file

Tips for preventing the need to cast a DOM element to any in Typescript

Angular 11 Working with template-driven model within a directive

The problem with the onClick event not triggering in Angular buttons

Conceal object from inventory upon clicking

I am interested in creating a class that will produce functions as its instances