@modernpoacher/halacious 7.0.3 → 7.0.4

package/src/representation.mjs

@@ -1,8 +1,13 @@
-import _ from 'lodash'
 import * as hoek from '@hapi/hoek'
 import URI from 'urijs'
 
-const templatedRE = /{*}/
+import {
+  getSelf,
+  getHref,
+  getPrefix
+} from './utils.mjs'
+
+const TEMPLATE = /{*}/
 
 /**
  * A HAL wrapper interface around an entity. Provides an api for adding new links and recursively embedding child
@@ -15,34 +20,104 @@ const templatedRE = /{*}/
  * @constructor
  */
 export class Representation {
-  constructor (factory, self, entity, root) {
-    this._halacious = factory._halacious
+  constructor (factory, self, entity, root = this) {
+    const {
+      _halacious: halacious,
+      _request: request
+    } = factory
+
+    const {
+      href
+    } = self
+
+    const links = {
+      self
+    }
+
     this.factory = factory
-    this.request = factory._request
-    this._root = root || this
-    this.self = self.href
-    this._links = { self }
+    this.self = href
+    this.entity = entity
+    this._root = root
+    this._halacious = halacious
+    this._request = request
+    this._links = links
     this._embedded = {}
     this._namespaces = {}
-    this._props = {}
-    this._ignore = {}
-    this.entity = entity
+    this._props = new Map()
+    this._ignore = new Set()
+  }
+
+  getHalacious () {
+    return this._halacious
+  }
+
+  getRequest () {
+    return this._request
+  }
+
+  getRoot () {
+    return this._root
+  }
+
+  getLinks () {
+    return this._links
+  }
+
+  getEmbedded () {
+    return this._embedded
+  }
+
+  getNamespaces () {
+    return this._namespaces
+  }
+
+  getProps () {
+    return this._props
+  }
+
+  getIgnore () {
+    return this._ignore
+  }
+
+  get halacious () {
+    return this._halacious
+  }
+
+  get request () {
+    return this._request
   }
 
   /**
    * Adds a namespace to the 'curie' link collection. all curies in a response, top level or nested, should be declared
    * in the top level _links collection. a reference '_root' is kept to the top level representation for this purpose
+   *
    * @param namespace
    */
   curie (namespace) {
-    if (namespace && !this._root._namespaces[namespace.prefix]) {
-      this._root._namespaces[namespace.prefix] = namespace
-      this._root._links.curies = this._root._links.curies || []
-      this._root._links.curies.push({
-        name: namespace.prefix,
-        href: `${this._halacious.namespaceUrl(this.request, namespace)}/{rel}`,
+    if (namespace) {
+      const root = this.getRoot()
+
+      const namespaces = root.getNamespaces()
+
+      const prefix = getPrefix(namespace)
+
+      if (Reflect.has(namespaces, prefix)) return
+
+      Reflect.set(namespaces, prefix, namespace)
+
+      const links = root.getLinks()
+
+      const curies = Reflect.get(links, 'curies') ?? []
+
+      const request = this.getRequest()
+
+      const namespaceUrl = this.getHalacious().namespaceUrl(request, namespace)
+
+      Reflect.set(links, 'curies', curies.concat({
+        name: prefix,
+        href: `${namespaceUrl}/{rel}`,
         templated: true
-      })
+      }))
     }
   }
 
@@ -53,121 +128,173 @@ export class Representation {
    * @return {Representation}
    */
   prop (name, value) {
-    this._props[name] = value
+    this.getProps()
+      .set(name, value)
+
     return this
   }
 
   /**
-   * Merges an object's properties into the custom properties collection.
+   * Merges an object's properties into the custom properties collection
+   *
    * @param prop
    */
   merge (prop) {
-    hoek.merge(this._props, prop)
+    const props = this.getProps()
+
+    Object
+      .entries(prop)
+      .forEach(([name, value]) => {
+        props.set(name, value)
+      })
+
+    return this
   }
 
   /**
    * @param {...String || String[]} args properties to ignore
    * @return {Representation}
    */
-  ignore (...args) {
-    const props = _.isArray(args[0]) ? args[0] : args
-    props.forEach(function (prop) {
-      this._ignore[prop] = true
-    }, this)
+  ignore (arg, ...args) {
+    const props = (
+      Array.isArray(arg)
+        ? arg
+        : [arg].concat(args)
+    )
+
+    const ignore = this.getIgnore()
+
+    props
+      .filter(Boolean)
+      .forEach((prop) => {
+        ignore.add(prop)
+      })
+
     return this
   }
 
   /**
-   * Prepares the representation for JSON serialization.
+   * Prepares the representation for JSON serialization
+   *
    * @return {{}}
    */
   toJSON () {
     // initialize the json entity
-    const payload = { _links: this._links }
-    const self = this
+    const object = { _links: this.getLinks() }
 
     // copy all target properties in the entity using JSON.stringify(). if the entity has a .toJSON() implementation,
     // it will be called. properties on the ignore list will not be copied
-    const { entity } = this
+    const {
+      entity
+    } = this
+
+    const ignore = this.getIgnore()
+
     JSON.stringify(entity, (key, value) => {
       if (!key) {
         return value
       }
-      if (!self._ignore[key]) {
-        payload[key] = value
-      }
+
+      if (!ignore.has(key)) Reflect.set(object, key, value)
     })
 
+    const props = this.getProps()
+
     // merge in any extra properties
-    _.assign(payload, this._props)
-
-    const embeddedKeys = _.keys(this._embedded)
-    if (embeddedKeys.length > 0) {
-      payload._embedded = {}
-
-      const self = this
-      embeddedKeys.forEach((embedKey) => {
-        if (self._embedded[embedKey] instanceof Representation) {
-          payload._embedded[embedKey] = {}
-        } else if (self._embedded[embedKey] instanceof Array) {
-          payload._embedded[embedKey] = []
-        }
-
-        JSON.stringify(self._embedded[embedKey], (key, value) => {
-          if (!key) {
-            return value
-          }
-
-          payload._embedded[embedKey][key] = value
-        })
-      })
+    Object.assign(object, Object.fromEntries(Array.from(props.entries()).filter(([key]) => !ignore.has(key))))
+
+    const embedded = this.getEmbedded()
+
+    const entries = Object.entries(embedded)
+    if (entries.length) {
+      object._embedded = (
+        entries
+          .reduce((accumulator, [entryKey, entryValue]) => {
+            let currentValue
+
+            if (entryValue instanceof Representation) {
+              currentValue = {}
+            } else {
+              if (Array.isArray(entryValue)) {
+                currentValue = []
+              }
+            }
+
+            JSON.stringify(entryValue, (key, value) => {
+              if (!key) {
+                return value
+              }
+
+              if (!ignore.has(key)) Reflect.set(currentValue, key, value)
+            })
+
+            return (
+              Object.assign(accumulator, { [entryKey]: currentValue })
+            )
+          }, {})
+      )
     }
 
-    return payload
+    return object
   }
 
   /**
    * Creates a new link and adds it to the _links collection
+   *
    * @param rel
    * @param link
    * @return {{} || []} the new link
    */
-  link (originalRel, link) {
-    const rel = this._halacious.rel(originalRel)
-    const qname = rel.qname()
-
-    if (_.isArray(link)) {
-      const that = this
-      this._links[qname] = []
-      return link.map((l) => that.link(originalRel, l), this)
+  link (relName, link) {
+    const halacious = this.getHalacious()
+
+    const rel = halacious.rel(relName)
+    const key = rel.qname()
+
+    const links = this.getLinks()
+
+    if (Array.isArray(link)) {
+      if (!Reflect.has(links, key)) Reflect.set(links, key, [])
+
+      return (
+        link.map((href) => this.link(relName, href))
+      )
     }
 
     // adds the namespace to the top level curie list
     this.curie(rel.namespace)
 
-    link = this._halacious.link(link, this._links.self.href)
-    link.templated = templatedRE.test(link.href) ? true : undefined
+    const href = getHref(getSelf(links)) ?? ''
+
+    link = halacious.link(link, href)
+
+    if (TEMPLATE.test(link.href)) link.templated = true
+
     // e.g. 'mco:rel'
-    if (!this._links[qname]) {
-      this._links[qname] = link
-    } else if (_.isArray(this._links[qname])) {
-      this._links[qname].push(link)
-    } else {
-      this._links[qname] = [this._links[qname], link]
-    }
+
+    Reflect.set(links, key, (
+      Reflect.has(links, key)
+        ? [].concat(Reflect.get(links, key), link)
+        : link
+    ))
 
     return link
   }
 
   /**
    * Resolves a relative path against the representation's self href
+   *
    * @param relativePath
    * @return {*}
    */
   resolve (relativePath) {
-    return new URI(relativePath)
-      .absoluteTo(`${this._links.self.href}/`)
-      .toString()
+    const href = getHref(getSelf(this.getLinks())) ?? ''
+
+    return (
+      new URI(relativePath)
+        .absoluteTo(href.concat('/'))
+        .toString()
+    )
   }
 
   /**
@@ -178,7 +305,9 @@ export class Representation {
    * @return {*}
    */
   route (routeName, params) {
-    return this._halacious.route(routeName, params)
+    return (
+      this.getHalacious().route(routeName, params)
+    )
   }
 
   /**
@@ -188,45 +317,62 @@ export class Representation {
    * @param {{} || []} entity an object to wrap
    * @return {entity || []}
    */
-  embed (originalRel, self, entity) {
-    const rel = this._halacious.rel(originalRel)
-    const qname = rel.qname()
+  embed (relName, self, entity) {
+    const halacious = this.getHalacious()
+
+    const rel = halacious.rel(relName)
+    const key = rel.qname()
 
     this.curie(rel.namespace)
 
-    if (_.isArray(entity)) {
-      const that = this
-      this._embedded[qname] = []
-      return entity.map((e) => that.embed(originalRel, self, e), this)
+    const embedded = this.getEmbedded()
+
+    if (Array.isArray(entity)) {
+      if (!Reflect.has(embedded, key)) Reflect.set(embedded, key, [])
+
+      return (
+        entity.map((entity) => this.embed(relName, self, entity))
+      )
     }
 
-    self = this._halacious.link(self, this._links.self.href)
+    const href = getHref(getSelf(this.getLinks())) ?? ''
 
-    const embedded = this.factory.create(entity, self, this._root)
+    self = halacious.link(self, href)
 
-    if (!this._embedded[qname]) {
-      this._embedded[qname] = embedded
-    } else if (_.isArray(this._embedded[qname])) {
-      this._embedded[qname].push(embedded)
-    } else {
-      this._embedded[qname] = [this._embedded[qname], embedded]
-    }
+    const root = this.getRoot()
+
+    const embed = this.factory.create(entity, self, root)
+
+    Reflect.set(embedded, key, (
+      Reflect.has(embedded, key)
+        ? [].concat(Reflect.get(embedded, key), embed)
+        : embed
+    ))
 
-    return embedded
+    return embed
   }
 
   /**
-   * Convenience method for embedding an array of entities
+   * Convenience method for embedding an entity or array of entities
+   *
    * @param rel
    * @param self
-   * @param entities
+   * @param arg
    * @return {Representation}
    */
-  embedCollection (rel, self, entities) {
-    entities = _.isArray(entities) ? entities : [entities]
-    entities.forEach(function (entity) {
-      this.embed(rel, hoek.clone(self), entity)
-    }, this)
+  embedCollection (rel, self, arg, ...args) {
+    const entities = (
+      Array.isArray(arg)
+        ? arg
+        : [arg].concat(args)
+    )
+
+    entities
+      .filter(Boolean)
+      .forEach((entity) => {
+        this.embed(rel, hoek.clone(self), entity)
+      })
+
     return this
   }
 
@@ -236,12 +382,13 @@ export class Representation {
    * @param callback
    */
   configure (config, callback) {
-    this._halacious.configureRepresentation(this, config, callback)
+    this.getHalacious().configureRepresentation(config, this, callback)
   }
 }
 
 /**
- * Responsible for creating all hal entities, top level or embedded, needed for a hapi request
+ * Responsible for creating all hal entities, top level or embedded, needed for a Hapi request
+ *
  * @param halacious a reference to the plugin api
  * @param request a hapi request object
  * @constructor
@@ -252,6 +399,30 @@ export class RepresentationFactory {
     this._request = request
   }
 
+  getHalacious () {
+    return this._halacious
+  }
+
+  getRequest () {
+    return this._request
+  }
+
+  getRequestPath () {
+    return this.getRequest()?.path
+  }
+
+  get halacious () {
+    return this._halacious
+  }
+
+  get request () {
+    return this._request
+  }
+
+  get requestPath () {
+    return this.request?.path
+  }
+
   /**
    * Creates a new hal representation out of a javascript object
    * @param {{}=} entity the entity to wrap with a representation. an empty object is created by default
@@ -260,11 +431,14 @@ export class RepresentationFactory {
    * should be expanded into absolute urls
    * @return {Representation}
    */
-  create (entity, self, root) {
-    entity = entity || {}
-    self = self || (this._request && this._request.path)
-    self = this._halacious.link(self)
-    return new Representation(this, self, entity, root)
+  create (entity = {}, self = this.getRequestPath(), root) {
+    const halacious = this.getHalacious()
+
+    const link = halacious.link(self)
+
+    return (
+      new Representation(this, link, entity, root)
+    )
   }
 }
 

package/src/utils/getFieldValueByPath.mjs

@@ -0,0 +1,20 @@
+function reduce (accumulator, fieldName) {
+  return (
+    Reflect.has(accumulator, fieldName)
+      ? Reflect.get(accumulator, fieldName)
+      : accumulator
+  )
+}
+
+/**
+ *  Previously `reach`
+ */
+export default function getFieldValueByPath (path = '', context = {}) {
+  const fieldNames = String(path ?? '').split('.')
+
+  return (
+    fieldNames
+      .filter(Boolean)
+      .reduce(reduce, context)
+  )
+}

package/src/utils/getMediaType.mjs

@@ -0,0 +1,15 @@
+import Negotiator from 'negotiator'
+
+/**
+ * Selects the media type based on the request's Accept header and a ranked ordering of configured
+ * media types
+ *
+ * @param request
+ * @param mediaTypes
+ * @return {*}
+ */
+export default function getMediaType (request, mediaTypes) {
+  return (
+    new Negotiator(request).mediaType([].concat(mediaTypes))
+  )
+}

package/src/utils/getTemplateContext.mjs

@@ -0,0 +1,32 @@
+import getFieldValueByPath from './getFieldValueByPath.mjs'
+
+const REG = /{([^{}]+)}|([^{}]+)/g
+
+/**
+ * Evaluates and flattens deep expressions (e.g. '/{foo.a.b}') into a single level context object: {'foo.a.b': value}
+ * so that it may be used by url-template library
+ *
+ * @param template
+ * @param context
+ * @return {{}}
+ */
+export default function getTemplateContext (template, context) {
+  const templateContext = {}
+  let matches
+
+  while ((matches = REG.exec(template))) {
+    if (Array.isArray(matches)) {
+      const [
+        , // input,
+        path
+      ] = matches
+
+      if (path) {
+        const fieldValue = getFieldValueByPath(path, context)
+        if (fieldValue) Reflect.set(templateContext, path, fieldValue.toString())
+      }
+    }
+  }
+
+  return templateContext
+}