DEV Community: Riko

Using Marshmallow `Method` Fields for Complex Nested Schemas in Flask

Riko — Fri, 13 Mar 2026 12:37:01 +0000

Introduction

I made an habit tracking journal app where users can write entries about their habit loops. A habit loop consists of a trigger or cue, a behavior, and a result. For privacy reasons and a clean database design, triggers are related to a user, while behaviors are available to all users. Users can write entries that have one trigger and one behavior. A user's entries are still private to them through the trigger.

I wanted an API response that returns all of a user's data with nested schemas. Due to the model relationships, there can be two hierarchical views of the same data:

User > Trigger > Behaviors > Entries
User > Behavior > Triggers > Entries

So the API response needs to:

List triggers with their related behaviors and only the entries that belong to both the trigger and behavior.
List behaviors with their related triggers and those same filtered entries.
Include user-specific filtering to only show relevant triggers and behaviors: a user should not see behaviors, triggers, or entries that are not their own.

Marshmallow’s Schema and Nested fields are great, but these can't easily handle multiple levels of nesting that enforce a particular context. Enter Marshmallow’s Method fields which allow you to shape complex nested data exactly how you want it.

My Solution: Marshmallow `Method` Fields with Context

The key was to use ma.Method fields inside my Marshmallow schemas. These let you define your own methods that compute whatever data you want when serializing.

Step 1: Create schemas for the base models — Entry, Trigger, Behavior

Each has basic auto fields for their core attributes.

class EntrySchema(ma.SQLAlchemySchema):
    class Meta:
        model = Entry
        load_instance = True
    id = ma.auto_field()
    description = ma.auto_field()
    # ... other fields

Step 2: Build nested schemas that include filtered related entries

For example, NestedTriggerSchemaWithEntries represents a trigger but also includes entries filtered by behavior. To achieve this filtering, I pass the parent behavior object via context so the method knows which entries to include:

class NestedTriggerSchemaWithEntries(ma.SQLAlchemySchema):
    # Schema for Behavior, Nested Trigger, and Entries associated with both
    class Meta:
        model = Trigger
        load_instance = True
    id = ma.auto_field()
    name = ma.auto_field()
    description = ma.auto_field()
    user_id = ma.auto_field()

    entries = ma.Method("get_entries_for_behavior")

    def get_entries_for_behavior(self, trigger_obj):
        # Get entries that match this trigger and its parent behavior from context. 
        behavior_obj = self.context.get("behavior")
        if not behavior_obj or not trigger_obj:
            return []

        filtered_entries = [e for e in trigger_obj.entries
                            if e.behavior_id == behavior_obj.id
                            and e.trigger_id == trigger_obj.id]
        return entries_schema.dump(filtered_entries)

This method filters entries for the trigger but only those tied to the current behavior.

Step 3: Connect it all in top-level schemas

In your BehaviorSchema, you can include a triggers field that uses the nested trigger schema above, passing the parent behavior in context:

class BehaviorSchema(ma.SQLAlchemySchema):
    class Meta:
        model = Behavior
        load_instance = True

    id = ma.auto_field()
    name = ma.auto_field()
    description = ma.auto_field()
    type = ma.auto_field()

    triggers = ma.Method("get_nested_trigger_entries")

    def get_nested_trigger_entries(self, behavior_obj):
        # Gets triggers with entries that match the parent behavior
        if behavior_obj is None or behavior_obj.triggers is None:
            return []
        triggers = []
        for trigger in behavior_obj.triggers:
            if trigger is None:
                continue
            if trigger.user_id != current_user.id:
                continue
            # Instantiate nested triggers with entries schema, passing the behavior as context
            schema = NestedTriggerSchemaWithEntries(context={"behavior": behavior_obj})
            triggers.append(schema.dump(trigger))
        return triggers

behavior_schema = BehaviorSchema()
behaviors_schema = BehaviorSchema(many=True, exclude=('triggers',))

The same pattern applies in reverse with NestedBehaviorSchemaWithEntries inside your TriggerSchema.

