fix linting and apply isAttribute in _deattribute

Author: pedep

packages/kitsu-core/src/components/deattribute.spec.ts

@@ -1,8 +1,9 @@
 import test from 'ava'
 
 import { deattribute } from '../index.js'
+import { ResourceObject } from '../resources/resourceObject.js'
 
-test('deattribute', t => {
+test('deattributes a valid ResourceObject', t => {
   t.deepEqual(
     deattribute({
       id: '1',
@@ -35,7 +36,7 @@ test('deattribute', t => {
   )
 })
 
-test('deattribute with attributes.attributes', t => {
+test('deattributes a ResourceObject when attributes has the key "attributes"', t => {
   t.deepEqual(
     deattribute({
       id: '2',
@@ -60,7 +61,7 @@ test('deattribute with attributes.attributes', t => {
   )
 })
 
-test('deattribute array', t => {
+test('deattributes arrays of ResourceObject', t => {
   t.deepEqual(
     deattribute([
       {
@@ -88,3 +89,20 @@ test('deattribute array', t => {
     ]
   )
 })
+
+// subject to change
+const fun = () => 'im a function'
+test('performs no operation on a ResourceObject with invalid attributes', t => {
+  t.deepEqual(
+    deattribute({
+      id: '1',
+      type: 'test',
+      attributes: fun
+    } as ResourceObject),
+    {
+      id: '1',
+      type: 'test',
+      attributes: fun
+    }
+  )
+})

packages/kitsu-core/src/components/deattribute.ts

@@ -1,26 +1,46 @@
-import { Attributes, isAttributes } from "../resources/attributes.js";
-import { ResourceIdentifier } from "../resources/resource-identifier.js";
-import { ResourceObject } from "../resources/resource-object.js";
+import { Attributes, isAttributes } from '../resources/attributes.js'
+import { ResourceIdentifier } from '../resources/resourceIdentifier.js'
+import { ResourceObject } from '../resources/resourceObject.js'
 
-export type DeattributedResourceObject = ResourceIdentifier & Attributes;
+export type DeattributedResourceObject = ResourceIdentifier & Attributes
 
 // Write a function that hoists the attributes of a given object to the top level
-export function deattribute(data: ResourceObject): DeattributedResourceObject;
-export function deattribute(data: ResourceObject[]): DeattributedResourceObject[];
-export function deattribute(data: ResourceObject | ResourceObject[]): DeattributedResourceObject | DeattributedResourceObject[] {
-  return isResourceObjectArray(data) ? data.map(_deattribute) : _deattribute(data);
+export function deattribute(data: ResourceObject): DeattributedResourceObject
+export function deattribute(
+  data: ResourceObject[]
+): DeattributedResourceObject[]
+export function deattribute(
+  data: ResourceObject | ResourceObject[]
+): DeattributedResourceObject | DeattributedResourceObject[] {
+  return isResourceObjectArray(data)
+    ? data.map(_deattribute)
+    : _deattribute(data)
 }
 
 function _deattribute(data: ResourceObject): DeattributedResourceObject {
+  // FIXME: what is the best behaviour when given an invalid attributes key?
+  // 1. (Current) the same invalid object is returned.
+  //   a. This results in deattribute returning potentially invalid DeattributedResourceObjects
+  // 2. the object is modified, and has the invalid key removed
+  //   a. This would guarantee valid returns, but will also change the current default behaviour.
+  // 3. the object is not touched, and an error is thrown
+  //   a. this would function closer to how JSON.parse does, throwing errors when unexpected input is given
+  //
+  // This should not be an issue for projects using typescript natively, since the compiler will warn when passing
+  // objects with mismatched types to deattribute
+  if (!isAttributes(data.attributes)) return data as DeattributedResourceObject
+
   const output = {
     ...data,
     ...data.attributes
   }
 
   if (output.attributes === data.attributes) delete output.attributes
-  return output;
+  return output
 }
 
-function isResourceObjectArray(obj: ResourceObject | ResourceObject[]): obj is ResourceObject[] {
-  return Array.isArray(obj)
+function isResourceObjectArray(
+  object: ResourceObject | ResourceObject[]
+): object is ResourceObject[] {
+  return Array.isArray(object)
 }

packages/kitsu-core/src/components/deepEqual.spec.ts

@@ -25,25 +25,25 @@ const people = {
   five: {
     address: {
       street: '123 Main St',
-      inhabitants: ['Chuck', 'Howard', {name: "Jimmy", age: 35}]
+      inhabitants: ['Chuck', 'Howard', { name: 'Jimmy', age: 35 }]
     }
   },
   six: {
     address: {
       street: '123 Main St',
-      inhabitants: ['Chuck', 'Howard', {name: "Jimmy", age: 35}]
+      inhabitants: ['Chuck', 'Howard', { name: 'Jimmy', age: 35 }]
     }
   },
   seven: {
     address: {
       street: '456 Main St',
-      inhabitants: ['Chuck', 'Howard', {name: "Jimmy", age: 35}]
+      inhabitants: ['Chuck', 'Howard', { name: 'Jimmy', age: 35 }]
     }
   },
   eight: {
     address: {
       street: '123 Main St',
-      inhabitants: ['Howard', {name: "Jimmy", age: 35}, 'Chuck']
+      inhabitants: ['Howard', { name: 'Jimmy', age: 35 }, 'Chuck']
     }
   }
 }

packages/kitsu-core/src/components/deepEqual.ts

@@ -1,4 +1,8 @@
-export const isDeepEqual = (left: any, right: any) => {
+// isDeepEqual is able to compare every possible input, so we allow explicit any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Comparable = any
+
+export function isDeepEqual(left: Comparable, right: Comparable): boolean {
   if (!left || !right) return left === right
 
   const leftKeys = Object.keys(left)
@@ -12,14 +16,17 @@ export const isDeepEqual = (left: any, right: any) => {
 
     const isObjects = isObject(leftValue) && isObject(rightValue)
 
-    if ((isObjects && !isDeepEqual(leftValue, rightValue)) || (!isObjects && leftValue !== rightValue)) {
+    if (
+      (isObjects && !isDeepEqual(leftValue, rightValue)) ||
+      (!isObjects && leftValue !== rightValue)
+    ) {
       return false
     }
   }
 
   return true
 }
 
-function isObject(obj: any): obj is object {
-  return obj != undefined && typeof obj === 'object'
+function isObject(object: unknown): object is object {
+  return object != undefined && typeof object === 'object'
 }

packages/kitsu-core/src/resources/attributes.ts

@@ -6,16 +6,25 @@
 
 // Valid JSON values
 // https://datatracker.ietf.org/doc/html/rfc8259#section-3
-export type JsonValues = object | number | string | false | null | true | Array<JsonValues>;
+export type JsonValues =
+  | object
+  | number
+  | string
+  | false
+  | null
+  | true
+  | Array<JsonValues>
 
 // https://datatracker.ietf.org/doc/html/rfc8259#section-4
 // "A name is a string"
 export interface Attributes {
-  [name: string]: JsonValues;
+  [name: string]: JsonValues
 }
 
-export function isAttributes(attrs: any): attrs is Attributes {
-  return typeof attrs.attributes === 'object' &&
-    attrs.attributes !== null &&
-    !Array.isArray(attrs.attributes)
+export function isAttributes(attributes: unknown): attributes is Attributes {
+  return (
+    typeof attributes === 'object' &&
+    attributes !== null &&
+    !Array.isArray(attributes)
+  )
 }

packages/kitsu-core/src/resources/resource-object.ts

@@ -6,13 +6,15 @@
 // > The value of the lid member MUST be identical for every representation of the resource in the document, including resource identifier objects.
 
 export interface LocalResourceIdentifier {
-  lid: string;
-  type: string;
+  lid: string
+  type: string
 }
 
 export interface RemoteResourceIdentifier {
-  id: string;
-  type: string;
+  id: string
+  type: string
 }
 
-export type ResourceIdentifier = LocalResourceIdentifier | RemoteResourceIdentifier;
+export type ResourceIdentifier =
+  | LocalResourceIdentifier
+  | RemoteResourceIdentifier

packages/kitsu-core/src/resources/resource-identifier.ts renamed to packages/kitsu-core/src/resources/resourceIdentifier.ts

@@ -0,0 +1,15 @@
+import { Attributes } from './attributes.js'
+import { ResourceIdentifier } from './resource-identifier.js'
+
+type Relationships = void
+type Links = void
+type Meta = void
+
+export interface ResourceObjectFields {
+  attributes?: Attributes
+  relationships?: Relationships
+  links?: Links
+  meta?: Meta
+}
+
+export type ResourceObject = ResourceObjectFields & ResourceIdentifier