title: Creating structs programmatically at runtime - possible?
body: <p>Is it possible in Go to create a struct type programmatically (i.e. not in the compiled source code)?</p>
  
  <p>We have a particular use case where a type will be created via user-defined metadata (so the schema/types are not known in advance)
  and will vary for every customer. We would then need to auto-generate REST services for those and persist them in a NoSQL backend.
  We would also need to define different dynamic validators per field (e.g. mandatory, regex, max/min size, max/min value, a reference to another type instance, etc.)</p>
  
  <p>I was wondering if something similar is possible in the Go?</p>
  
  <p><strong>Edit 1:</strong></p>
  
  <p>For example </p>
  
  <blockquote>
    <p>From frontend in JSON</p>
  </blockquote>
  
  <pre><code>For customer 1:
  {
  "id":1,
  "patientid":1,
  "name":"test1",
  "height":"160",
  "weight":"70",
  "temp":"98"
  }
  
  For customer 2:
  {
  "id":2,
  "patientid":1,
  "name":"test1",
  "height":"160",
  "weight":"70"
  }
  
  For customer 3
  
  may be different new fields will add
  </code></pre>
  
  <blockquote>
    <p>Backend</p>
  </blockquote>
  
  <pre><code>// For One customer need to have these fields 
  
  type Vitalsigns struct {
      ID                int64  `datastore:"-"`
      PatientID         int64  `json:"patientid,omitempty"`
      Name              string `json:"name,omitempty"`
      Height            string `json:"height,omitempty"`
      Weight            string `json:"weight,omitempty"`
      Temp              string `json:"temp,omitempty"`
  }
  
  
  
  // Another need to have these fields
  
  type Vitalsigns struct {
      ID                int64  `datastore:"-"`
      PatientID         int64  `json:"patientid,omitempty"`
      Name              string `json:"name,omitempty"`
      Height            string `json:"height,omitempty"`
      Weight            string `json:"weight,omitempty"`
  }
  
  
  //CreateVitalsignsHandler is to create vitals for a patient
  func CreateVitalsignsHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
  
      //Creating the Vitalsigns
      kinVitalsigns := &amp;Vitalsigns{}
      ctx := appengine.NewContext(r)
      if err := json.NewDecoder(r.Body).Decode(kinVitalsigns); err != nil {
          RespondErr(w, r, http.StatusInternalServerError, err.Error())
          return
      }
      //Getting namespace
      namespace := ps.ByName("namespace")
      ctx, err := appengine.Namespace(ctx, namespace)
      if err != nil {
          log.Infof(ctx, "Namespace error from CreateVitalsignsHandler")
          RespondErr(w, r, http.StatusInternalServerError, err.Error())
          return
      }
      //Geting the patientID
      pID, err := strconv.Atoi(ps.ByName("id"))
      if err != nil {
          log.Infof(ctx, "Srting to Int64 conversion error from CreateVitalsignsHandler")
          RespondErr(w, r, http.StatusInternalServerError, err.Error())
          return
      }
      patientID := int64(pID)
      kinVitalsigns.PatientID = patientID
  
      //Generating the key
      vitalsignsKey := datastore.NewIncompleteKey(ctx, "Vitalsigns", nil)
  
      //Inserting the data to the datastore
      vk, err := datastore.Put(ctx, vitalsignsKey, kinVitalsigns)
      if err != nil {
          log.Infof(ctx, "Entity creation was failed from CreateVitalsignsHandler")
          RespondErr(w, r, http.StatusInternalServerError, err.Error())
          return
      }
      kinVitalsigns.ID = vk.IntID()
      message := "Vitalsigns created successfully!! "
      Respond(w, r, http.StatusOK, SuccessResponse{kinVitalsigns.ID, 0, "", message})
      return
  }
  </code></pre>