microstates / lab
96%
master: 96%

LAST BUILD BRANCH: greenkeeper/monorepo.babel7-20200530201154
DEFAULT BRANCH: master
Repo Added
Files 10
Badge
Embed ▾
README BADGES
x

If you need to use a raster PNG badge, change the '.svg' to '.png' in the link

Markdown

Textile

RDoc

HTML

Rst

LAST BUILD ON BRANCH cl/linker-architecture
branch: cl/linker-architecture
CHANGE BRANCH
x

29

Pull #10

travis-ci-com

web-flow 
Abstract Relationships

We've introduced a very, very low-level linking functionality to have
a microstate draw its value from anywhere in the tree. However, what's
lacking is a way to declaratively state from within the microstate
what those links _are_ and where they go.

So, for example in the BigTest network ORM, we want to be able to say:

```js

import { belongsTo } from '@bigtest/network';

class Blog {
  title = String;
  author = belongsTo(Person);
}
```

and for it to link to the correct person.

To accomplish this, we introduce the concept of a relationship which
is just an abstraction over a Type and a path. Every reference from
one microstate to another is now reconceived as a relatioship.

It's not that complicated though. A relationship is really just a
function that takes the holder object, it's type, it's path, and the
name of the relationship and returns a `{ Type, path }` pair that is
used for linking.

For example, the default relationship is `Child` and is defined as:

```js
function Child(spec) {
  return new Relationship(resolve);

  function resolve(origin, originType, path, name) {
    let Type = typeof spec === 'function' ? spec : typeOf(spec);
    return { Type, path: path.concat(name) };
  }
}
```

It's what implements the first line DSL.

`belongsTo`, which resolves to a different place in the store, could
be implemented like so:

```js
function belongsTo(Type) {
  return new Relationship(resolve);

  function resolve(object, objectType, path, name) {
    let tableName = pluralize(Type.name.toLowerCase());
    let id = valueOf(this)[`${name}Id`];
    return { Type, path: path.slice(-3).concat([tableName, "records", id]) };
  }
}
```

this assumes a layout of the DB like:

```json
{
  blogs: {
    nextId: 2,
    records: {
      0: { title: 'How to blog', authorId: 'id1' },
      1: {
        title: 'How to build a fully immutable directed cyclic graph in javascript',
        authorId: '0'
      }
    }
  },
  people: {
   ... (continued)
Pull Request #10: Abstract Relationships

53 of 60 branches covered (88.33%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 5 files covered. (100.0%)

164 of 166 relevant lines covered (98.8%)

182.23 hits per line

Relevant lines Covered
166 RELEVANT LINES 164 COVERED LINES
182.23 HITS PER LINE
Source Files on cl/linker-architecture
Coverage ∆ File Lines Relevant Covered Missed Hits/Line Branch Hits Branch Misses

Recent builds

Builds Branch Commit Type Ran Committer Via Coverage
29 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... Pull #10 web-flow travis-ci-com pending completion  
27 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... Pull #10 web-flow travis-ci pending completion  
28 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... push cowboyd travis-ci-com pending completion  
26 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... push cowboyd travis-ci pending completion  
16 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... Pull #10 web-flow travis-ci-com pending completion  
16 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... Pull #10 web-flow travis-ci pending completion  
15 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... push cowboyd travis-ci pending completion  
15 cl/linker-architecture Abstract Relationships We've introduced a very, very low-level linking functionality to have a microstate draw its value from anywhere in the tree. However, what's lacking is a way to declaratively state from within the microstate what those link... push cowboyd travis-ci-com pending completion  
See All Builds (389)