shinkansen-transmission 2.3.5 → 2.4.0

package/src/transmission/from-hash-to-document/index.mjs

@@ -4,7 +4,7 @@
  *  @typedef {TransmissionTypes.ArrayLiteralType} ArrayLiteralType
  *  @typedef {TransmissionTypes.ArrayType} ArrayType
  *
- *  @typedef {TransmissionTypes.ItemsType} ItemsType
+ *  @typedef {TransmissionTypes.MemberArrayType} MemberArrayType
  *
  *  @typedef {TransmissionTypes.DocumentType} DocumentType
  *  @typedef {TransmissionTypes.SchemaType} SchemaType
@@ -16,7 +16,6 @@ import debug from 'debug'
 import {
   isArray,
   isObject,
-  isPrimitive,
   hasEnum,
   getEnum,
   hasAnyOf,
@@ -27,96 +26,57 @@ import {
   transformToValue
 } from '#transmission/transmission/common'
 
-const log = debug('shinkansen-transmission/from-hash-to-document')
-
-log('`shinkansen` is awake')
-
-/**
- *  @param {unknown} v
- *  @returns {null}
- */
-export function toNull (v) {
-  if (v === null || v === 'null') return null
-
-  throw new Error('Invalid `null`')
-}
+import {
+  fromHashToArray
+} from '#transmission/transmission/common/transform'
 
-/**
- *  @param {unknown} v
- *  @returns {boolean}
- */
-export function toBoolean (v) {
-  if (typeof v === 'boolean') return v
-  if (v === 'true') return true
-  if (v === 'false') return false
+import {
+  transformString
+} from './string/index.mjs'
 
-  throw new Error('Invalid `boolean`')
-}
+import {
+  transformNumber
+} from './number/index.mjs'
 
-/**
- *  @param {unknown} v
- *  @returns {string}
- */
-export function toString (v) {
-  if (typeof v === 'string') return v
-  if (typeof v === 'number') return String(v)
+import {
+  transformBoolean
+} from './boolean/index.mjs'
 
-  return JSON.stringify(v)
+import {
+  transformNull
+} from './null/index.mjs'
+
+export { default as transformStringSchema } from './string/index.mjs'
+export { default as transformNumberSchema } from './number/index.mjs'
+export { default as transformBooleanSchema } from './boolean/index.mjs'
+export { default as transformNullSchema } from './null/index.mjs'
+
+export {
+  transformString,
+  transformNumber,
+  transformBoolean,
+  transformNull
 }
 
-/**
- *  @param {unknown} v
- *  @returns {number}
- */
-export function toNumber (v) {
-  if (typeof v === 'number') return v
-  if (typeof v === 'boolean') return Number(v)
-
-  if (v) { // excludes zero-length strings
-    const n = (
-      isPrimitive(v) // excludes objects and arrays
-        ? Number(v) // +v // unary operator
-        : NaN
-    )
-
-    if (!isNaN(n)) return n
-  }
-
-  throw new Error('Invalid `number`')
-}
+const log = debug('shinkansen-transmission/from-hash-to-document')
 
-function handleError ({ message = 'No error message defined' }) { log(message) }
+log('`shinkansen` is awake')
 
 export { transformToValue }
 
 /**
  *  @param {HashType} hash
- *  @param {string} parentUri
- *  @returns {(document: ObjectLiteralType | ObjectType, entry: [key: string, schema: SchemaType]) => ObjectLiteralType | ObjectType}
- */
-function getReducePropertiesEntriesFor (hash, parentUri) {
-  /**
-   *  @param {ObjectLiteralType | ObjectType} document
-   *  @param {[key: string, schema: SchemaType]} entry
-   *  @returns {ObjectLiteralType | ObjectType}
-   */
-  return function reduce (document, [key, schema]) {
-    const schemaUri = getUri(parentUri, key)
-
-    document[key] = transform(hash, schema, schemaUri, schemaUri)
-
-    return document
-  }
-}
-
-/**
- *  @param {HashType} hash
- *  @param {SchemaType[]} items
+ *  @param {SchemaType[]} itemSchemas
  *  @param {string} parentUri
  *  @param {string} uri
  *  @returns {(document: ArrayLiteralType | ArrayType, key: string) => ArrayLiteralType | ArrayType}
  */
-function getReduceItemsArrayFor (hash, items, parentUri, uri) {
+function getReduceItemsArrayFor (hash, itemSchemas, parentUri, uri) {
+  /**
+   *  @param {ArrayLiteralType | ArrayType} document
+   *  @param {string} key
+   *  @returns {ArrayLiteralType | ArrayType}
+   */
   return function reduce (document, key) {
     const v = uri.endsWith('/') ? key.slice(uri.length) : key.slice(uri.length + 1)
     const i = v ? Number(v.includes('/') ? v.slice(0, v.indexOf('/')) : v) : NaN
@@ -124,7 +84,7 @@ function getReduceItemsArrayFor (hash, items, parentUri, uri) {
     if (!isNaN(i)) {
       const schemaUri = getUri(parentUri, i)
 
-      document[i] = transform(hash, items[i], schemaUri, schemaUri) // items
+      document[i] = fromHashToDocument(hash, itemSchemas[i], schemaUri, schemaUri) // items
     }
 
     return document
@@ -133,12 +93,17 @@ function getReduceItemsArrayFor (hash, items, parentUri, uri) {
 
 /**
  *  @param {HashType} hash
- *  @param {SchemaType} items
+ *  @param {SchemaType} itemSchema
  *  @param {string} parentUri
  *  @param {string} uri
  *  @returns {(document: ArrayLiteralType | ArrayType, key: string) => ArrayLiteralType | ArrayType}
  */
-function getReduceItemsObjectFor (hash, items, parentUri, uri) {
+function getReduceItemsObjectFor (hash, itemSchema, parentUri, uri) {
+  /**
+   *  @param {ArrayLiteralType | ArrayType} document
+   *  @param {string} key
+   *  @returns {ArrayLiteralType | ArrayType}
+   */
   return function reduce (document, key) {
     const v = uri.endsWith('/') ? key.slice(uri.length) : key.slice(uri.length + 1)
     const i = v ? Number(v.includes('/') ? v.slice(0, v.indexOf('/')) : v) : NaN
@@ -146,111 +111,21 @@ function getReduceItemsObjectFor (hash, items, parentUri, uri) {
     if (!isNaN(i)) {
       const schemaUri = getUri(parentUri, i)
 
-      document[i] = transform(hash, items, schemaUri, schemaUri) // items
+      document[i] = fromHashToDocument(hash, itemSchema, schemaUri, schemaUri) // items
     }
 
     return document
   }
 }
 
-/**
- *  @param {DocumentType} document
- *  @param {ItemsType} [array]
- *  @returns {DocumentType | undefined}
- */
-export function transformToValueFor (document, array = []) {
-  /*
-   *  log('transformToValueFor')
-   */
-
-  const i = toNumber(document)
-
-  if (i in array) { // @ts-ignore
-    const v = array[i]
-
-    /*
-     *  Return the document according to the schema `v` or, if `v` is a primitive, return that
-     */
-    return transformToValue(v)
-  }
-
-  throw new Error('Invalid `document`')
-}
-
-/**
- *  @param {HashType} hash
- *  @param {ItemsType} [array]
- *  @param {string} [uri]
- *  @returns {string | number | object | boolean | null | []}
- */
-export function getArrayFor (hash, array = [], uri = '#') {
-  /*
-   *  log('getArrayFor')
-   */
-
-  if (uri in hash) {
-    const v = hash[uri]
-    const i = Number(v)
-
-    if (!isNaN(i)) return array[i]
-  }
-
-  return []
-}
-
 /**
  *  @param {HashType} hash
- *  @param {SchemaType} [schema]
+ *  @param {SchemaType[]} [itemSchemas]
  *  @param {string} parentUri
  *  @param {string} uri
- *  @returns {DocumentType | undefined}
- */
-export function transformArrayFor (hash, { items } = {}, parentUri = '#', uri = getUri(parentUri)) {
-  /*
-   *  log('transformArrayFor')
-   */
-
-  if (isArray(items)) {
-    return transformItemsArrayFor(hash, items, parentUri, uri)
-  } else {
-    if (isObject(items)) {
-      return transformItemsObjectFor(hash, items, parentUri, uri)
-    }
-  }
-
-  return []
-}
-
-/**
- *  @param {HashType} hash
- *  @param {SchemaType} [schema]
- *  @param {string} [parentUri]
  *  @returns {DocumentType}
  */
-export function transformObjectFor (hash, { properties } = {}, parentUri = '#') { // }, uri = getUri(parentUri)) {
-  /*
-   *  log('transformObjectFor')
-   */
-
-  if (isObject(properties)) {
-    return (
-      Object
-        .entries(properties)
-        .reduce(getReducePropertiesEntriesFor(hash, parentUri), {})
-    )
-  }
-
-  return {}
-}
-
-/**
- *  @param {HashType} hash
- *  @param {SchemaType[]} [items]
- *  @param {string} parentUri
- *  @param {string} uri
- *  @returns {DocumentType}
- */
-export function transformItemsArrayFor (hash, items = [], parentUri = '#', uri = getUri(parentUri)) {
+function transformItemsArrayFor (hash, itemSchemas = [], parentUri = '#', uri = getUri(parentUri)) {
   /*
    *  log('transformItemsArrayFor')
    */
@@ -259,7 +134,7 @@ export function transformItemsArrayFor (hash, items = [], parentUri = '#', uri =
     const document = hash[uri] // Reflect.get(hash, uri)
 
     if (isArray(document)) {
-      return items.map((item, i) => transform(hash, item, uri, getUri(uri, i)))
+      return itemSchemas.map((itemSchema, i) => fromHashToDocument(hash, itemSchema, uri, getUri(uri, i)))
     }
   }
 
@@ -267,18 +142,18 @@ export function transformItemsArrayFor (hash, items = [], parentUri = '#', uri =
     Object
       .keys(hash)
       .filter((key) => key.startsWith(uri))
-      .reduce(getReduceItemsArrayFor(hash, items, parentUri, uri), [])
+      .reduce(getReduceItemsArrayFor(hash, itemSchemas, parentUri, uri), [])
   )
 }
 
 /**
  *  @param {HashType} hash
- *  @param {SchemaType} [items]
+ *  @param {SchemaType} [itemSchema]
  *  @param {string} parentUri
  *  @param {string} uri
  *  @returns {DocumentType | undefined}
  */
-export function transformItemsObjectFor (hash, items = {}, parentUri = '#', uri = getUri(parentUri)) {
+function transformItemsObjectFor (hash, itemSchema = {}, parentUri = '#', uri = getUri(parentUri)) {
   /*
    *  log('transformItemsObjectFor')
    */
@@ -287,7 +162,7 @@ export function transformItemsObjectFor (hash, items = {}, parentUri = '#', uri
     const document = hash[uri] // Reflect.get(hash, uri)
 
     if (isArray(document)) {
-      return transform(hash, items, uri, uri)
+      return fromHashToDocument(hash, itemSchema, uri, uri)
     }
   }
 
@@ -295,102 +170,31 @@ export function transformItemsObjectFor (hash, items = {}, parentUri = '#', uri
     Object
       .keys(hash)
       .filter((key) => key.startsWith(uri))
-      .reduce(getReduceItemsObjectFor(hash, items, parentUri, uri), [])
+      .reduce(getReduceItemsObjectFor(hash, itemSchema, parentUri, uri), [])
   )
 }
 
 /**
  *  @param {HashType} hash
- *  @param {SchemaType} schema
+ *  @param {SchemaType} [schema]
  *  @param {string} parentUri
  *  @param {string} uri
  *  @returns {DocumentType | undefined}
  */
-export function transformNull (hash, schema, parentUri, uri) {
+export function transformArrayFor (hash, { items } = {}, parentUri = '#', uri = getUri(parentUri)) {
   /*
-   *  log('transformNull')
+   *  log('transformArrayFor')
    */
 
-  if (uri in hash) { // Reflect.has(hash, uri)) {
-    const document = hash[uri] // Reflect.get(hash, uri)
-
-    if (hasEnum(schema)) {
-      const array = getEnum(schema)
-
-      if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-      return transformToValueFor(document, array)
-    } else {
-      if (hasAnyOf(schema)) {
-        const array = getAnyOf(schema)
-
-        if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-        return transformToValueFor(document, array)
-      } else {
-        if (hasOneOf(schema)) {
-          const array = getOneOf(schema)
-
-          if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-          return transformToValueFor(document, array)
-        }
-      }
-    }
-
-    try {
-      if (isArray(document)) return document.map(toNull)
-      return toNull(document)
-    } catch (e) {
-      handleError(e)
+  if (isArray(items)) {
+    return transformItemsArrayFor(hash, items, parentUri, uri)
+  } else {
+    if (isObject(items)) {
+      return transformItemsObjectFor(hash, items, parentUri, uri)
     }
-
-    return document
   }
-}
-
-/**
- *  @param {HashType} hash
- *  @param {SchemaType} schema
- *  @param {string} parentUri
- *  @param {string} uri
- *  @returns {DocumentType | undefined}
- */
-export function transformBoolean (hash, schema, parentUri, uri) {
-  /*
-   *  log('transformBoolean')
-   */
 
-  if (uri in hash) { // Reflect.has(hash, uri)) {
-    const document = hash[uri] // Reflect.get(hash, uri)
-
-    if (hasEnum(schema)) {
-      const array = getEnum(schema)
-
-      if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-      return transformToValueFor(document, array)
-    } else {
-      if (hasAnyOf(schema)) {
-        const array = getAnyOf(schema)
-
-        if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-        return transformToValueFor(document, array)
-      } else {
-        if (hasOneOf(schema)) {
-          const array = getOneOf(schema)
-
-          if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-          return transformToValueFor(document, array)
-        }
-      }
-    }
-
-    try {
-      if (isArray(document)) return document.map(toBoolean)
-      return toBoolean(document)
-    } catch (e) {
-      handleError(e)
-    }
-
-    return document
-  }
+  return []
 }
 
 /**
@@ -400,110 +204,112 @@ export function transformBoolean (hash, schema, parentUri, uri) {
  *  @param {string} uri
  *  @returns {DocumentType | undefined}
  */
-export function transformObject (hash, schema, parentUri, uri) {
+export function transformArray (hash, schema, parentUri, uri) {
   /*
-   *  log('transformObject')
+   *  log('transformArray')
    */
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
 
-    return getArrayFor(hash, array, uri)
+    return (
+      transformToValue(
+        fromHashToArray(hash, uri, array)
+      )
+    )
   } else {
     if (hasAnyOf(schema)) {
       const array = getAnyOf(schema)
 
-      return getArrayFor(hash, array, uri)
+      return (
+        transformToValue(
+          fromHashToArray(hash, uri, array)
+        )
+      )
     } else {
       if (hasOneOf(schema)) {
         const array = getOneOf(schema)
 
-        return getArrayFor(hash, array, uri)
+        return (
+          transformToValue(
+            fromHashToArray(hash, uri, array)
+          )
+        )
       }
     }
   }
 
-  return transformObjectFor(hash, schema, parentUri) // , uri)
+  return transformArrayFor(hash, schema, parentUri, uri)
 }
 
 /**
- *  @param {HashType} hash
- *  @param {SchemaType} schema
- *  @param {string} parentUri
- *  @param {string} uri
- *  @returns {DocumentType | undefined}
+ *  Hash can be `undefined`
+ *
+ *  @param {HashType} [hash]
+ *  @param {SchemaType} [schema]
+ *  @param {ParamsType} [params]
+ *  @returns {DocumentType}
  */
-export function transformArray (hash, schema, parentUri, uri) {
-  /*
-   *  log('transformArray')
-   */
-
-  if (hasEnum(schema)) {
-    const array = getEnum(schema)
+export function transformArraySchema (hash = {}, schema = {}, params = {}) {
+  log('transformArraySchema')
 
-    return getArrayFor(hash, array, uri)
-  } else {
-    if (hasAnyOf(schema)) {
-      const array = getAnyOf(schema)
+  const {
+    type
+  } = schema
 
-      return getArrayFor(hash, array, uri)
-    } else {
-      if (hasOneOf(schema)) {
-        const array = getOneOf(schema)
+  // https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1
+  if (type === 'array') {
+    const {
+      uri: parentUri = '#',
+      index: arrayIndex // number | undefined
+    } = params
 
-        return getArrayFor(hash, array, uri)
-      }
-    }
+    return transformArray(hash, schema, parentUri, getUri(parentUri, arrayIndex))
   }
 
-  return transformArrayFor(hash, schema, parentUri, uri)
+  throw new Error('Schema does not conform to Instance Data Model, https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1')
 }
 
 /**
  *  @param {HashType} hash
- *  @param {SchemaType} schema
  *  @param {string} parentUri
- *  @param {string} uri
- *  @returns {DocumentType | undefined}
+ *  @returns {(document: ObjectLiteralType | ObjectType, entry: [key: string, schema: SchemaType]) => ObjectLiteralType | ObjectType}
  */
-export function transformNumber (hash, schema, parentUri, uri) {
-  /*
-   *  log('transformNumber')
+function getReducePropertiesEntriesFor (hash, parentUri) {
+  /**
+   *  @param {ObjectLiteralType | ObjectType} document
+   *  @param {[key: string, schema: SchemaType]} entry
+   *  @returns {ObjectLiteralType | ObjectType}
    */
+  return function reduce (document, [key, schema]) {
+    const schemaUri = getUri(parentUri, key)
 
-  if (uri in hash) { // Reflect.has(hash, uri)) {
-    const document = hash[uri] // Reflect.get(hash, uri)
-
-    if (hasEnum(schema)) {
-      const array = getEnum(schema)
+    document[key] = fromHashToDocument(hash, schema, schemaUri, schemaUri)
 
-      if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-      return transformToValueFor(document, array)
-    } else {
-      if (hasAnyOf(schema)) {
-        const array = getAnyOf(schema)
-
-        if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-        return transformToValueFor(document, array)
-      } else {
-        if (hasOneOf(schema)) {
-          const array = getOneOf(schema)
-
-          if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-          return transformToValueFor(document, array)
-        }
-      }
-    }
+    return document
+  }
+}
 
-    try {
-      if (isArray(document)) return document.map(toNumber)
-      return toNumber(document)
-    } catch (e) {
-      handleError(e)
-    }
+/**
+ *  @param {HashType} hash
+ *  @param {SchemaType} [schema]
+ *  @param {string} [parentUri]
+ *  @returns {DocumentType}
+ */
+export function transformObjectFor (hash, { properties } = {}, parentUri = '#') { // }, uri = getUri(parentUri)) {
+  /*
+   *  log('transformObjectFor')
+   */
 
-    return document
+  if (isObject(properties)) {
+    return (
+      Object
+        .entries(properties)
+        .reduce(getReducePropertiesEntriesFor(hash, parentUri), {})
+    )
   }
+
+  return {}
 }
 
 /**
@@ -513,48 +319,74 @@ export function transformNumber (hash, schema, parentUri, uri) {
  *  @param {string} uri
  *  @returns {DocumentType | undefined}
  */
-export function transformString (hash, schema, parentUri, uri) {
+export function transformObject (hash, schema, parentUri, uri) {
   /*
-   *  log('transformString')
+   *  log('transformObject')
    */
 
-  if (uri in hash) { // Reflect.has(hash, uri)) {
-    const document = hash[uri] // Reflect.get(hash, uri)
+  if (hasEnum(schema)) {
+    const array = getEnum(schema)
 
-    if (hasEnum(schema)) {
-      const array = getEnum(schema)
+    return (
+      transformToValue(
+        fromHashToArray(hash, uri, array)
+      )
+    )
+  } else {
+    if (hasAnyOf(schema)) {
+      const array = getAnyOf(schema)
 
-      if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-      return transformToValueFor(document, array)
+      return (
+        transformToValue(
+          fromHashToArray(hash, uri, array)
+        )
+      )
     } else {
-      if (hasAnyOf(schema)) {
-        const array = getAnyOf(schema)
-
-        if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-        return transformToValueFor(document, array)
-      } else {
-        if (hasOneOf(schema)) {
-          const array = getOneOf(schema)
-
-          if (isArray(document)) return document.map((v) => transformToValueFor(v, array))
-          return transformToValueFor(document, array)
-        }
+      if (hasOneOf(schema)) {
+        const array = getOneOf(schema)
+
+        return (
+          transformToValue(
+            fromHashToArray(hash, uri, array)
+          )
+        )
       }
     }
+  }
 
-    try {
-      if (isArray(document)) return document.map(toString)
-      return toString(document)
-    } catch (e) {
-      handleError(e)
-    }
+  return transformObjectFor(hash, schema, parentUri) // , uri)
+}
 
-    return document
+/**
+ *  Hash can be `undefined`
+ *
+ *  @param {HashType} [hash]
+ *  @param {SchemaType} [schema]
+ *  @param {ParamsType} [params]
+ *  @returns {DocumentType}
+ */
+export function transformObjectSchema (hash = {}, schema = {}, params = {}) {
+  log('transformObjectSchema')
+
+  const {
+    type
+  } = schema
+
+  // https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1
+  if (type === 'object') {
+    const {
+      uri: parentUri = '#',
+      key: fieldKey // string | undefined
+    } = params
+
+    return transformObject(hash, schema, parentUri, getUri(parentUri, fieldKey))
   }
+
+  throw new Error('Schema does not conform to Instance Data Model, https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1')
 }
 
 /**
- * Hash can be `undefined`
+ *  Hash can be `undefined`
  *
  *  @param {HashType} [hash]
  *  @param {SchemaType} [schema]
@@ -562,7 +394,7 @@ export function transformString (hash, schema, parentUri, uri) {
  *  @param {string} [uri]
  *  @returns {DocumentType | undefined}
  */
-export default function transform (hash = {}, schema = {}, parentUri = '#', uri = getUri(parentUri)) {
+export default function fromHashToDocument (hash = {}, schema = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('fromHashToDocument')
 
   const {