class NestedBehaviorSchemaWithEntries(ma.SQLAlchemySchema):
    # Schema for Trigger, Nested Behavior, and Entries associated with both
    class Meta:
        model = Behavior
        load_instance = True

    id = ma.auto_field()
    name = ma.auto_field()
    description = ma.auto_field()
    type = ma.auto_field()

    entries = ma.Method("get_entries_for_trigger")

    def get_entries_for_trigger(self, behavior_obj):
        # Gets entries that match this behavior and its parent trigger from context. Current user should already match the trigger.
        trigger_obj = self.context.get("trigger")
        if not trigger_obj:
            return []
        if behavior_obj is None:
            return []
        filtered_entries = [e for e in behavior_obj.entries
                            if e.trigger_id == trigger_obj.id
                            and e.behavior.id == behavior_obj.id]
        return entries_schema.dump(filtered_entries)


class TriggerSchema(ma.SQLAlchemySchema):
    class Meta:
        model = Trigger
        load_instance = True

    id = ma.auto_field()
    name = ma.auto_field()
    description = ma.auto_field()
    user_id = ma.auto_field()
    behaviors = ma.Method("get_nested_behavior_entries")

    def get_nested_behavior_entries(self, trigger_obj):
        # Gets behaviors that match the user and parent trigger
        if trigger_obj is None or trigger_obj.behaviors is None:
            return []
        behaviors = []
        for behavior in trigger_obj.behaviors:
            if behavior is None:
                continue
            # Instantiate nested behaviors with entries schema, passing trigger as context
            schema = NestedBehaviorSchemaWithEntries(context={"trigger": trigger_obj})
            behaviors.append(schema.dump(behavior))
        return behaviors

trigger_schema = TriggerSchema()
triggers_schema = TriggerSchema(many=True)

Step 4: Nest the trigger and behavior schemas in User schema

Finally, these schemas are then used in User schema with ma.Nested. This ensures that API requests to login and get current user will return all of the user's data in one response:

class UserSchema(ma.SQLAlchemySchema):
    class Meta:
        model = User
        load_instance = True

    id = ma.auto_field()
    username = ma.auto_field()
    triggers = ma.Nested(triggers_schema)
    behaviors = ma.Nested(BehaviorSchema, many=True, attribute="behaviors")

Benefits of this Approach

Fine-grained control: Instead of blindly dumping related fields, I control exactly which entries appear, filtered by multiple criteria.
Reusability: These nested schemas can be composed and reused wherever needed.
Context-aware: Passing objects through context is a powerful way to carry filtering criteria down the nested serialization chain.
Flask-Login aware: I can easily integrate user-based filtering right in the methods.

Conclusion

Marshmallow’s Method fields are a lifesaver when you need multi-layered nested JSON responses that must adhere to a specific user's context. They let you write custom logic to filter, transform, and enrich your data exactly how your frontend needs it.

Understanding Database Relationships in Flask-SQLAlchemy: `db.relationship` and `association_proxy`

Riko — Sat, 25 Oct 2025 14:24:34 +0000

Modeling relationships between tables is essential for representing data's real-world connections. Flask-SQLAlchemy provides two constructs to manage relationships: db.relationship and association_proxy.

There are three types of database relationships:

One-to-many: One parent, many children
One-to-one: One parent, one child
Many-to-many: Many parents relate to many children

In this blog, I'll demonstrate how db.relationship and association_proxy are used in a database that has Meditations, Users, and Meditation Sessions.

A user has many meditations through meditation sessions
A meditation session has one meditation and one user
A meditation has many users through meditation sessions

Here is the Python code with each class model and their relationships, including foreign key columns and serialize rules to prevent recursion:

class Meditation(db.Model, SerializerMixin):
    __tablename__ = "meditations"


    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String)
    duration = db.Column(db.Integer)
    instructions = db.Column(db.String)

    meditation_sessions = db.relationship('MeditationSession', back_populates='meditation', cascade='all, delete-orphan')

    users = association_proxy('meditation_sessions', 'user', creator=lambda user_obj: MeditationSession(user=user_obj))

    serialize_rules = ('-users.meditations', '-meditation_sessions.meditation',)


class User(db.Model, SerializerMixin):
    __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, unique=True, nullable=False)
    _password_hash = db.Column(db.String)

    meditation_sessions = db.relationship('MeditationSession', back_populates='user', cascade='all, delete-orphan')

    meditations = association_proxy('meditation_sessions', 'meditation', creator=lambda meditation_obj: MeditationSession(meditation=meditation_obj))

    serialize_rules = ('-meditations.users', '-meditation_sessions.user')

