shinkansen-transmission 2.3.5 → 2.4.0

package/src/transmission/from-hash-to-document/null/index.d.mts

@@ -0,0 +1,8 @@
+export type SchemaType = TransmissionTypes.SchemaType
+export type ParamsType = TransmissionTypes.ParamsType
+export type DocumentType = TransmissionTypes.DocumentType
+export type HashType = TransmissionTypes.HashType
+
+export function transformNull (hash: HashType, schema: SchemaType, parentUri: string, uri: string): null | undefined
+
+export default function transformNullSchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined

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

@@ -8,19 +8,100 @@
 import debug from 'debug'
 
 import {
+  isArray,
+  hasEnum,
+  getEnum,
+  hasAnyOf,
+  getAnyOf,
+  hasOneOf,
+  getOneOf,
+  transformToValue,
   getUri
 } from '#transmission/transmission/common'
 
 import {
-  transformNull
-} from '#transmission/transmission/from-hash-to-document'
+  fromDocumentToArray,
+  mapToValue,
+  toNull
+} from '#transmission/transmission/common/transform'
 
 const log = debug('shinkansen-transmission/from-hash-to-document/null')
 
 log('`shinkansen` is awake')
 
 /**
- * Hash can be `undefined`
+ * @overload
+ * @param {unknown} error
+ * @returns {void}
+ *
+ * @param {{ message?: string }} error
+ * @returns {void}
+ */
+function handleError ({ message = 'No error message defined' }) { log(message) }
+
+/**
+ *  @param {HashType} hash
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {DocumentType | undefined}
+ */
+export function transformNull (hash, schema, parentUri, uri) {
+  /*
+   *  log('transformNull')
+   */
+
+  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(mapToValue(array))
+      return (
+        transformToValue(
+          fromDocumentToArray(document, array)
+        )
+      )
+    } else {
+      if (hasAnyOf(schema)) {
+        const array = getAnyOf(schema)
+
+        if (isArray(document)) return document.map(mapToValue(array))
+        return (
+          transformToValue(
+            fromDocumentToArray(document, array)
+          )
+        )
+      } else {
+        if (hasOneOf(schema)) {
+          const array = getOneOf(schema)
+
+          if (isArray(document)) return document.map(mapToValue(array))
+          return (
+            transformToValue(
+              fromDocumentToArray(document, array)
+            )
+          )
+        }
+      }
+    }
+
+    try {
+      if (isArray(document)) return document.map(toNull)
+      return (
+        toNull(document)
+      )
+    } catch (e) {
+      handleError(e)
+    }
+
+    return document
+  }
+}
+
+/**
+ *  Hash can be `undefined`
  *
  *  @param {HashType} [hash]
  *  @param {SchemaType} [schema]

package/src/transmission/from-hash-to-document/number/index.d.mts

@@ -0,0 +1,8 @@
+export type SchemaType = TransmissionTypes.SchemaType
+export type ParamsType = TransmissionTypes.ParamsType
+export type DocumentType = TransmissionTypes.DocumentType
+export type HashType = TransmissionTypes.HashType
+
+export function transformNumber (hash: HashType, schema: SchemaType, parentUri: string, uri: string): number | undefined
+
+export default function transformNumberSchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined

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

@@ -8,19 +8,100 @@
 import debug from 'debug'
 
 import {
+  isArray,
+  hasEnum,
+  getEnum,
+  hasAnyOf,
+  getAnyOf,
+  hasOneOf,
+  getOneOf,
+  transformToValue,
   getUri
 } from '#transmission/transmission/common'
 
 import {
-  transformNumber
-} from '#transmission/transmission/from-hash-to-document'
+  fromDocumentToArray,
+  mapToValue,
+  toNumber
+} from '#transmission/transmission/common/transform'
 
 const log = debug('shinkansen-transmission/from-hash-to-document/number')
 
 log('`shinkansen` is awake')
 
 /**
- * Hash can be `undefined`
+ * @overload
+ * @param {unknown} error
+ * @returns {void}
+ *
+ * @param {{ message?: string }} error
+ * @returns {void}
+ */
+function handleError ({ message = 'No error message defined' }) { log(message) }
+
+/**
+ *  @param {HashType} hash
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {DocumentType | undefined}
+ */
+export function transformNumber (hash, schema, parentUri, uri) {
+  /*
+   *  log('transformNumber')
+   */
+
+  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(mapToValue(array))
+      return (
+        transformToValue(
+          fromDocumentToArray(document, array)
+        )
+      )
+    } else {
+      if (hasAnyOf(schema)) {
+        const array = getAnyOf(schema)
+
+        if (isArray(document)) return document.map(mapToValue(array))
+        return (
+          transformToValue(
+            fromDocumentToArray(document, array)
+          )
+        )
+      } else {
+        if (hasOneOf(schema)) {
+          const array = getOneOf(schema)
+
+          if (isArray(document)) return document.map(mapToValue(array))
+          return (
+            transformToValue(
+              fromDocumentToArray(document, array)
+            )
+          )
+        }
+      }
+    }
+
+    try {
+      if (isArray(document)) return document.map(toNumber)
+      return (
+        toNumber(document)
+      )
+    } catch (e) {
+      handleError(e)
+    }
+
+    return document
+  }
+}
+
+/**
+ *  Hash can be `undefined`
  *
  *  @param {HashType} [hash]
  *  @param {SchemaType} [schema]

package/src/transmission/from-hash-to-document/object/index.d.mts

@@ -0,0 +1,4 @@
+export {
+  transformObject,
+  transformObjectSchema as default
+} from '#transmission/transmission/from-hash-to-document'

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

@@ -1,48 +1,10 @@
-/**
- *  @typedef {TransmissionTypes.HashType} HashType
- *  @typedef {TransmissionTypes.SchemaType} SchemaType
- *  @typedef {TransmissionTypes.ParamsType} ParamsType
- *  @typedef {TransmissionTypes.DocumentType} DocumentType
- */
-
 import debug from 'debug'
 
