yayson 3.0.0 → 4.0.0

package/src/yayson/legacy-presenter.js

@@ -1,121 +0,0 @@
-module.exports = function (Presenter) {
-  return class LegacyPresenter extends Presenter {
-    static type = 'object'
-
-    pluralType() {
-      return this.constructor.plural || this.constructor.type + 's'
-    }
-
-    attributes(instance) {
-      if (!instance) {
-        return null
-      }
-      const attributes = { ...this.constructor.adapter.get(instance) }
-      const relationships = this.relationships()
-      for (let key in relationships) {
-        var id
-        const data = attributes[key]
-        if (data == null) {
-          id = attributes[key + 'Id']
-          if (id != null) {
-            attributes[key] = id
-          }
-        } else if (data instanceof Array) {
-          attributes[key] = data.map((obj) => obj.id)
-        } else {
-          attributes[key] = data.id
-        }
-      }
-      return attributes
-    }
-
-    includeRelationships(scope, instance) {
-      if (!scope.links) {
-        scope.links = {}
-      }
-      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)
-        if (data != null) {
-          presenter.toJSON(data, { defaultPlural: true })
-        }
-
-        const type = scope[this.pluralType()] != null ? this.pluralType() : this.constructor.type
-        const keyName = scope[presenter.pluralType()] != null ? presenter.pluralType() : presenter.constructor.type
-        const link = { type: keyName }
-        scope.links[`${type}.${key}`] = link
-        result.push(link)
-      }
-      return result
-    }
-
-    toJSON(instanceOrCollection, options) {
-      let type
-      if (options == null) {
-        options = {}
-      }
-      if (instanceOrCollection instanceof Array) {
-        const collection = instanceOrCollection
-        if (!this.scope[(type = this.pluralType())]) {
-          this.scope[type] = []
-        }
-        collection.forEach((instance) => {
-          return this.toJSON(instance)
-        })
-      } else {
-        let links
-        const instance = instanceOrCollection
-        let added = true
-        const attrs = this.attributes(instance)
-        if ((links = this.links())) {
-          attrs.links = links
-        }
-        // If eg x.image already exists
-        if (this.scope[this.constructor.type] && !this.scope[this.pluralType()]) {
-          if (this.scope[this.constructor.type].id !== attrs.id) {
-            this.scope[this.pluralType()] = [this.scope[this.constructor.type]]
-            delete this.scope[this.constructor.type]
-            this.scope[this.pluralType()].push(attrs)
-          } else {
-            added = false
-          }
-
-          // If eg x.images already exists
-        } else if (this.scope[this.pluralType()]) {
-          if (!this.scope[this.pluralType()].some((i) => i.id === attrs.id)) {
-            this.scope[this.pluralType()].push(attrs)
-          } else {
-            added = false
-          }
-        } else if (options.defaultPlural) {
-          this.scope[this.pluralType()] = [attrs]
-        } else {
-          this.scope[this.constructor.type] = attrs
-        }
-
-        if (added) {
-          this.includeRelationships(this.scope, instance)
-        }
-      }
-      return this.scope
-    }
-
-    render(instanceOrCollection) {
-      return this.toJSON(instanceOrCollection)
-    }
-
-    static toJSON() {
-      return new this().toJSON(...arguments)
-    }
-
-    static render() {
-      return new this().render(...arguments)
-    }
-  }
-}

package/src/yayson/legacy-store.js

@@ -1,156 +0,0 @@
-// 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

@@ -1,198 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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,
-  }
-}