yayson 2.1.0 → 3.0.0

package/src/yayson/legacy-store.js

@@ -0,0 +1,156 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+/*
+ * decaffeinate suggestions:
+ * DS101: Remove unnecessary use of Array.from
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS205: Consider reworking code to avoid use of IIFEs
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+
+module.exports = function () {
+  class Record {
+    constructor(options) {
+      this.type = options.type
+      this.data = options.data
+    }
+  }
+
+  return class Store {
+    constructor(options) {
+      this.types = options.types || {}
+      this.reset()
+    }
+
+    reset() {
+      this.records = []
+      return (this.relations = {})
+    }
+
+    toModel(rec, type, models) {
+      const model = {...rec.data}
+      if (!models[type][model.id]) {
+        models[type][model.id] = model
+      }
+
+      const relations = this.relations[type]
+      for (let attribute in relations) {
+        var relationType = relations[attribute]
+        model[attribute] =
+          model[attribute] instanceof Array
+            ? model[attribute].map((id) => this.find(relationType, id, models))
+            : this.find(relationType, model[attribute], models)
+      }
+
+      return model
+    }
+
+    setupRelations(links) {
+      return (() => {
+        const result = []
+        for (let key in links) {
+          const value = links[key]
+          let [type, attribute] = Array.from(key.split('.'))
+          type = this.types[type] || type
+          if (!this.relations[type]) {
+            this.relations[type] = {}
+          }
+          result.push((this.relations[type][attribute] = this.types[value.type] || value.type))
+        }
+        return result
+      })()
+    }
+
+    findRecord(type, id) {
+      return this.records.find((r) => r.type === type && r.data.id === id)
+    }
+
+    findRecords(type) {
+      return this.records.filter((r) => r.type === type)
+    }
+
+    retrive(type, data) {
+      this.sync(data)
+      const { id } = data[type]
+      return this.find(type, id)
+    }
+
+    find(type, id, models) {
+      if (models == null) {
+        models = {}
+      }
+      const rec = this.findRecord(type, id)
+      if (rec == null) {
+        return null
+      }
+      if (!models[type]) {
+        models[type] = {}
+      }
+      return models[type][id] || this.toModel(rec, type, models)
+    }
+
+    findAll(type, models) {
+      if (models == null) {
+        models = {}
+      }
+      const recs = this.findRecords(type)
+      if (recs == null) {
+        return []
+      }
+      recs.forEach((rec) => {
+        if (!models[type]) {
+          models[type] = {}
+        }
+        return this.toModel(rec, type, models)
+      })
+      return Object.values(models[type] || {})
+    }
+
+    remove(type, id) {
+      type = this.types[type] || type
+
+      const remove = (record) => {
+        const index = this.records.indexOf(record)
+        if (!(index < 0)) {
+          return this.records.splice(index, 1)
+        }
+      }
+
+      if (id != null) {
+        return remove(this.findRecord(type, id))
+      } else {
+        const records = this.findRecords(type)
+        return records.forEach(remove)
+      }
+    }
+
+    sync(data) {
+      this.setupRelations(data.links)
+
+      return (() => {
+        const result = []
+        for (var name in data) {
+          if (name === 'meta' || name === 'links') {
+            continue
+          }
+
+          const value = data[name]
+
+          const add = (d) => {
+            const type = this.types[name] || name
+            this.remove(type, d.id)
+            return this.records.push(new Record({ type, data: d }))
+          }
+
+          if (value instanceof Array) {
+            result.push(value.forEach(add))
+          } else {
+            result.push(add(value))
+          }
+        }
+        return result
+      })()
+    }
+  }
+}

package/src/yayson/presenter.js

@@ -0,0 +1,198 @@
+module.exports = function (adapter) {
+  const buildLinks = function (link) {
+    if (link == null) {
+      return
+    }
+    if (link.self != null || link.related != null) {
+      return link
+    } else {
+      return { self: link }
+    }
+  }
+
+  return class Presenter {
+    static adapter = adapter
+    static type = 'objects'
+
+    constructor(scope) {
+      if (scope == null) {
+        scope = {}
+      }
+      this.scope = scope
+    }
+
+    id(instance) {
+      return this.constructor.adapter.id(instance)
+    }
+
+    //eslint-disable-next-line no-unused-vars
+    selfLinks(instance) {}
+
+    links() {}
+
+    relationships() {}
+
+    attributes(instance) {
+      if (instance == null) {
+        return null
+      }
+      const attributes = { ...this.constructor.adapter.get(instance) }
+      delete attributes['id']
+
+      const relationships = this.relationships()
+      for (let key in relationships) {
+        delete attributes[key]
+      }
+      return attributes
+    }
+
+    includeRelationships(scope, instance) {
+      const relationships = this.relationships()
+      const result = []
+      for (var key in relationships) {
+        const factory = relationships[key]
+        if (!factory) throw new Error(`Presenter for ${key} in ${this.constructor.type} is not defined`)
+
+        const presenter = new factory(scope)
+
+        const data = this.constructor.adapter.get(instance, key)
+        result.push(presenter.toJSON(data, { include: true }))
+      }
+      return result
+    }
+
+    buildRelationships(instance) {
+      if (instance == null) {
+        return null
+      }
+      const rels = this.relationships()
+      const links = this.links(instance) || {}
+      let relationships = null
+      for (var key in rels) {
+        let data = this.constructor.adapter.get(instance, key)
+        var presenter = rels[key]
+        var buildData = (d) => {
+          return (data = {
+            id: this.constructor.adapter.id(d),
+            type: presenter.type,
+          })
+        }
+        const build = (d) => {
+          const rel = {}
+          if (d != null) {
+            rel.data = buildData(d)
+          }
+          if (links[key] != null) {
+            rel.links = buildLinks(links[key])
+          } else if (d == null) {
+            rel.data = null
+          }
+          return rel
+        }
+        if (!relationships) {
+          relationships = {}
+        }
+        if (!relationships[key]) {
+          relationships[key] = {}
+        }
+        if (data instanceof Array) {
+          relationships[key].data = data.map(buildData)
+          if (links[key] != null) {
+            relationships[key].links = buildLinks(links[key])
+          }
+        } else {
+          relationships[key] = build(data)
+        }
+      }
+      return relationships
+    }
+
+    buildSelfLink(instance) {
+      return buildLinks(this.selfLinks(instance))
+    }
+
+    toJSON(instanceOrCollection, options) {
+      if (options == null) {
+        options = {}
+      }
+      if (options.meta != null) {
+        this.scope.meta = options.meta
+      }
+      if (options.links != null) {
+        this.scope.links = options.links
+      }
+      if (!this.scope.data) {
+        this.scope.data = null
+      }
+
+      if (instanceOrCollection == null) {
+        return this.scope
+      }
+
+      if (instanceOrCollection instanceof Array) {
+        const collection = instanceOrCollection
+        if (!this.scope.data) {
+          this.scope.data = []
+        }
+        collection.forEach((instance) => {
+          return this.toJSON(instance, options)
+        })
+      } else {
+        const instance = instanceOrCollection
+        let added = true
+        const model = {
+          id: this.id(instance),
+          type: this.constructor.type,
+          attributes: this.attributes(instance),
+        }
+        if (model.id === undefined) {
+          delete model.id
+        }
+        const relationships = this.buildRelationships(instance)
+        if (relationships != null) {
+          model.relationships = relationships
+        }
+        const links = this.buildSelfLink(instance)
+        if (links != null) {
+          model.links = links
+        }
+
+        if (options.include) {
+          if (!this.scope.included) {
+            this.scope.included = []
+          }
+          if (!this.scope.included.concat(this.scope.data).some((i) => i.id === model.id && i.type === model.type)) {
+            this.scope.included.push(model)
+          } else {
+            added = false
+          }
+        } else if (this.scope.data != null) {
+          if (!(this.scope.data instanceof Array) || !this.scope.data.some((i) => i.id === model.id)) {
+            this.scope.data.push(model)
+          } else {
+            added = false
+          }
+        } else {
+          this.scope.data = model
+        }
+
+        if (added) {
+          this.includeRelationships(this.scope, instance)
+        }
+      }
+      return this.scope
+    }
+
+    render(instanceOrCollection, options) {
+      return this.toJSON(instanceOrCollection, options)
+    }
+
+    static toJSON() {
+      return new this().toJSON(...arguments)
+    }
+
+    static render() {
+      return new this().render(...arguments)
+    }
+  }
+}

package/src/yayson/store.js

@@ -0,0 +1,194 @@
+module.exports = function () {
+  class Record {
+    constructor(options) {
+      ;({
+        id: this.id,
+        type: this.type,
+        attributes: this.attributes,
+        relationships: this.relationships,
+        links: this.links,
+        meta: this.meta,
+      } = options)
+    }
+  }
+
+  class Store {
+    //eslint-disable-next-line no-unused-vars
+    constructor(options) {
+      this.reset()
+    }
+
+    reset() {
+      this.records = []
+    }
+
+    toModel(rec, type, models) {
+      let typeAttribute
+      const model = { ...(rec.attributes || {}) }
+      if (model.type) {
+        typeAttribute = model.type
+      }
+
+      model.id = rec.id
+      model.type = rec.type
+      if (!models[type]) {
+        models[type] = {}
+      }
+      if (!models[type][rec.id]) {
+        models[type][rec.id] = model
+      }
+
+      if (Object.prototype.hasOwnProperty.call(model, 'meta')) {
+        model.attributes = { meta: model.meta }
+        delete model.meta
+      }
+
+      if (rec.meta != null) {
+        model.meta = rec.meta
+      }
+
+      if (rec.links != null) {
+        model.links = rec.links
+      }
+
+      if (rec.relationships != null) {
+        for (let key in rec.relationships) {
+          const rel = rec.relationships[key]
+          const { data } = rel
+          const { links } = rel
+          const { meta } = rel
+
+          model[key] = null
+          if (data == null && links == null) {
+            continue
+          }
+          const resolve = ({ type, id }) => {
+            return this.find(type, id, models)
+          }
+          model[key] = data instanceof Array ? data.map(resolve) : data != null ? resolve(data) : {}
+
+          // Model of the relation
+          const currentModel = model[key]
+
+          if (currentModel != null) {
+            // retain the links and meta from the relationship entry
+            // use as underscore property name because the currentModel may also have a link and meta reference
+            currentModel._links = links || {}
+            currentModel._meta = meta || {}
+          }
+        }
+      }
+
+      if (typeAttribute) {
+        model.type = typeAttribute
+      }
+      return model
+    }
+
+    findRecord(type, id) {
+      return this.records.find((r) => r.type === type && r.id === id)
+    }
+
+    findRecords(type) {
+      return this.records.filter((r) => r.type === type)
+    }
+
+    find(type, id, models) {
+      if (models == null) {
+        models = {}
+      }
+      const rec = this.findRecord(type, id)
+      if (rec == null) {
+        return null
+      }
+      if (!models[type]) {
+        models[type] = {}
+      }
+      return models[type][id] || this.toModel(rec, type, models)
+    }
+
+    findAll(type, models) {
+      if (models == null) {
+        models = {}
+      }
+      const recs = this.findRecords(type)
+      if (recs == null) {
+        return []
+      }
+      recs.forEach((rec) => {
+        if (!models[type]) {
+          models[type] = {}
+        }
+        return this.toModel(rec, type, models)
+      })
+      return Object.values(models[type] || {})
+    }
+
+    remove(type, id) {
+      const remove = (record) => {
+        const index = this.records.indexOf(record)
+        if (!(index < 0)) {
+          return this.records.splice(index, 1)
+        }
+      }
+
+      if (id != null) {
+        return remove(this.findRecord(type, id))
+      } else {
+        const records = this.findRecords(type)
+        return records.map(remove)
+      }
+    }
+
+    sync(body) {
+      const sync = (data) => {
+        if (data == null) {
+          return null
+        }
+        const add = (obj) => {
+          const { type, id } = obj
+          this.remove(type, id)
+          const rec = new Record(obj)
+          this.records.push(rec)
+          return rec
+        }
+
+        if (data instanceof Array) {
+          return data.map(add)
+        } else {
+          return add(data)
+        }
+      }
+
+      sync(body.included)
+      const recs = sync(body.data)
+
+      if (recs == null) {
+        return null
+      }
+
+      const models = {}
+      let result = null
+
+      if (recs instanceof Array) {
+        result = recs.map((rec) => {
+          return this.toModel(rec, rec.type, models)
+        })
+      } else {
+        result = this.toModel(recs, recs.type, models)
+      }
+
+      if (Object.prototype.hasOwnProperty.call(body, 'links')) {
+        result.links = body.links
+      }
+
+      if (Object.prototype.hasOwnProperty.call(body, 'meta')) {
+        result.meta = body.meta
+      }
+
+      return result
+    }
+  }
+
+  return Store
+}

package/src/yayson.js

@@ -0,0 +1,23 @@
+const Adapter = require('./yayson/adapter')
+const adapters = require('./yayson/adapters')
+const presenter = require('./yayson/presenter')
+const store = require('./yayson/store')
+
+const lookupAdapter = function (nameOrAdapter) {
+  if (nameOrAdapter === 'default') {
+    return Adapter
+  }
+  return adapters[nameOrAdapter] || nameOrAdapter || Adapter
+}
+
+module.exports = function ({ adapter: nameOrAdapter } = {}) {
+  const adapter = lookupAdapter(nameOrAdapter)
+  const Presenter = presenter(lookupAdapter(adapter))
+  const Store = store()
+
+  return {
+    Store,
+    Presenter,
+    Adapter,
+  }
+}

package/webpack.browser.js

@@ -0,0 +1,27 @@
+const path = require('path')
+const { merge } = require('webpack-merge')
+const common = require('./webpack.common.js')
+
+module.exports = merge(common, {
+  entry: {
+    tests: './test/browser.js',
+  },
+  devtool: 'eval',
+  output: {
+    path: __dirname + '/test',
+    filename: '[name].js',
+  },
+  performance: {
+    maxAssetSize: 3000000,
+    maxEntrypointSize: 3000000,
+    assetFilter: (asset) => {
+      console.log(1212, asset, asset.match('tests.js'))
+      return asset.match('tests.js')
+    },
+  },
+  devServer: {
+    static: [path.join(__dirname, 'test'), path.join(__dirname, 'dist'), path.join(__dirname, 'node_modules/mocha')],
+    compress: true,
+    port: 9000,
+  },
+})

package/webpack.common.js

@@ -0,0 +1,39 @@
+module.exports = {
+  mode: 'production',
+  entry: {
+    yayson: './src/yayson.js',
+    'yayson.min': './src/yayson.js',
+    'yayson-legacy': './src/legacy.js',
+    'yayson-legacy.min': './src/legacy.js',
+  },
+  output: {
+    path: __dirname + '/dist',
+    filename: '[name].js',
+    library: 'yayson',
+  },
+  resolve: {
+    fallback: { util: false },
+  },
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: [
+              [
+                '@babel/preset-env',
+                {
+                  corejs: '3',
+                  useBuiltIns: 'entry',
+                },
+              ],
+            ],
+          },
+        },
+      },
+    ],
+  },
+}

package/webpack.dist.js

@@ -0,0 +1,21 @@
+const webpack = require('webpack')
+const { merge } = require('webpack-merge')
+const common = require('./webpack.common.js')
+const PACKAGE = require('./package.json')
+const TerserPlugin = require('terser-webpack-plugin')
+
+module.exports = merge(common, {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new TerserPlugin({
+        extractComments: false,
+      }),
+    ],
+  },
+  plugins: [
+    new webpack.BannerPlugin({
+      banner: `yayson v ${PACKAGE.version} (${PACKAGE.homepage}) by ${PACKAGE.author}`,
+    }),
+  ],
+})

package/.circleci/config.yml

@@ -1,35 +0,0 @@
-# Javascript Node CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-javascript/ for more details
-#
-version: 2
-jobs:
-  build:
-    docker:
-      # specify the version you desire here
-      - image: circleci/node:6.11
-        environment:
-          NODE_ENV: 'test'
-
-    working_directory: ~/repo
-
-    steps:
-      - checkout
-      - run:
-          name: Setup Environment Variables
-          command: |
-            echo 'export NODE_ENV="test"' >> $BASH_ENV
-      # Download and cache dependencies
-      - restore_cache:
-          keys:
-          - v1-dependencies-{{ checksum "package.json" }}
-          # fallback to using the latest cache if no exact match is found
-          - v1-dependencies-
-      - run: npm install
-      - save_cache:
-          paths:
-            - node_modules
-          key: v1-dependencies-{{ checksum "package.json" }}
-
-      # run tests!
-      - run: npm test