-import {
-  getUri
-} from '#transmission/transmission/common'
-
-import {
-  transformObject
-} from '#transmission/transmission/from-hash-to-document'
-
 const log = debug('shinkansen-transmission/from-hash-to-document/object')
 
 log('`shinkansen` is awake')
 
-/**
- * Hash can be `undefined`
- *
- *  @param {HashType} [hash]
- *  @param {SchemaType} [schema]
- *  @param {ParamsType} [params]
- *  @returns {DocumentType}
- */
-export default 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')
-}
+export {
+  transformObject,
+  transformObjectSchema as default
+} from '#transmission/transmission/from-hash-to-document'

package/src/transmission/from-hash-to-document/string/index.d.mts

@@ -0,0 +1,8 @@
+export type SchemaType = TransmissionTypes.SchemaType
+export type ParamsType = TransmissionTypes.ParamsType
+export type DocumentType = TransmissionTypes.DocumentType
+export type HashType = TransmissionTypes.HashType
+
+export function transformString (hash: HashType, schema: SchemaType, parentUri: string, uri: string): string | undefined
+
+export default function transformStringSchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined

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

@@ -2,7 +2,7 @@
  *  @typedef {TransmissionTypes.ObjectType} ObjectType
  *  @typedef {TransmissionTypes.ArrayType} ArrayType
  *
- *  @typedef {TransmissionTypes.ItemsType} ItemsType
+ *  @typedef {TransmissionTypes.MemberArrayType} MemberArrayType
  *
  *  @typedef {TransmissionTypes.HashType} HashType
  *  @typedef {TransmissionTypes.SchemaType} SchemaType
@@ -13,19 +13,100 @@
 import debug from 'debug'
 
 import {
+  isArray,
+  hasEnum,
+  getEnum,
+  hasAnyOf,
+  getAnyOf,
+  hasOneOf,
+  getOneOf,
+  transformToValue,
   getUri
 } from '#transmission/transmission/common'
 
 import {
-  transformString
-} from '#transmission/transmission/from-hash-to-document'
+  fromDocumentToArray,
+  mapToValue,
+  toString
+} from '#transmission/transmission/common/transform'
 
 const log = debug('shinkansen-transmission/from-hash-to-document/string')
 
 log('`shinkansen` is awake')
 
 /**
- * Hash can be `undefined`
+ * @overload
+ * @param {unknown} error
+ * @returns {void}
+ *
+ * @param {{ message?: string }} error
+ * @returns {void}
+ */
+function handleError ({ message = 'No error message defined' }) { log(message) }
+
+/**
+ *  @param {HashType} hash
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {DocumentType | undefined}
+ */
+export function transformString (hash, schema, parentUri, uri) {
+  /*
+   *  log('transformString')
+   */
+
+  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(mapToValue(array))
+      return (
+        transformToValue(
+          fromDocumentToArray(document, array)
+        )
+      )
+    } else {
+      if (hasAnyOf(schema)) {
+        const array = getAnyOf(schema)
+
+        if (isArray(document)) return document.map(mapToValue(array))
+        return (
+          transformToValue(
+            fromDocumentToArray(document, array)
+          )
+        )
+      } else {
+        if (hasOneOf(schema)) {
+          const array = getOneOf(schema)
+
+          if (isArray(document)) return document.map(mapToValue(array))
+          return (
+            transformToValue(
+              fromDocumentToArray(document, array)
+            )
+          )
+        }
+      }
+    }
+
+    try {
+      if (isArray(document)) return document.map(toString)
+      return (
+        toString(document)
+      )
+    } catch (e) {
+      handleError(e)
+    }
+
+    return document
+  }
+}
+
+/**
+ *  Hash can be `undefined`
  *
  *  @param {HashType} [hash]
  *  @param {SchemaType} [schema]