DEV Community: dotnet dev

Hey .NET Dev, Welcome to Node.js! A Guide to Data Access Beyond EF & OData

dotnet dev — Mon, 14 Jul 2025 14:16:57 +0000

So, you're a .NET developer stepping into the world of Node.js. You're comfortable, maybe even fluent, in the art of crafting elegant queries with Entity Framework Core. You can probably write LINQ in your sleep, and you appreciate how OData can magically expose your data models to the web with powerful querying capabilities.

Welcome! The good news is that the Node.js ecosystem has a rich and mature set of tools to give you a similar, if not identical, developer experience. The main difference? The "batteries-included" feel of .NET is replaced by a vibrant, open-source world where you choose the best tool for the job.

This post will serve as your Rosetta Stone for data access in Node.js, translating your EF Core and OData concepts to their Node.js equivalents.

The ORM Landscape: Finding Your EF Core Equivalent

In .NET, EF Core is the default Object-Relational Mapper (ORM). In Node.js, you have several excellent options, each with a slightly different philosophy. Let's look at the top contenders by trying to solve a common task:

The Goal: Fetch 10 users (skipping the first 5) who have at least one published post, order them by email, and include their post data in the results.

1. Prisma: The "Just-Like-LINQ" Experience

If you want the most seamless transition, start with Prisma. It's a modern, type-safe ORM that feels incredibly similar to writing LINQ. It uses a declarative schema file (schema.prisma) to define your models, and its auto-generated client provides a fully-typed, fluent API that makes querying a joy.

It’s clean, has fantastic autocompletion with TypeScript, and is the least verbose of the bunch.


// prisma.ts  
const users \= await prisma.user.findMany({  
  where: {  
    posts: {  
      some: {  
        published: true,  
      },  
    },  
  },  
  include: { // Similar to .Include()  
    posts: true,  
  },  
  orderBy: {   // Similar to .OrderBy()  
    email: 'asc',  
  },  
  take: 10,      // Similar to .Take()  
  skip: 5,       // Similar to .Skip()  
});

2. TypeORM: The Familiar Decorator Pattern

TypeORM will feel familiar to anyone who has used EF Core with attribute-based model configuration. It heavily uses decorators (@Entity, @column, @ManyToOne) to define your entities, just like you would in a C# class. Its QueryBuilder provides a powerful, LINQ-like method-chaining syntax.


// typeorm.ts  
const users \= await dataSource  
  .getRepository(User)  
  .createQueryBuilder("user")  
  .innerJoinAndSelect("user.posts", "post", "post.published \= :isPublished", { isPublished: true })  
  .orderBy("user.email", "ASC")  
  .skip(5)  
  .take(10)  
  .getMany();

3. Sequelize: The Veteran ORM

Sequelize is the most established ORM in the Node.js world. It's feature-rich, battle-tested, and supports a wide range of databases. Its approach relies less on fluent chaining for complex queries and more on passing configuration objects to its methods. This can feel a bit more verbose if you're coming directly from LINQ.


// sequelize.ts  
const users \= await User.findAll({  
  include: \[{  
    model: Post,  
    where: { published: true },  
    required: true // Enforces an INNER JOIN  
  }\],  
  order: \[  
    \['email', 'ASC'\]  
  \],  
  limit: 10,  
  offset: 5,  
  distinct: true // Ensures unique users are returned  
});

4. Knex.js: The "Dapper" of Node.js

Sometimes you don't want a full ORM. If you love the raw power and control of a tool like Dapper in .NET, then Knex.js is your go-to. It’s a SQL query builder, not an ORM. You get a fluent API to build raw SQL queries, which gives you maximum control at the cost of more boilerplate for tasks like mapping results to objects.


// knex.ts  
const users \= await knex('users')  
  .select('users.\*', 'posts.\*')  
  .innerJoin('posts', 'users.id', 'posts.userId')  
  .whereIn('users.id', function() {  
    this.select('userId').from('posts').where('published', true);  
  })  
  .orderBy('users.email', 'asc')  
  .limit(10)  
  .offset(5);

What About OData? Handling API Querying

In the .NET world, OData is a powerful framework for adding dynamic filtering, selecting, and paging directly from a URL (e.g., /users?$filter=name eq 'John').

The Node.js approach is typically more about composition, using smaller, focused libraries to achieve the same result. Instead of a single, all-encompassing framework like OData, you'll likely parse the URL query parameters yourself and use your ORM to build the database query.

A very popular library for this is qs, which can parse complex nested query strings. For a more structured approach, you might use a library like api-query-params, which is designed specifically to convert URL query strings into MongoDB query objects, but the principle can be adapted.

Example: Manual OData-style Filtering

Imagine a request to GET /users?filter[name]=John&sort=email&page=1&limit=20.

Your code would look something like this:

// In your Express.js controller  
import { parse } from 'qs';  
import prisma from './your-prisma-client';

app.get('/users', async (req, res) \=\> {  
  const query \= parse(req.query);

  const filter \= query.filter || {};  
  const sort \= query.sort || 'email';  
  const page \= parseInt(query.page) || 1;  
  const limit \= parseInt(query.limit) || 20;

  const users \= await prisma.user.findMany({  
    where: filter,  
    orderBy: { \[sort\]: 'asc' },  
    skip: (page \- 1) \* limit,  
    take: limit,  
  });

  res.json(users);  
});

This gives you full control over how your API behaves, though it requires more manual setup than dropping in the OData middleware.

Quick Comparison Table

Tool	Primary Paradigm	LINQ-like Feel	Verbosity	Best For...
Prisma	Modern ORM	Highest	Lowest	Developers wanting a seamless, type-safe, LINQ-like experience.
TypeORM	Decorator-based ORM	High (with QueryBuilder)	Low	Developers familiar with attribute/decorator-based entity configuration.
Sequelize	Traditional ORM	Medium	Medium	Projects needing a stable, feature-rich ORM with broad database support.
Knex.js	SQL Query Builder	Low	High	Developers who want full control over SQL, similar to Dapper.

Conclusion

Navigating the Node.js data access layer is an exercise in choice, which is both empowering and initially daunting.

If you want to feel right at home with a modern, LINQ-like experience, choose Prisma.
If you prefer the "code-first" decorator pattern of older EF versions, TypeORM is a solid bet.
If you want fine-grained control and love writing SQL, Knex.js will be your best friend.

Unlocking the Power of .NET 10: New Features and Enhancements

dotnet dev — Mon, 31 Mar 2025 15:21:56 +0000

.NET 10 introduces a suite of powerful features and enhancements that can significantly boost your application's performance and efficiency. Let's dive into some of the most notable improvements and how you can leverage them in your development work.

Enhancements to the ZipArchive Class

One of the standout features in .NET 10 is the enhancement to the ZipArchive class, which brings substantial performance and memory improvements. Here's what's new:

Optimized Update Mode: Previously, updating a file within a ZIP archive required loading the entire archive into memory, consuming significant resources. In .NET 10, file updates are handled more efficiently, reducing memory consumption.
Parallelized Extraction: The process of decompressing files from ZIP archives has been sped up through parallelization. Data is processed in parallel, and memory consumption has been optimized, making extraction faster and more efficient.

How You Can Use It

If your applications work with ZIP archives, you'll notice faster and more efficient handling of these files. Updating large files within a ZIP or extracting multiple files simultaneously will benefit from these improvements.

Benefits

Reduced Memory Consumption: Particularly noticeable when dealing with large or numerous ZIP archives.
Improved Performance: Faster ZIP update and extraction operations make your applications more responsive.

C# 14 Features

.NET 10 also introduces several new features in C# 14 that enhance productivity and code readability:

Field-backed Properties: Simplifies creating properties with custom getter/setter logic by allowing direct access to the compiler-generated backing field using the field keyword.

  public class MyClass
  {
      private int _myField;
      public int MyProperty
      {
          get => field; // Accessing the backing field
          set { field = Math.Max(0, value); }
      }
  }

Implicit Conversions for Span<T> and ReadOnlySpan<T>: Provides first-class language support for these types, allowing implicit conversions in more scenarios.
Unbound Generics in nameof: Obtain the name of an unbound generic type without specifying concrete type arguments.
Modifiers on Lambda Parameters: Add modifiers like ref, in, or out directly to lambda parameters for more concise expressions.

ASP.NET Core 10 Features

ASP.NET Core 10 brings several enhancements to web API development:

OpenAPI 3.1 Support: Generate OpenAPI documents conforming to the latest specification, with improved JSON Schema alignment.
Serving OpenAPI in YAML: Provides OpenAPI documentation in a more human-readable YAML format.

Blazor Enhancements

Blazor continues to evolve with new features in .NET 10:

ReconnectModal Component: A built-in way to handle UI during reconnections between the client and server.
QuickGrid Improvements: Supports the RowClass parameter for applying CSS classes to rows and CloseColumnOptionsAsync for programmatically closing column options.
Blazor Script as Static Web Asset: Improves performance through precompression and browser caching.

EF Core 10 Features

Entity Framework Core 10 introduces new capabilities for data access:

LeftJoin/RightJoin Operators: Simplifies writing LINQ queries involving these types of joins.
Improved ExecuteUpdateAsync: Accepts regular lambda expressions for specifying updates, making it more convenient to use.

Conclusion

.NET 10 brings a wealth of improvements across various domains, from language features to web API enhancements and framework updates for Blazor and EF Core. These features offer practical benefits that can significantly enhance your .NET development work.