class MeditationSession(db.Model, SerializerMixin):
    __tablename__ = "meditation_sessions"

    id = db.Column(db.Integer, primary_key=True)
    completed_duration = db.Column(db.Integer)
    rating = db.Column(db.Integer)
    session_note = db.Column(db.String)

    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
    meditation_id = db.Column(db.Integer, db.ForeignKey('meditations.id'))

    user = db.relationship('User', back_populates='meditation_sessions')
    meditation = db.relationship('Meditation', back_populates='meditation_sessions')

    serialize_rules = ('-meditation.meditation_sessions', '-user.meditation_sessions')

`db.relationship`: establishing bi-directional relationships

db.relationship defines how tables or models relate to one another in Python objects. It works alongside foreign keys to create clear links and enable convenient querying and data manipulation.

Let's break down the relationship between a User and Meditation Session.

For a session, the relationship to a user is:
user = db.relationship('User', back_populates='meditation_sessions')

Since a meditation session has only one user, the name of the property is singular
The first argument passed to db.relationship is the target model class name (User)
back_populates is the name of the reciprocal relationship property on the User model (meditation_sessions)

Inversely, a user's relationship to a meditation session is:
meditation_sessions = db.relationship('MeditationSession', back_populates='user', cascade='all, delete-orphan')

Since a user can have many meditation sessions, the name of the property is plural
The first argument is the target model class name (MeditationSession)
And back_populates points back to the user relationship property we defined in Meditation Session, enabling a bidirectional link between the two models
cascade specifies how SQLAlchemy will handle child objects if the parent object were to disappear. There are several options that can be passed:
- all is a combination of save-update, merge, and delete, meaning the child meditation sessions will be added to the database session, merged if the session contains duplicate objects, and deleted if the parent object is deleted
- delete-orphan will delete a child if it is disassociated from its parent, meaning if a meditation session is removed from user.meditation_sessions, the meditation session will be deleted

`association_proxy`: establishing Many-to-Many relationships

association_proxy is a construct that allows a class to reach across an intermediary class in a many-to-many relationship. In our model, a user can have many meditations through meditation sessions, and a meditation can have many users through meditation sessions. Meditation Session is the intermediary class between Users and Meditations.

Let's break down the association proxy between User and Meditation.

For a user, the association to meditation is:
meditations = association_proxy('meditation_sessions', 'meditation', creator=lambda meditation_obj: MeditationSession(meditation=meditation_obj))

Since this is a many-to-many relationship, the property name is plural (meditations)
The first argument passed to association_proxy specifies the relationship property we defined above with db.relationship and intend to use as a connector (meditation_sessions)
The second argument (meditation) indicates the name of the model we're connecting to
The creator parameter takes a function (an anonymous lambda in this case), which accepts an object of the other independent class and returns the corresponding object of the connecting class that made the connection possible
- The lambda function creates a new intermediary MeditationSession object when a Meditation is added to the meditations association proxy
- meditation_obj is an instance of the Meditation model passed in by the association_proxy
- MeditationSession(meditation=meditation_obj) creates a new MeditationSession object and sets its meditation relationship to that meditation_obj
- This new MeditationSession instance acts as the link or bridge between the User and the Meditation

Understanding when to use list comprehensions vs generator expressions

Riko — Mon, 11 Aug 2025 12:20:37 +0000

List Comprehensions

List comprehensions create new lists by transforming or filtering items from another iterable (such as a dictionary, tuple, or another list). They can be read as "do this operation for each item in this collection (and sometimes, only if this condition is true)".

The syntax looks like this:

[operation(item) for item in iterable if condition(item)]

List comprehensions are useful if you need to reuse and access these lists in your code.

List Comprehension with Simple Condition

Let's say I want a list representing books I haven't read yet in my personal library. I can use a list comprehension with a simple condition:

unread_books = [book for book in books if book.status == "to_read"]

Here, the list comprehension does not perform any operation on the individual book; it is only checking if the book's status is "to_read".

List Comprehension with Function Call

