convert_j_to_s.js

let data = process.argv[2]
let unmarshalled = JSON.parse(data)

function toCamelCase(key) {
  return key.split('_')(key).map(convertCase).join('')
}

function convertCase(key) {
  if(key.toLowerCase() == "id") return key.toUpperCase()
  return key[0].toUpperCase() + key.slice(1)
}

function createStructType(data) {
  let subTypes = []

  let toplevel = Object.keys(data).reduce((acc, k) => {
  let val = data[k]
  let typ = (val) => Object.prototype.toString.call(val).slice(8, -1);
  let structType = "interface{}"

  let str = `${toCamelCase(k)} `

  if(typ(val) == 'Number') {
    structType = "int64"

    if((""+val).indexOf('.') > -1) {
      structType = "float64"
    }
  } else if(typ(val) == "String") {
    structType = "string"  
  } else if(typ(val) == "Array") {
    if(typ(val[0]) == "Number") {
      if(("" + val[0]).indexOf('.') > -1) { structType = "[]float64"}
      else structType = "[]int64"
    } else if(typ(val[0]) == "String") {
      structType = "[]string"
    } else if(typ(val[0]) == "Object") {
      // structType = str + "struct {" + createStructType(val[0]) + "}" 
      structType = `[]${str}`
      subTypes.push({key: k, value: val[0]})
    } else if(typ(val) == "Boolean") {
      structType = "bool"
    }
  } else if(typ(val) == "Boolean") {
    structType = "bool"
  } else if(typ(val) == "Object") {
    //structType = str + "struct {" + createStructType(val) + "}" 
    structType = str
    subTypes.push({key: k, value: val})
  } 
  
  acc = acc + str + structType + " `json:\""+ k +"\"`" + "\n"
  return acc
  }, '')

  toplevel += "\n"
  
  if(subTypes.length) toplevel += createSubTypes(subTypes)

  return toplevel
}

function createSubTypes(subTypes) {
  return subTypes.map(subType => {
    let val = subType.value
    let key = subType.key
    let str = `type ${toCamelCase(key)} struct \n { ${createStructType(val)} }`
    return str
  }).join("\n")
}

console.log(
  createStructType(unmarshalled)
)

convert_j_to_s.notworking.js

let data = process.argv[2]
let unmarshalled = JSON.parse(data)

let typ = (val) => Object.prototype.toString.call(val).slice(8, -1);

function toCamelCase(key) {
  return key.split('_').map(convertCase).join('')
}

function convertCase(key) {
  if(key.toLowerCase() == "id") return key.toUpperCase()
  return key[0].toUpperCase() + key.slice(1)
}

function handleNumberType(val) {
  structType = "int64"

  if((""+val).indexOf('.') > -1) { structType = "float64"}
  return {t: structType}
}

function handleArrayType(key, val) {
  let jsType = typ(val)
  let types = transformTypes(jsType, key, val)

  structType = `[]${types.t}`

  if(types.subTypes) return { t: structType, subTypes: types.structTypes}
  return {t: structType}

  if(typ(val) == "Number") {
    if(("" + val).indexOf('.') > -1) { structType = "[]float64"}
    else structType = "[]int64"
  } else if(typ(val) == "String") {
    structType = "[]string"
  } else if(typ(val) == "Object") {
    structType = `[]${str}`
    subTypes.push({key: k, value: val})
  } else if(typ(val) == "Boolean") {
    structType = "bool"
  } else {
    structType = "[]interface{}"
  }
}

function handleObjectType(key, val) {
  let subTypes = {key: key, value: val}
  return {t: toCamelCase(key), subTypes: subTypes}
}

function transformTypes(key, value) {
  let jsType = typ(value)

  let types = {
    Number: () => handleNumberType(value),
    String: () => ({t: "string"}),
    Boolean: () => ({t: "bool"}),
    Array: () => handleArrayType(key, value[0]),
    Object: () => handleObjectType(key, value)
  }

  return types[jsType]() || {t: "interface{}"}
}


function createStructType(data) {
  let subTypes = []
  let types = Object.keys(data).reduce((acc, k) => {
    let str = `${toCamelCase(k)} `

    let structTypeOb = transformTypes(k, data[k])
    if(structTypeOb.subTypes) subTypes.push(structTypeOb.subTypes)

    acc = acc.concat(str + structTypeOb.t + " `json:\""+ k +"\"`")
    return acc
  }, [])

  if(subTypes.length) types.push(createSubTypes(subTypes))

  return types.join("\n")
}

function createSubTypes(subTypes) {
  return subTypes.map(subType => {
    let val = subType.value
    let key = subType.key
    let str = `\n type ${toCamelCase(key)} struct { \n ${createStructType(val)} }`
    return str
  }).join("\n")
}

console.log(
  createStructType(unmarshalled)
)