yayson 2.1.0 → 3.0.0

package/.eslintrc.json

@@ -0,0 +1,28 @@
+{
+  "env": {
+    "commonjs": true,
+    "es6": true,
+    "mocha": true,
+    "node": true
+  },
+  "parser": "@babel/eslint-parser",
+  "parserOptions": {
+    "ecmaVersion": 2020
+  },
+  "ignorePatterns": ["node_modules", "dist"],
+  "rules": {
+    "eqeqeq": ["error", "smart"],
+    "semi": ["error", "never", { "beforeStatementContinuationChars": "always" }],
+    "no-extra-semi": "off"
+  },
+  "plugins": ["mocha"],
+  "extends": ["eslint:recommended", "plugin:mocha/recommended"],
+  "overrides": [
+    {
+      "files": ["test/**/*.js"],
+      "rules": {
+        "no-unused-vars": "off"
+      }
+    }
+  ]
+}

package/.github/workflows/node.js.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x, 15.x]
+        node-version: [14.x, 16.x, 18.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

package/.mocharc.js

@@ -2,14 +2,14 @@
 
 module.exports = {
   recursive: true,
-  require: ['coffeescript/register', 'test/common.coffee'],
+  require: ['test/node.js'],
   diff: true,
-  extension: ['js', 'coffee'],
+  extension: ['js'],
   package: './package.json',
   reporter: 'spec',
   slow: 75,
   timeout: 10000,
   ui: 'bdd',
-  spec: ['test/yayson/**/*.coffee'],
-  'watch-files': ['src/**/*.coffee', 'test/**/*.coffee'],
+  spec: ['test/yayson/**/*.js'],
+  'watch-files': ['src/**/*.js', 'test/**/*.js'],
 }

package/.nvmrc

@@ -0,0 +1 @@
+v18.13.0

package/README.md

@@ -1,6 +1,8 @@
 # YAYSON
 
-A library for serializing and reading [JSON API](http://jsonapi.org) data in JavaScript. As of 2.0.0 YAYSON aims to support JSON API version 1.
+A library for serializing and reading [JSON API](http://jsonapi.org) data in JavaScript.
+
+From version 3 we now support native JavaScript classes. YAYSON has zero dependencies and works in the browser and in node 14 and up.
 
 [![NPM](https://nodei.co/npm/yayson.png?downloads=true)](https://nodei.co/npm/yayson/)
 
@@ -10,55 +12,45 @@ A library for serializing and reading [JSON API](http://jsonapi.org) data in Jav
 Install yayson by running:
 
 ```
-$ npm install yayson --save
-```
-
-## Presenting data
-
-A basic `Presenter` can look like this in Coffeescript:
-
-```coffee
-  {Presenter} = require('yayson')(adapter: 'default')
-
-  class ItemsPresenter extends Presenter
-    type: 'items'
 
-  item =
-    id: 5
-    name: 'First'
 
-  ItemsPresenter.render(item)
+$ npm i yayson
 ```
 
-Or in plain JavaScript:
+## Presenting data
+
+A basic `Presenter` can look like this:
 
 ```javascript
-  const Presenter = require('yayson')({
-    adapter: 'default'
-  }).Presenter;
+const yayson = require('yayson')
+const { Presenter } = yayson()
 
-  class ItemsPresenter extends Presenter {};
-  ItemsPresenter.prototype.type = 'items';
+class BikePresenter extends Presenter {
+  static type = 'bikes'
+}
 
-  var item = {
-    id: 5,
-    name: 'First'
-  };
+const bike = {
+  id: 5,
+  name: 'Monark'
+};
 
-  ItemsPresenter.render(item);
+BikePresenter.render(bike);
 ```
 
 
 This would produce:
 
 ```javascript
+
+
+
 {
   data: {
     id: 5,
-    type: 'items',
+    type: 'bikes',
     attributes: {
       id: 5,
-      name: 'First'
+      name: 'Monark'
     }
   }
 }
@@ -69,46 +61,28 @@ be an array.
 
 A bit more advanced example:
 
-```coffee
-  {Presenter} = require('yayson')(adapter: 'default')
-
-  class ItemsPresenter extends Presenter
-    type: 'items'
-
-    attributes: ->
-      attrs = super
-      attrs.start = moment.utc(attrs.start).toDate()
-      attrs
-
-    relationships: ->
-      event: EventsPresenter
-
-  ItemsPresenter.render(item)
-```
-
-In JavaScript this would be done as:
 
 ```javascript
 
-var Presenter = require('yayson')().Presenter;
-
-class ItemsPresenter extends Presenter {};
-ItemsPresenter.prototype.type = 'items'
+const yayson = require('yayson')
+const { Presenter } = yayson()
 
-ItemsPresenter.prototype.attributes = function() {
-  var attrs = Presenter.prototype.attributes.apply(this, arguments);
+class WheelPresenter extends Presenter {
+  static type = 'wheels'
 
-  attrs.start = moment.utc(attrs.start).toDate();
-  return attrs;
+  relationships() {
+    return { bike: BikePresenter }
+  }
 }
 
-ItemsPresenter.prototype.relationships = function() {
-  return {
-    event: EventsPresenter
+class BikePresenter extends Presenter {
+  static type = 'bikes'
+  relationships() {
+    return { wheels: WheelPresenter }
   }
 }
 
-ItemsPresenter.render(item)
+
 ```
 
 ### Sequelize support
@@ -117,28 +91,25 @@ By default it is set up to handle standard JS objects. You can also make
 it handle Sequelize.js models like this:
 
 ```javascript
-{Presenter} = require('yayson')({adapter: 'sequelize'})
+
+const yayson = require('yayson')
+{Presenter} = yayson({adapter: 'sequelize'})
 
 ```
 
 You can also define your own adapter globally:
 
 ```javascript
-{Presenter} = require('yayson')(adapter: {
+
+
+const yayson = require('yayson')
+{Presenter} = yayson(adapter: {
   id: function(model){ return 'omg' + model.id},
   get: function(model, key){ return model[key] }
 })
 
 ```
 
-Or at Presenter level:
-
-```javascript
-ItemPresenter.adapter = {
-  id: function(model){ return 'omg' + model.id},
-  get: function(model, key){ return model[key] }
-}
-```
 
 Take a look at the SequelizeAdapter if you want to extend YAYSON to your ORM. Pull requests are welcome. :)
 
@@ -146,13 +117,17 @@ Take a look at the SequelizeAdapter if you want to extend YAYSON to your ORM. Pu
 
 You can add metadata to the top level object.
 
-``` coffee
-  ItemsPresenter.render(items, meta: count: 10)
+``` javascript
+
+
+  ItemsPresenter.render(items, {meta: count: 10})
 ```
 
 This would produce:
 
 ```javascript
+
+
 {
   meta: {
     count: 10
@@ -172,16 +147,25 @@ This would produce:
 
 You can use a `Store` can like this:
 
-```coffee
-    {Store} = require('yayson')()
-    store = new Store()
+```javascript
+  const {Store} = require('yayson')();
+  const store = new Store();
 
-    adapter.get(path: '/events/' + id).then (data) ->
-      event = store.sync(data)
+  const data = await adapter.get({path: '/events/' + id});
+  const event = store.sync(data);
 ```
 
 This will give you the parsed event with all its relationships.
 
+Its also possible to find in the synched data:
+
+
+```javascript
+  const event = this.store.find('events', id)
+
+  const images = this.store.findAll('images')
+```
+
 
 ## Use in the browser
 
@@ -189,6 +173,7 @@ Recommended way is to use it via [webpack](https://github.com/webpack/webpack) o
 
 If you just want to try it out, copy the file `dist/yayson.js` to your project. Then simply include it:
 ```html
+
     <script src="./lib/yayson.js"></script>
 ```
 Then you can `var yayson = window.yayson()` use the `yayson.Presenter` and `yayson.Store` as usual.
@@ -202,5 +187,19 @@ Then you can `var yayson = window.yayson()` use the `yayson.Presenter` and `yays
 - Safari iOS
 
 #### Untested, but should work
-- IE 9+
+- IE 11
 - Android
+
+
+## Legacy support
+
+Earlier versions of JSON API worked a bit different from 1.0. Therefore YAYSON provides legacy presenters and stores in order to have interoperability between the versions. Its used similar to the standard presenters:
+
+```javascript
+
+const yayson = require('yayson/legacy')
+const { Presenter } = yayson()
+
+```
+
+

package/babel.config.json

@@ -0,0 +1,4 @@
+{
+  "presets": [],
+  "plugins": []
+}

package/legacy.js

@@ -0,0 +1,2 @@
+const yayson = require('./src/legacy')
+module.exports = yayson

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "yayson",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "A library for serializing and reading JSON API standardized data in JavaScript.",
-  "main": "lib/yayson.js",
+  "main": "src/yayson.js",
   "engines": {
-    "node": ">=10",
+    "node": ">=14",
     "npm": ">=6"
   },
   "scripts": {
     "test": "mocha",
-    "build": "gulp",
+    "build": "webpack --config webpack.dist.js",
+    "test-browser": "webpack-dev-server --config webpack.browser.js",
     "preversion": "npm test && npm run build && git add dist/yayson.js",
     "postversion": "git push --follow-tags origin master",
     "release": "npm version minor"
@@ -36,30 +37,26 @@
     "url": "https://github.com/confetti/yayson/issues"
   },
   "homepage": "https://github.com/confetti/yayson",
+  "browserslist": [
+    "defaults",
+    "not IE 11"
+  ],
   "devDependencies": {
-    "bower": "^1.8.12",
-    "browserify": "^17.0.0",
-    "chai": "^4.3.4",
-    "coffeeify": "^3.0.1",
-    "coffeescript": "^1.12.7",
-    "ecstatic": "^4.1.4",
-    "gulp": "^4.0.2",
-    "gulp-coffee": "^3.0.3",
-    "gulp-util": "^3.0.1",
-    "mocha": "^8.3.2",
-    "sinon": "^10.0.0",
-    "sinon-chai": "^3.6.0",
-    "vinyl-source-stream": "^2.0.0"
-  },
-  "optionalDependencies": {
-    "lodash": "^4.17.21",
-    "q": "^1.5.1",
-    "underscore": "^1.13.1"
-  },
-  "browser": {
-    "lodash": false,
-    "q": false,
-    "underscore": false
-  },
-  "dependencies": {}
+    "@babel/core": "^7.20.12",
+    "@babel/eslint-parser": "^7.19.1",
+    "@babel/preset-env": "^7.20.2",
+    "babel-loader": "^9.1.2",
+    "chai": "^4.3.7",
+    "core-js": "^3.27.2",
+    "eslint": "^8.33.0",
+    "eslint-plugin-mocha": "^10.1.0",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.3",
+    "sinon": "^15.0.1",
+    "sinon-chai": "^3.7.0",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
+    "webpack-dev-server": "^4.11.1",
+    "webpack-merge": "^5.8.0"
+  }
 }

package/prettier.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  semi: false,
+  singleQuote: true,
+  printWidth: 120,
+}

package/src/legacy.js

@@ -0,0 +1,14 @@
+const yayson = require('./yayson')
+const legacyPresenter = require('./yayson/legacy-presenter')
+const legacyStore = require('./yayson/legacy-store')
+
+module.exports = function (options = {}) {
+  const { Store, Presenter, Adapter } = yayson(options)
+  return {
+    Store: legacyStore(Store),
+    Presenter: legacyPresenter(Presenter),
+    Adapter,
+  }
+}
+
+

package/src/yayson/adapter.js

@@ -0,0 +1,18 @@
+class Adapter {
+  static get(model, key) {
+    if (key) {
+      return model[key]
+    }
+    return model
+  }
+
+  static id(model) {
+    const id = this.get(model, 'id')
+    if (id === undefined) {
+      return id
+    }
+    return `${id}`
+  }
+}
+
+module.exports = Adapter

package/src/yayson/adapters/index.js

@@ -0,0 +1 @@
+module.exports = { sequelize: require('./sequelize') }

package/src/yayson/adapters/sequelize.js

@@ -0,0 +1,11 @@
+const Adapter = require('../adapter')
+
+class SequelizeAdapter extends Adapter {
+  static get(model, key) {
+    if (model != null) {
+      return model.get(key)
+    }
+  }
+}
+
+module.exports = SequelizeAdapter

package/src/yayson/legacy-presenter.js

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