What if I want to ensure that my book titles are consistently capitalized? I can use a list comprehension that calls a function on each book title:

def fix_title(title):
    return title.strip().title()

book_titles = ['  war and peace', 'the HOBBIT ', '  dune']

cleaned_titles = [fix_title(t) for t in book_titles]
print(cleaned_titles)
# Output: ['War And Peace', 'The Hobbit', 'Dune']

List Comprehension with a more complex condition

Let's say I want all the titles of books that are longer than 300 pages AND I've already read:

finished_long_books = [
    book.title for book in books 
    if book.status == "finished" and book.page_count > 300
]

Generator Expressions

Generator expressions have a similar syntax as list comprehensions, but instead of creating a list, they produces items or values one at a time instead of storing a full list. This is useful if you're working with very large datasets and need to iterate over them only once.

Using generator expressions to sum values

Let's say I want to get a sum of all the pages I've read in my library:

total_pages_read = sum(book.page_count for book in books if book.status == "finished")

Note that the generator expression is passed to sum(), which adds each book's page count together if the book's status is "finished".

Using generator expressions to print values

Let's say I just want to print the names of the authors of the books I'm currently reading and don't need to store these as a separate list:

print(*(f"{book.author}" for book in books), sep="\n")

The generator expression is passed to print() as the first argument, which uses the unpacking operator * to print each author's name. The second argument is the separator that prints each name on a newline. This removes the need to use a for loop, iterating and printing over the authors in a single line.

Summary

List comprehensions create lists that can be reused and access in your code.

Generator expressions create generator objects that produce one value at a time, using less memory than a list.

Validating React Form Fields with State

Riko — Sat, 24 May 2025 17:08:06 +0000

The Problem: State updates are asynchronous

When validating controlled forms in React, a common mistake is expecting state updates (like setErrors) to happen immediately within the same function that validate the form fields. React state updates are asynchronous, so if you call setErrors inside your validation function, the updated errors state will not be immediately available to check in the submit handler.

Assume we have a controlled form for a user to subscribe to your app, which requires the user's name and email, as well as error state to check whether the form is completely filled:

function Form() {
  const [formData, setFormData] = useState({
    name: "",
    email: "",
  });

  const [errors, setErrors] = useState([]);

To handle error validation for the name and email fields, here is an example of a problematic pattern:

function handleErrors() {
  const tempErrors = [];

  if (formData.name === "") {
    tempErrors.push("Name is required.");
  }
  if (formData.email === "") {
    tempErrors.push("Email is required.");
  }

  setErrors(tempErrors); // This state update is asynchronous
}

function handleSubmit(event) {
  event.preventDefault();

  handleErrors();

  // Immediately checking `errors` state here is unreliable due to async update
  if (errors.length === 0) {
    // This will run even if errors were found
    console.log("no errors, submitting form");
    // proceed with submission...
  } else {
    console.log("errors found", errors);
  }
}

Because setErrors updates state asynchronously, the errors state inside handleSubmit will not reflect the latest errors immediately after calling handleErrors(). As a result, the form might submit even if validation fails.

The Solution: Return Errors and Control Flow Synchronously

Refactor your validation function to return the error list instead of setting state internally, then in handleSubmit decide whether to proceed or display errors.

function handleErrors() {
  const tempErrors = [];

  if (formData.name.trim() === "") {
    tempErrors.push("Name is required.");
  }
  if (formData.email.trim() === "") {
    tempErrors.push("Email is required.");
  }

  return tempErrors; // Return errors synchronously
}

function handleSubmit(event) {
  event.preventDefault();

  //reset stale errors from previous submit
  setErrors([])

  //get errors synchronously
  const tempErrors = handleErrors();

  if (tempErrors.length === 0) {
    console.log("no errors");
    fetch("http://localhost:3000/users", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(formData)
    })
    .then(r => r.json())
    .then(data => {
      console.log("Form submitted:", data);
      // Update UI or add new data to parent component state here...
    });
    // reset form data
    setFormData({
      name: "",
      email: ""
    });

  } else {
    console.log("errors found on submit", tempErrors);
    setErrors(tempErrors); // Update error state to display messages
  }
}

Summary

