fix(kitsu-core): serialise v9 relationship structures

This was intended to be part of the 9.0.0 release

Unfortuantely I missed it hadn't been done and shipped incompatible deserialise and serialise functions

BREAKING CHANGE

Author: wopian

packages/kitsu-core/src/serialise/index.js

@@ -43,17 +43,21 @@ function isValid (isArray, type, payload, method) {
  * @returns {Object} Serialised relationship
  * @private
  */
-function serialiseRelationOne (node, relations, key) {
-  relations[key] = { data: {} }
-  for (const prop of Object.keys(node[key].data)) {
-    const propNode = node[key].data[prop]
-    let propRelations = relations[key].data
-    // Pull everything but id and type into data.attributes
-    if (prop && ![ 'id', 'type' ].includes(prop)) {
-      propRelations = serialiseAttr(propNode, prop, propRelations)
-    } else propRelations[prop] = propNode
+function serialiseRelationOne (node, nodeType) {
+  let relation = {}
+  for (const prop of Object.keys(node)) {
+    if (prop &&
+      // Properties not being put in data.attributes
+      ![ 'id', 'type' ].includes(prop) &&
+      // Exclude a valid JSON:API links object being put in data.attributes
+      !(prop === 'links' && (node[prop].self || node[prop].related))
+    ) {
+      relation = serialiseAttr(node[prop], prop, relation)
+    } else relation[prop] = node[prop]
   }
-  return relations
+  // Guess relationship type if not provided
+  if (!relation.type) relation.type = nodeType
+  return relation
 }
 
 /**
@@ -65,50 +69,35 @@ function serialiseRelationOne (node, relations, key) {
  * @returns {Object} Serialised relationship
  * @private
  */
-function serialiseRelationMany (node, relations, key) {
-  relations[key] = { data: [] }
-  for (const prop of node[key].data) {
-    relations[key].data.push(prop)
+function serialiseRelationMany (node, nodeType) {
+  const relation = []
+  for (const prop of node) {
+    const serialised = serialiseRelationOne(prop)
+    // Guess relationship type if not provided
+    if (!serialised.type) serialised.type = nodeType
+    relation.push(serialised)
   }
-  return relations
+  return relation
 }
 
 /**
  * Serialises a relational object to JSON:API format
  *
- * @param {Object} node Relation object
- * @returns {Object} Serialised relationship
- * @private
- */
-function serialiseRelation (node) {
-  // Create a new object to handle collisions with attributes.attributes
-  let relations = {}
-  for (const key in node) {
-    const isToMany = Array.isArray(node[key].data)
-    relations = isToMany
-      ? serialiseRelationMany(node, relations, key)
-      : serialiseRelationOne(node, relations, key)
-  }
-  return relations
-}
-
-/**
- * Serialises an object to JSON:API format
- *
  * @param {Object} node Resource object
  * @param {string} nodeType Resource type of the object
  * @param {string} key The resource object's key value
  * @param {Object} data Root JSON:API data object
  * @private
  */
-function serialiseObject (node, nodeType, key, data) {
+function serialiseRelation (node, nodeType, key, data) {
   if (!data.relationships) data.relationships = {}
-  // Guess type if not provided
-  if (!node.type) node.type = nodeType
   data.relationships[key] = {
-    data: Object.assign(node)
+    data: Array.isArray(node.data)
+      ? serialiseRelationMany(node.data, nodeType)
+      : serialiseRelationOne(node.data, nodeType)
   }
-  data.relationships = serialiseRelation(data.relationships)
+  if (node?.links?.self || node?.links?.related) data.relationships[key].links = node.links
+  if (node?.meta) data.relationships[key].meta = node.meta
   return data
 }
 
@@ -123,8 +112,9 @@ function serialiseObject (node, nodeType, key, data) {
  */
 function serialiseArray (node, nodeType, key, data) {
   if (!data.relationships) data.relationships = {}
+
   data.relationships[key] = {
-    data: node.map(({ id, type, ...attributes }) => {
+    data: node.data.map(({ id, type, ...attributes }) => {
       return {
         id,
         type: type || nodeType,
@@ -146,7 +136,8 @@ function serialiseArray (node, nodeType, key, data) {
  */
 function serialiseAttr (node, key, data) {
   if (!data.attributes) data.attributes = {}
-  data.attributes[key] = node
+  if (key === 'links' && (node.self || node.related)) data.links = node
+  else data.attributes[key] = node
   return data
 }
 
@@ -158,7 +149,10 @@ function serialiseAttr (node, key, data) {
  * @private
  */
 function hasID (node) {
-  return Object.prototype.hasOwnProperty.call(node, 'id')
+  if (!node.data) return false
+  // Check if relationship is to-many
+  const nodeData = Array.isArray(node.data) ? node.data[0] : node.data
+  return Object.prototype.hasOwnProperty.call(nodeData, 'id')
 }
 
 /**
@@ -198,16 +192,17 @@ function serialiseRootObject (type, payload, method, options) {
   isValid(false, type, payload, method)
   type = options.pluralTypes(options.camelCaseTypes(type))
   let data = { type }
+  // ID not required for POST requests
   if (payload?.id) data.id = String(payload.id)
   for (const key in payload) {
     const node = payload[key]
     const nodeType = options.pluralTypes(options.camelCaseTypes(key))
     // 1. Skip null nodes, 2. Only grab objects, 3. Filter to only serialise relationable objects
     if (node !== null && node?.constructor === Object && hasID(node)) {
-      data = serialiseObject(node, nodeType, key, data)
+      data = serialiseRelation(node, nodeType, key, data)
     // 1. Skip null nodes, 2. Only grab arrays, 3. Filter to only serialise relationable arrays
-    } else if (node !== null && Array.isArray(node) && (node.length > 0 && hasID(node[0]))) {
-      data = serialiseArray(node, nodeType, key, data)
+    // } else if (node !== null && node?.constructor === Object && hasID(node)) {
+    //   data = serialiseArray(node, nodeType, key, data)
     // 1. Don't place id/key inside attributes object
     } else if (key !== 'id' && key !== 'type') {
       data = serialiseAttr(node, key, data)

packages/kitsu-core/src/serialise/index.spec.js

@@ -81,7 +81,9 @@ describe('kitsu-core', () => {
         'libraryEntries',
         {
           user: {
-            id: '2'
+            data: {
+              id: '2'
+            }
           }
         },
         undefined,
@@ -110,16 +112,18 @@ describe('kitsu-core', () => {
       const input = serialise(
         'libraryEntries',
         {
-          user: [
-            {
-              id: '2',
-              type: 'users',
-              content: 'yuzu'
-            },
-            {
-              id: '3'
-            }
-          ]
+          user: {
+            data: [
+              {
+                id: '2',
+                type: 'users',
+                content: 'yuzu'
+              },
+              {
+                id: '3'
+              }
+            ]
+          }
         },
         undefined,
         {
@@ -305,10 +309,12 @@ describe('kitsu-core', () => {
       expect.assertions(1)
       const input = serialise('resourceModel', {
         myRelationship: {
-          id: '1',
-          type: 'relationshipModel',
-          content: 'Hello',
-          attributes: 'Keep me'
+          data: {
+            id: '1',
+            type: 'relationshipModel',
+            content: 'Hello',
+            attributes: 'Keep me'
+          }
         }
       })
       expect(input).toEqual({
@@ -334,9 +340,11 @@ describe('kitsu-core', () => {
       expect.assertions(1)
       const input = serialise('resourceModel', [ {
         myRelationship: {
-          id: '1',
-          type: 'relationshipModel',
-          content: 'Hello'
+          data: {
+            id: '1',
+            type: 'relationshipModel',
+            content: 'Hello'
+          }
         }
       } ])
       expect(input).toEqual({
@@ -381,12 +389,16 @@ describe('kitsu-core', () => {
     it('serialises type arrays into relationships', () => {
       expect.assertions(1)
       const input = serialise('resourceModels', {
-        arrayRelation: [ {
-          id: '1',
-          type: 'arrayRelations',
-          content: 'Hey',
-          attributes: 'Keep me'
-        } ]
+        arrayRelation: {
+          data: [
+            {
+              id: '1',
+              type: 'arrayRelations',
+              content: 'Hey',
+              attributes: 'Keep me'
+            }
+          ]
+        }
       })
       expect(input).toEqual({
         data: {
@@ -450,5 +462,82 @@ describe('kitsu-core', () => {
       const input = serialise('posts', resource)
       expect(input).toEqual({ data: resourceOutput })
     })
+
+    it('uses the new system', () => {
+      expect.assertions(1)
+      const input = {
+        id: '1',
+        type: 'libraryEntries',
+        links: { self: 'library-entries/1' },
+        ratingTwenty: 10,
+        user: {
+          links: {
+            self: 'library-entries/1/relationships/user',
+            related: 'library-entries/1/user'
+          },
+          meta: { some: 'meta info' },
+          data: {
+            id: '2',
+            type: 'users',
+            name: 'Example',
+            links: { self: 'users/2' }
+          }
+        },
+        unit: {
+          links: {
+            self: 'library-entries/1/relationships/unit',
+            related: 'library-entries/1/unit'
+          },
+          meta: { extra: 'info' },
+          data: [
+            {
+              id: '3',
+              type: 'episodes',
+              number: 12,
+              links: { self: 'episodes/3' }
+            }
+          ]
+        }
+      }
+      const output = {
+        data: {
+          id: '1',
+          type: 'libraryEntries',
+          links: { self: 'library-entries/1' },
+          attributes: { ratingTwenty: 10 },
+          relationships: {
+            user: {
+              links: {
+                self: 'library-entries/1/relationships/user',
+                related: 'library-entries/1/user'
+              },
+              meta: { some: 'meta info' },
+              data: {
+                id: '2',
+                type: 'users',
+                attributes: { name: 'Example' },
+                links: { self: 'users/2' }
+              }
+            },
+            unit: {
+              links: {
+                self: 'library-entries/1/relationships/unit',
+                related: 'library-entries/1/unit'
+              },
+              meta: { extra: 'info' },
+              data: [
+                {
+                  id: '3',
+                  type: 'episodes',
+                  attributes: { number: 12 },
+                  links: { self: 'episodes/3' }
+                }
+              ]
+            }
+          }
+        }
+      }
+      expect(serialise('libraryEntries', input)).toStrictEqual(output)
+    })
   })
 })