0.3.0 • Public • Published


    Entity relationship automation for AngularJS.

    npm version npm downloads Build Status

    What does it do?

    You define collections and the relationships between them:

    A shopping app has customers
    Each customer has multiple orders
    Each order has multiple items
    db.collection('customer', ['name', 'email'])
    db.collection('order', ['value', 'status'])
    db.collection('item', ['description', 'price'])
    db.oneToMany('customer', 'order')
    db.oneToMany('order', 'item')
    // This is a simple example, you can do much more

    From this SneakerJS will:

    A) Generate specially named functions for you to work with

    These are all generated based on the names of your collections:

    db.newCustomer({name: 'joe', email: ''})
    db.newOrder({value: 100, customer: customer})
    db.getCustomerOrders(customer) // Return all the customer's orders
    db.deleteItem(order)           // Delete an order and its items
    db.deleteItem(customer)        // Delete a customer, his orders and their items

    This makes writing your app very intuitive and fast.

    B) Take care of storing your data

    If using PouchDB (which can also connect to CouchDB) then your data will automatically be persisted in a structure which works well for single-user apps.

    You don't need to worry about foreign keys for one-to-many joins, or dedicated collections for many-to-many joins. In fact you don't need to do anything other than define your collections and start using the functions (See this Plunkr)

    If you'd rather have control over your backend, or use data from another API altogether, no problem! There is an easy way to intercept the CRUD calls, so you can use SneakerJS in the front-end with any API you like at the back-end (see User Guide)

    C) Map all the relationships in memory for lightening fast performance

    SneakerJS loads the full data at startup and replicates changes to the database (currently no provision for synchronising changes from the db to client, you have to do that manually, but it's in the pipeline)

    It also caches every relationship bi-directionally.

    E.g for a one-to-many relationship between customer and order, it stores the array of orders for each customer, and a reference to the customer against each order, and keeps these updated.

    While this may seem trivial, caching relationships in this way can make an application which has many joins between it's collections go over 100 times faster than using map-reduce joins (yes, I've measured this before).

    What this means it that you can design your collections in a highly normalised relational form and probably not have to worry about performance. Let that sink in for a bit ;-)

    What else?

    SneakerJS takes care of the angular digest loop so you don't have to $scope.$apply() everywhere. Just call the generated functions and changes will be reflected in the UI once they are confirmed by the database (so it's a bit like firebase but in many cases much faster, and free!)

    SneakerJS also lets you:

    • Specify constructor functions to initiate collection items, effectively making SneakerJS a mini ORM.
    • Define many-to-many relationships without setting up special tables/collections
    • Use aliases to allow multiple same type relationships between collections


    Here is a simple Plunkr. There is also a demo project included.


    npm install sneakerjs --save

    User Guide

    Yes, there is a complete user guide!

    Reporting bugs

    Please report any issues in the issue tracker.

    Running test

    Tests written in Jasmine, run with karma, and code coverage checked with istanbul.

    npm test

    Of course, it uses karma-nicer-reporter ;-)




    npm i sneakerjs

    DownloadsWeekly Downloads






    Last publish


    • avatar