Fortune.js is a library for managing data in Node.js and web browsers. It consists of a data abstraction layer and networking functions.

View the website for documentation. Get it from npm:

$ npm install fortune --save

Synopsis

Fortune.js facilitates sharing data between client and server by sharing most of the same code. The core is a data abstraction layer, which provides querying, persistence, type validation, relationships, and business logic isolation.

The included networking functions provide a basis for implementing application-level protocols, including media types such as Micro API and JSON API, standard input formats such as URL encoded and form data, and also includes its own wire protocol based on Websocket and MessagePack.

Example

The only necessary input is record type definitions. Here's a model of a basic micro-blogging service:

const fortune = require('fortune')

const store = fortune({
  user: {
    name: { type: String },

    // Following and followers are inversely related (many-to-many).
    following: { link: 'user', inverse: 'followers', isArray: true },
    followers: { link: 'user', inverse: 'following', isArray: true },

    // Many-to-one relationship of user posts to post author.
    posts: { link: 'post', inverse: 'author', isArray: true }
  },
  post: {
    message: { type: String },

    // One-to-many relationship of post author to user posts.
    author: { link: 'user', inverse: 'posts' }
  }
})

By default, the data is persisted in memory. There are adapters for databases such as MongoDB, Postgres, and NeDB. To make a request internally:

store.request({
  type: 'user',
  method: 'create',
  payload: [ { name: 'John Doe' }, { name: 'Jane Doe' } ]
})

The first call to request will trigger a connection to the data store, and it returns the result as a Promise.

Then let's add a HTTP server:

const http = require('http')

// The `fortune.net.http` helper function returns a listener function which
// does content negotiation, and maps the internal response to a HTTP response.
const server = http.createServer(fortune.net.http(store))

store.connect().then(() => server.listen(1337))

This yields an ad hoc JSON over HTTP API. There are serializers for Micro API (JSON-LD) and JSON API, which also accept HTTP parameters. In addition, Fortune.js implements a wire protocol based on WebSocket and MessagePack.

See the plugins page for more details.

Features and Non-Features

• Type validations, with support for custom types.
• Application-level denormalized inverse relationships.
• Dereferencing relationships in a single request.
• Isomorphic, backed by IndexedDB in web browsers, including a built-in wire protocol for data synchronization.
• No active record pattern, just plain data objects.
• No coupling with network protocol, they are treated as external I/O.

Requirements

Fortune.js is written in ECMAScript 5.1 syntax, with some ECMAScript 6 additions.

• Promise (ES6): not supported in IE, supported in Edge. Bring your own implementation (optional).
• WeakMap (ES6): supported in IE11+, Edge. Polyfills exist, but they have their shortcomings since it must be implemented natively.

License

This software is licensed under the MIT license.