Return Errors from handleErrors: This provides immediate access to validation results.
Use Returned Errors in handleSubmit: You can synchronously decide whether to proceed or not.
Set Errors State Only After Decision: This avoids race conditions caused by asynchronous state updates.
This pattern ensures form validation and submission logic are reliable and user feedback occurs as expected.

Handling form validation in React requires understanding that state updates like setErrors are asynchronous and won’t reflect immediately. To avoid premature form submission despite validation errors, perform validation synchronously by returning errors from your validation function. Then, use these returned errors in your submit handler to decide whether to proceed or display error messages. This approach ensures reliable validation flow and a better user experience in React forms.

A beginner's guide to the Array .map and .reduce methods

Riko — Mon, 03 Mar 2025 13:43:21 +0000

Introduction

JavaScript's Array iterator methods .map and .reduce were some of the more confusing things to learn as a new JavaScript programmer. In this blog I walk through each method and explain how to use them. As a beginner myself, I hope to demonstrate my own learning and help other beginners who may also struggle to understand these methods.

I'll use an array of students where each student object has keys studentId, name, age, score, and classes (an array of Class IDs the student is enrolled in).

const students = [
  { id: "A001", name: "Alice", age: 22, gpa: 4.0, classes: ["C101", "C102", "C103"] },
  { id: "B002", name: "Bob", age: 24, gpa: 3.5, classes: ["C101", "C104"] },
  { id: "C003", name: "Charlie", age: 23, gpa: 3.6, classes: ["C102", "C105"] },
  { id: "D004", name: "David", age: 25, gpa: 2.9, classes: ["C103", "C106"] },
  { id: "E005", name: "Eve", age: 21, gpa: 3.0, classes: ["C104", "C105", "C106"] }
];

.map()

Description: iterates over an array and applies a callback function to each element, modifying them in some way
Arguments: a callback function
Returns: a new array with the elements that have been modified by the callback function

Use `.map` to create a new array using an object key

.map makes it super quick to get a list of particular values from an array of objects using a key. For example, we can use .map to get a list of studentIds

const studentIds = students.map(student => student.id)
//[ 'A001', 'B002', 'C003', 'D004', 'E005' ]

This uses a function expression with an implicit return. This is basically saying, for each student, get their ID, and return the ID to the new studentIds array.

Use `.map` to create a new array of objects with additional data

We can also use map to get create a new list of students with their IDs and the count of classes they are enrolled in, based on the length of the nested classes array.

const studentClassCount = students.map(student => {
    return {
        id: student.id,
        countOfClasses: student.classes.length
    }
})
/*
LOG: [
{ id: 'A001', countOfClasses: 3 },
{ id: 'B002', countOfClasses: 2 },
{ id: 'C003', countOfClasses: 2 },
{ id: 'D004', countOfClasses: 2 },
{ id: 'E005', countOfClasses: 3 }
]
*/

Because this use of .map is constructing new objects, the anonymous function that's passed to .map has to explicitly return each object with the student id and the new countOfClasses key that gets the length of each student's nested classes array.

.reduce()

Description: iterates over an array and applies a function to each element and calculates a single value
Arguments: a callback function (which can have 3 arguments) and an initial value to start
Returns: A single value (such as a string, integer, boolean, or another object/array)

Reduce is helpful for calculating a single value from an array, such as a string, integer, boolean, or another object/array. But its argument structure can be difficult to understand. Let's break it down:

The first argument is a callback function, and this function itself can have three arguments:

An accumulator (sometimes abbreviated as accum or acc), which is the value that will be added to (or accumulated) with each iteration over the array, and it will be passed into the next iteration. This accumulator will be the thing that is returned by reduce once the entire array has been iterated over with the callback function.
A current value (sometimes written as value), which will represent each array element as it is passed to the callback function
An index, an optional argument that indicates which index in the array for the function to start at. If this is not provided, the callback function will start with index 0 by default (the first element in the array).

An initial value to start with, such as 0 if you're calculating a numeric value, or an object/array. Objects can be empty, but you can include new keys if needed.

To demonstrate .reduce and these arguments, let's use a simple array of numbers and sum them together.

const numbers = [1, 2, 3];
const sum = numbers.reduce((acc, value, index) => {
    console.log(`Index: ${index}, Accumulator: ${acc}, Value: ${value}`);
    return acc + value;
}, 0);

