yayson 2.0.10-quickfix → 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/tags

@@ -0,0 +1,59 @@
+!_TAG_FILE_FORMAT	2	/extended format/
+!_TAG_FILE_SORTED	0	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Łukasz Korecki	/lukasz@korecki.me/
+!_TAG_PROGRAM_NAME	CoffeeTags	//
+!_TAG_PROGRAM_URL	https://github.com/lukaszkorecki/CoffeeTags	/GitHub repository/
+!_TAG_PROGRAM_VERSION	0.6.0	//
+@render	src/yayson/presenter.coffee	/^    @render: ->$/;"	f	line:133	language:coffee	object:exports.Presenter
+@toJSON	src/yayson/presenter.coffee	/^    @toJSON: ->$/;"	f	line:130	language:coffee	object:exports.Presenter
+BikePresenter	test/yayson/presenter.coffee	/^    class BikePresenter extends Presenter$/;"	c	line:108	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:194	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:203	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:214	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:235	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:277	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:298	language:coffee
+CarPresenter	test/yayson/presenter.coffee	/^    class CarPresenter extends Presenter$/;"	c	line:65	language:coffee
+MotorPresenter	test/yayson/presenter.coffee	/^    class MotorPresenter extends Presenter$/;"	c	line:60	language:coffee
+Presenter	src/yayson/presenter.coffee	/^  class Presenter$/;"	c	line:3	language:coffee
+WheelPresenter	test/yayson/presenter.coffee	/^    class WheelPresenter extends Presenter$/;"	c	line:103	language:coffee
+attributes	src/yayson/presenter.coffee	/^    attributes: (instance) ->$/;"	f	line:27	language:coffee	object:exports.Presenter
+build	src/yayson/presenter.coffee	/^        build = (d) =>$/;"	f	line:59	language:coffee	object:exports.Presenter.buildRelationships
+buildData	src/yayson/presenter.coffee	/^        buildData = (d) =>$/;"	f	line:55	language:coffee	object:exports.Presenter.buildRelationships
+buildLinks	src/yayson/presenter.coffee	/^    buildLinks = (link) ->$/;"	f	line:4	language:coffee	object:exports.Presenter
+buildRelationships	src/yayson/presenter.coffee	/^    buildRelationships: (instance) ->$/;"	f	line:47	language:coffee	object:exports.Presenter
+buildSelfLink	src/yayson/presenter.coffee	/^    buildSelfLink: (instance) ->$/;"	f	line:78	language:coffee	object:exports.Presenter
+constructor	src/yayson/presenter.coffee	/^    constructor: (scope = {}) ->$/;"	f	line:14	language:coffee	object:exports.Presenter
+exports	src/yayson.coffee	/^module.exports = ({adapter} = {}) ->$/;"	f	line:24	language:coffee	object:window
+exports	src/yayson/presenter.coffee	/^module.exports = (utils, adapter) ->$/;"	f	line:1	language:coffee	object:window
+for 	src/yayson/presenter.coffee	/^      for key of relationships$/;"	b	line:34	language:coffee
+for 	src/yayson/presenter.coffee	/^      for key of relationships$/;"	b	line:40	language:coffee
+for 	src/yayson/presenter.coffee	/^      for key of rels$/;"	b	line:52	language:coffee
+for 	test/yayson/presenter.coffee	/^    for c in cars$/;"	b	line:266	language:coffee
+for 	test/yayson/presenter.coffee	/^    for w in wheels$/;"	b	line:135	language:coffee
+get	test/yayson/presenter.coffee	/^      get: sinon.spy -> 'bar'$/;"	f	line:359	language:coffee	object:presenterFactory.adapter
+id	src/yayson/presenter.coffee	/^    id: (instance) ->$/;"	f	line:17	language:coffee	object:exports.Presenter
+if 	src/yayson.coffee	/^if window?$/;"	b	line:2	language:coffee
+if 	src/yayson/presenter.coffee	/^          if d?$/;"	b	line:61	language:coffee
+if 	src/yayson/presenter.coffee	/^          if links[key]?$/;"	b	line:63	language:coffee
+if 	src/yayson/presenter.coffee	/^          if links[key]?$/;"	b	line:72	language:coffee
+if 	src/yayson/presenter.coffee	/^        if data instanceof Array$/;"	b	line:70	language:coffee
+if 	src/yayson/presenter.coffee	/^        if options.include$/;"	b	line:105	language:coffee
+if 	src/yayson/presenter.coffee	/^      if instanceOrCollection instanceof Array$/;"	b	line:87	language:coffee
+if 	src/yayson/presenter.coffee	/^      if link.self? || link.related?$/;"	b	line:6	language:coffee
+if 	src/yayson/presenter.coffee	/^      if utils.isPromise(instanceOrCollection)$/;"	b	line:125	language:coffee
+if 	test/yayson/presenter.coffee	/^      if attr?$/;"	b	line:326	language:coffee
+includeRelationships	src/yayson/presenter.coffee	/^    includeRelationships: (scope, instance) ->$/;"	f	line:38	language:coffee	object:exports.Presenter
+links	src/yayson/presenter.coffee	/^    links: ->$/;"	f	line:23	language:coffee	object:exports.Presenter
+links	test/yayson/presenter.coffee	/^      links: (instance) ->$/;"	f	line:223	language:coffee	object:presenterFactory.CarPresenter
+lookupAdapter	src/yayson.coffee	/^lookupAdapter = (nameOrAdapter) ->$/;"	f	line:16	language:coffee	object:window
+presenter	src/yayson.coffee	/^presenter = (options = {}) ->$/;"	f	line:20	language:coffee	object:window
+presenterFactory	test/yayson/presenter.coffee	/^presenterFactory = require('../../src/yayson.coffee')$/;"	o	line:5	language:coffee	object:window
+relationships	src/yayson/presenter.coffee	/^    relationships: ->$/;"	f	line:25	language:coffee	object:exports.Presenter
+relationships	test/yayson/presenter.coffee	/^      relationships: ->$/;"	f	line:62	language:coffee	object:presenterFactory.MotorPresenter
+render	src/yayson/presenter.coffee	/^    render: (instanceOrCollection, options) ->$/;"	f	line:124	language:coffee	object:exports.Presenter
+selfLinks	src/yayson/presenter.coffee	/^    selfLinks: (instance) ->$/;"	f	line:21	language:coffee	object:exports.Presenter
+selfLinks	test/yayson/presenter.coffee	/^      selfLinks: (instance) ->$/;"	f	line:196	language:coffee	object:presenterFactory.CarPresenter
+toJSON	src/yayson/presenter.coffee	/^    toJSON: (instanceOrCollection, options = {}) ->$/;"	f	line:81	language:coffee	object:exports.Presenter
+unless 	src/yayson/presenter.coffee	/^          unless @scope.data instanceof Array and utils.any(@scope.data, (i) -> i.id == model.id)$/;"	b	line:114	language:coffee
+unless 	src/yayson/presenter.coffee	/^          unless utils.any(@scope.included.concat(@scope.data), (i) ->$/;"	b	line:107	language:coffee

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',
+                },
+              ],
+            ],
+          },
+        },
+      },
+    ],
+  },
+}