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

Encountering a Nuxt error where properties of null are being attempted to be read, specifically the 'addEventListener' property. As a result, both the default

Declare that a method alters a value with state

Divide the enhanced document into sections using TypeScript

Variable Scope is not defined in the TypeScript controller class of an AngularJS directive

Enhance the capabilities of a basic object by incorporating a superclass through the creation of

Setting the sidebar width for Nebular with two sidebars in the layout: A step-by-step guide

Divide a given number of elements within an array of arrays

Implementing an interface in TypeScript and assigning it a value using generics?

Typescript: The type 'T' fails to meet the requirement of being an 'object'

Issue with InversifyJS @multiInject: receiving an error stating "ServiceIdentifier has an ambiguous match"

Searching for a string within a JSON object in Angular: step-by-step guide

What is the reason behind Typescript not narrowing generic union type components when they are eliminated by type guards?

In TypeScript, Firestore withConverter may return a QueryDocumentSnapshot instead of the expected Class object

The property of userNm is undefined and cannot be set

The necessity of the second parameter, inverseSide property in TypeORM's configurations, even though it is optional

Node.js and Express: The error message "Cors is not a function"

Leverage the generic parameter type inferred from one function to dynamically type other functions

The error message is: "Cannot access property 'up' of an undefined object within the material UI library using theme.breakpoints."

Suggestions for enhancing or troubleshooting Typescript ts-node compilation speed?

What could be causing the issue with my customized sorting in the Material-UI Data Grid component?