/* LOG:
Index: 0, Accumulator: 0, Value: 1
Index: 1, Accumulator: 1, Value: 2
Index: 2, Accumulator: 3, Value: 3
*/

console.log(sum)
//LOG: 6

We call reduce on the numbers array, and pass an arrow callback function that has 3 arguments: acc, value, `index
The callback function does 2 things for each iteration: it first console logs each of the arguments, and it returns the sum of acc and value
After the callback function, note that 0 is provided as the second argument to .reduce. This is the initial value of acc that the sum will start with.
In the first iteration, the index starts at 0, the acc is 0 (the initial value provided as second argument to .reduce), and the current value is the first element in the array: 1
The callback function returns acc + value, or 0 + 1 which equals 1.
1 is then passed into the second iteration as the acc. The index is now 1, accumulator is 1, and the next array value in the array is now 2
This repeats for each element in the array.
sum ultimately returns 6 as the sum of 1 + 2 + 3

Now let's return to our students example and see what we can do with .reduce.

Use reduce to calculate a single value

If we wanted to calculate an average GPA for our set of students, we can use .reduce to get the total GPA which can then be used to calculate an average.

`javascript
const totalGPA = students.reduce((accumulator, student) => {
return accumulator + student.gpa;
}, 0);
const averageGPA = totalGPA / students.length;

//LOG: Total GPA: 17
//LOG: Average GPA: 3.4
`

Use reduce to create a new object

We want to categorize our students based on their GPA scores. To do this, we'll want to loop through each student's GPA and determine where each GPA falls in our categories.

`javascript
const gpaCategories = students.reduce((accumulator, student) => {
let category;
if (student.gpa === 4.0) {
category = "4.0";
} else if (student.gpa >= 3.5) {
category = "3.5-3.9";
} else if (student.gpa >= 3.0) {
category = "3.0-3.4";
} else {
category = "below 3.0";
}

if (!accumulator[category]) {
accumulator[category] = [];
}

accumulator[category].push(student.name);
return accumulator;
}, {});
`

The callback function uses if/else statements to determine the category in which each GPA falls. The second if statement creates the category keys in the accumulator object after checking whether the category key already exists.

Then each student name is pushed into the category key according to their GPA.

This will return a new object:

javascript { '4.0': [ 'Alice' ], '3.5-3.9': [ 'Bob', 'Charlie' ], 'below 3.0': [ 'David' ], '3.0-3.4': [ 'Eve' ] }

Conclusion

In this blog I demonstrated how .map and .reduce can be used, providing a break down of each method's arguments and inner workings. .map is a powerful and concise method for creating new arrays of modified elements, while .reduce can derive a single calculated value or object/array.

Happy learning!

DEV Community: Riko

Using Marshmallow `Method` Fields for Complex Nested Schemas in Flask

Introduction

My Solution: Marshmallow Method Fields with Context

Step 1: Create schemas for the base models — Entry, Trigger, Behavior

Step 2: Build nested schemas that include filtered related entries

Step 3: Connect it all in top-level schemas

Step 4: Nest the trigger and behavior schemas in User schema

Benefits of this Approach

Conclusion

Understanding Database Relationships in Flask-SQLAlchemy: `db.relationship` and `association_proxy`

db.relationship: establishing bi-directional relationships

association_proxy: establishing Many-to-Many relationships

Understanding when to use list comprehensions vs generator expressions

List Comprehensions

List Comprehension with Simple Condition

List Comprehension with Function Call

List Comprehension with a more complex condition

Generator Expressions

Using generator expressions to sum values

Using generator expressions to print values

Summary

Validating React Form Fields with State

The Problem: State updates are asynchronous

The Solution: Return Errors and Control Flow Synchronously

Summary

A beginner's guide to the Array .map and .reduce methods

Introduction

.map()

Use .map to create a new array using an object key

Use .map to create a new array of objects with additional data

.reduce()

Use reduce to calculate a single value

Use reduce to create a new object

Conclusion

My Solution: Marshmallow `Method` Fields with Context

`db.relationship`: establishing bi-directional relationships

`association_proxy`: establishing Many-to-Many relationships

Use `.map` to create a new array using an object key

Use `.map` to create a new array of objects with additional data