node-data-mapper

node-data-mapper in object-relational mapper for Node.js. It uses the data-mapper pattern.

What does it do?

It takes queries that look like this:

SELECT  bs.bikeShopID, bs.name, bs.address,
        s.staffID, s.firstName, s.lastName
FROM    bike_shops bs
INNER JOIN staff s ON bs.bikeShopID = s.bikeShopID
ORDER BY bs.name, s.firstName

and makes them look like this:

dataContext
  .from('bike_shops bs')
  .innerJoin('bs.staff s')
  .select(
    'bs.bikeShopID', 'bs.name', 'bs.address',
    's.staffID', 's.firstName', 's.lastName')
  .orderBy('bs.name', 's.firstName')

It maps relational, tabular data that look like this:

bikeShopID|name|address|staffID|firstName|lastName ---|---|---|---|---|--- 1|Bob's Bikes|9107 Sunrise Blvd|2|John|Stovall 1|Bob's Bikes|9107 Sunrise Blvd|1|Randy|Alamedo 1|Bob's Bikes|9107 Sunrise Blvd|3|Tina|Beckenworth 3|Cycle Works|3100 La Riviera Wy|7|Kimberly|Fenters 3|Cycle Works|3100 La Riviera Wy|8|Michael|Xavier 3|Cycle Works|3100 La Riviera Wy|5|Sal|Green 3|Cycle Works|3100 La Riviera Wy|6|Valerie|Stocking 2|Zephyr Cove Cruisers|18271 Highway 50|4|Abe|Django

to a normalized document like this:

[ { bikeShopID: 1,
    name: 'Bob\'s Bikes',
    address: '9107 Sunrise Blvd',
    staff: 
     [ { staffID: 2, firstName: 'John', lastName: 'Stovall' },
       { staffID: 1, firstName: 'Randy', lastName: 'Alamedo' },
       { staffID: 3, firstName: 'Tina', lastName: 'Beckenworth' } ] },
  { bikeShopID: 3,
    name: 'Cycle Works',
    address: '3100 La Riviera Wy',
    staff: 
     [ { staffID: 7, firstName: 'Kimberly', lastName: 'Fenters' },
       { staffID: 8, firstName: 'Michael', lastName: 'Xavier' },
       { staffID: 5, firstName: 'Sal', lastName: 'Green' },
       { staffID: 6, firstName: 'Valerie', lastName: 'Stocking' } ] },
  { bikeShopID: 2,
    name: 'Zephyr Cove Cruisers',
    address: '18271 Highway 50',
    staff: [ { staffID: 4, firstName: 'Abe', lastName: 'Django' } ] } ]

Why should I use it?

• It's fast.
• The code is well documented and thoroughly tested.
• Tutorials and documentation help you to get started quickly.
• It works well with existing projects and databases.
• The query interface is intuitive and closely resembles SQL.
• Unlike other ORMs, there's no need to define models.
• Queries use plain ol' JavaScript objects and arrays.
• Security concerns like SQL injection are covered.
• CRUD operations can be reused. Create a select query, and use the same query for updates and deletes.
• It lets you easily create queries that can be filtered and ordered dynamically.
• There are hooks for global conversions and transformations, like normalizing dates and formatting phone numbers.
• Database modifications show up immediately. If you add a column to the database, you don't have to change any code.
• It eliminates incosistent property names, which is a common problem in APIs.

How do I get started?

Go check out the tutorials!

Table of Contents

• Getting Started
  • Example Database Setup
  • Installing and Connecting
• Selecting
  • Select all from a Single Table
  • Limiting Columns
  • Ad-Hoc Mapping
  • Ordering
  • Ad-Hoc Converters
  • Conditions I
  • Conditions II
  • Joins
• Inserting
  • Create a Single Model
  • Create Multiple Models
• Deleting
  • Delete a Single Model
  • Delete Multiple Models
  • Delete Using a From Instance
• Updating
  • Update a Single Model
  • Update Multiple Models
  • Updating Using a From Instance
• Schema Objects (Global Property Names and Conversions)
  • Schema Generation Overview
  • Customizing Names (Mapping)
  • Converters