Lateral Flattening of JSON Data in Python

dotnet dev — Mon, 27 Jan 2025 18:28:15 +0000

Introduction

Lateral flattening is the process of converting nested or hierarchical JSON structures into flat, tabular formats. Python’s pandas library provides powerful tools for this task, particularly the json_normalize function. This article explores how to use Python to explode arrays and flatten nested JSON data for use in analytics, databases, or machine learning pipelines.

JSON’s nested structure is ideal for web APIs and configuration files but becomes cumbersome for:

Relational databases (e.g., PostgreSQL, MySQL).
Tabular analysis tools (e.g., pandas, Excel).
Machine learning models (most require 2D input).

Flattening resolves nested keys and explodes arrays into rows or columns, enabling compatibility with these systems.

Python Implementation with `pandas`

Key Function: `json_normalize`

The pandas.json_normalize method recursively flattens nested JSON structures. Its parameters include:

data: The JSON input (dict or list of dicts).
record_path: The key containing the array to explode.
meta: Fields to preserve as metadata (e.g., id, name).
meta_prefix: A prefix for nested metadata keys (e.g., user_).

Example 1: Exploding a Simple Array

Input JSON:

{
  "id": 1,
  "name": "John Doe",
  "contactIds": [1, 2, 3, 4]
}

Python Code:

import pandas as pd

data = {
    "id": 1,
    "name": "John Doe",
    "contactIds": [1, 2, 3, 4]
}

# Explode the "contactIds" array into rows
df = pd.json_normalize(
    data,
    record_path="contactIds",  # Array to explode
    meta=["id", "name"],       # Fields to retain
    record_prefix="contactId_" # Optional: prefix for exploded values
)

print(df)

Output:

   id      name  contactId_
0   1  John Doe           1
1   1  John Doe           2
2   1  John Doe           3
3   1  John Doe           4

Example 2: Handling Nested Objects

For JSON with nested objects (e.g., address.street), json_normalize automatically concatenates keys:

Input JSON:

{
  "id": 1,
  "name": "John Doe",
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  }
}

Python Code:

df = pd.json_normalize(data)
print(df)

Output:

   id      name  address.street address.city
0   1  John Doe     123 Main St     Anytown

To rename columns:

df.columns = df.columns.str.replace(".", "_")

Example 3: Complex Nesting (Arrays of Objects)

For arrays containing nested objects, json_normalize combines key concatenation and array explosion:

Input JSON:

{
  "id": 1,
  "orders": [
    {"item": "A", "price": 10},
    {"item": "B", "price": 20}
  ]
}

Python Code:

df = pd.json_normalize(
    data,
    record_path="orders",  # Explode the "orders" array
    meta=["id"],           # Keep "id" as metadata
    meta_prefix="user_"
)

print(df)

Output:

  item  price  user_id
0    A     10        1
1    B     20        1

Advanced Customization

Handling Missing Data

Use the errors parameter to ignore or raise errors for missing fields:

pd.json_normalize(data, errors="ignore")  # Skip missing keys

Flattening Multiple Levels

For deeply nested JSON, combine json_normalize with recursive functions or custom logic.

Alternatives to `pandas`

flatdict Library: Lightweight flattening without dependencies.
Manual Recursion: Custom Python functions for edge cases.

When to Avoid Flattening

Preserving Hierarchy: Nested JSON is more efficient for tree-like data (e.g., organizational charts).
APIs: Clients often expect nested responses.

Footnotes

Use max_level in json_normalize to control flattening depth (e.g., max_level=2).
Flattened JSON may increase storage size due to duplicated metadata.

DEV Community: dotnet dev

Hey .NET Dev, Welcome to Node.js! A Guide to Data Access Beyond EF & OData

The ORM Landscape: Finding Your EF Core Equivalent

1. Prisma: The "Just-Like-LINQ" Experience

2. TypeORM: The Familiar Decorator Pattern

3. Sequelize: The Veteran ORM

4. Knex.js: The "Dapper" of Node.js

What About OData? Handling API Querying

Quick Comparison Table

Conclusion

Unlocking the Power of .NET 10: New Features and Enhancements

Enhancements to the ZipArchive Class

How You Can Use It

Benefits

C# 14 Features

ASP.NET Core 10 Features

Blazor Enhancements

EF Core 10 Features

Conclusion

Lateral Flattening of JSON Data in Python

Introduction

Python Implementation with pandas

Key Function: json_normalize

Example 1: Exploding a Simple Array

Example 2: Handling Nested Objects

Example 3: Complex Nesting (Arrays of Objects)

Advanced Customization

Handling Missing Data

Flattening Multiple Levels

Alternatives to pandas

When to Avoid Flattening

Footnotes

Python Implementation with `pandas`

Key Function: `json_normalize`

Alternatives to `pandas`