remove secondary codegen

6 files changed, 445 insertions, 200 deletions

diff --git a/pkg/client/client.go b/pkg/client/client.go
index fba38c008..bf2d5038e 100644
--- a/pkg/client/client.go
+++ b/pkg/client/client.go
@@ -2,4 +2,3 @@ package client
 
 //go:generate bun run ../../js/src/index.ts generate
 //go:generate go tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --package=client --generate=types,client,models -o generated-client.go ./gen/openapi.json
-//go:generate go tool github.com/atombender/go-jsonschema -p client -o generated-event.go ./gen/event.json
diff --git a/pkg/client/event.go b/pkg/client/event.go
index a43c4c8ea..f5aab2d26 100644
--- a/pkg/client/event.go
+++ b/pkg/client/event.go
@@ -5,21 +5,9 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
-	"reflect"
 	"strings"
 )
 
-var EventMap = map[string]any{
-	"storage.write":   EventStorageWrite{},
-	"session.updated": EventSessionUpdated{},
-	"message.updated": EventMessageUpdated{},
-}
-
-type EventMessage struct {
-	Type       string          `json:"type"`
-	Properties json.RawMessage `json:"properties"`
-}
-
 func (c *Client) Event(ctx context.Context) (<-chan any, error) {
 	events := make(chan any)
 	req, err := http.NewRequestWithContext(ctx, "GET", c.Server+"event", nil)
@@ -42,24 +30,18 @@ func (c *Client) Event(ctx context.Context) (<-chan any, error) {
 			if strings.HasPrefix(line, "data: ") {
 				data := strings.TrimPrefix(line, "data: ")
 
-				var eventMsg EventMessage
-				if err := json.Unmarshal([]byte(data), &eventMsg); err != nil {
+				var event Event
+				if err := json.Unmarshal([]byte(data), &event); err != nil {
 					continue
 				}
 
-				eventTemplate, exists := EventMap[eventMsg.Type]
-				if !exists {
-					continue
-				}
-
-				eventValue := reflect.New(reflect.TypeOf(eventTemplate)).Interface()
-
-				if err := json.Unmarshal(eventMsg.Properties, eventValue); err != nil {
+				val, err := event.ValueByDiscriminator()
+				if err != nil {
 					continue
 				}
 
 				select {
-				case events <- eventValue:
+				case events <- val:
 				case <-ctx.Done():
 					return
 				}
diff --git a/pkg/client/gen/event.json b/pkg/client/gen/event.json
deleted file mode 100644
index e40f1308f..000000000
--- a/pkg/client/gen/event.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
-  "type": "object",
-  "$schema": "https://json-schema.org/draft-2020-12/schema",
-  "definitions": {
-    "event.storage.write": {
-      "type": "object",
-      "properties": {
-        "key": {
-          "type": "string"
-        },
-        "content": {}
-      },
-      "required": [
-        "key",
-        "content"
-      ]
-    },
-    "event.lsp.client.diagnostics": {
-      "type": "object",
-      "properties": {
-        "serverID": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "serverID",
-        "path"
-      ]
-    },
-    "event.message.updated": {
-      "type": "object",
-      "properties": {
-        "sessionID": {
-          "type": "string"
-        },
-        "messageID": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "sessionID",
-        "messageID"
-      ]
-    },
-    "event.session.updated": {
-      "type": "object",
-      "properties": {
-        "sessionID": {
-          "type": "string"
-        }
-      },
-      "required": [
-        "sessionID"
-      ]
-    }
-  }
-}
\ No newline at end of file
diff --git a/pkg/client/gen/openapi.json b/pkg/client/gen/openapi.json
index 395ff5614..5356042c4 100644
--- a/pkg/client/gen/openapi.json
+++ b/pkg/client/gen/openapi.json
@@ -6,6 +6,25 @@
     "version": "1.0.0"
   },
   "paths": {
+    "/event": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Event stream",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Event"
+                }
+              }
+            }
+          }
+        },
+        "operationId": "getEvent",
+        "parameters": [],
+        "description": "Get events"
+      }
+    },
     "/session_create": {
       "post": {
         "responses": {
@@ -250,6 +269,136 @@
   },
   "components": {
     "schemas": {
+      "Event": {
+        "oneOf": [
+          {
+            "$ref": "#/components/schemas/Event.storage.write"
+          },
+          {
+            "$ref": "#/components/schemas/Event.lsp.client.diagnostics"
+          },
+          {
+            "$ref": "#/components/schemas/Event.message.updated"
+          },
+          {
+            "$ref": "#/components/schemas/Event.session.updated"
+          }
+        ],
+        "discriminator": {
+          "propertyName": "type",
+          "mapping": {
+            "storage.write": "#/components/schemas/Event.storage.write",
+            "lsp.client.diagnostics": "#/components/schemas/Event.lsp.client.diagnostics",
+            "message.updated": "#/components/schemas/Event.message.updated",
+            "session.updated": "#/components/schemas/Event.session.updated"
+          }
+        }
+      },
+      "Event.storage.write": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "storage.write"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "key": {
+                "type": "string"
+              },
+              "content": {}
+            },
+            "required": [
+              "key"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.lsp.client.diagnostics": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "lsp.client.diagnostics"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "serverID": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "serverID",
+              "path"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.message.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "message.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string"
+              },
+              "messageID": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "sessionID",
+              "messageID"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.session.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "session.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "sessionID"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
       "Session.Info": {
         "type": "object",
         "properties": {
diff --git a/pkg/client/generated-client.go b/pkg/client/generated-client.go
index 5901cb1c0..70a911908 100644
--- a/pkg/client/generated-client.go
+++ b/pkg/client/generated-client.go
@@ -24,6 +24,46 @@ const (
 	User      MessageInfoRole = "user"
 )
 
+// Event defines model for Event.
+type Event struct {
+	union json.RawMessage
+}
+
+// EventLspClientDiagnostics defines model for Event.lsp.client.diagnostics.
+type EventLspClientDiagnostics struct {
+	Properties struct {
+		Path     string `json:"path"`
+		ServerID string `json:"serverID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventMessageUpdated defines model for Event.message.updated.
+type EventMessageUpdated struct {
+	Properties struct {
+		MessageID string `json:"messageID"`
+		SessionID string `json:"sessionID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventSessionUpdated defines model for Event.session.updated.
+type EventSessionUpdated struct {
+	Properties struct {
+		SessionID string `json:"sessionID"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventStorageWrite defines model for Event.storage.write.
+type EventStorageWrite struct {
+	Properties struct {
+		Content *interface{} `json:"content,omitempty"`
+		Key     string       `json:"key"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
 // MessageInfo defines model for Message.Info.
 type MessageInfo struct {
 	Id       string `json:"id"`
@@ -191,6 +231,155 @@ type PostSessionMessagesJSONRequestBody PostSessionMessagesJSONBody
 // PostSessionShareJSONRequestBody defines body for PostSessionShare for application/json ContentType.
 type PostSessionShareJSONRequestBody PostSessionShareJSONBody
 
+// AsEventStorageWrite returns the union data inside the Event as a EventStorageWrite
+func (t Event) AsEventStorageWrite() (EventStorageWrite, error) {
+	var body EventStorageWrite
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventStorageWrite overwrites any union data inside the Event as the provided EventStorageWrite
+func (t *Event) FromEventStorageWrite(v EventStorageWrite) error {
+	v.Type = "storage.write"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventStorageWrite performs a merge with any union data inside the Event, using the provided EventStorageWrite
+func (t *Event) MergeEventStorageWrite(v EventStorageWrite) error {
+	v.Type = "storage.write"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
+func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
+	var body EventLspClientDiagnostics
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventLspClientDiagnostics overwrites any union data inside the Event as the provided EventLspClientDiagnostics
+func (t *Event) FromEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventLspClientDiagnostics performs a merge with any union data inside the Event, using the provided EventLspClientDiagnostics
+func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventMessageUpdated returns the union data inside the Event as a EventMessageUpdated
+func (t Event) AsEventMessageUpdated() (EventMessageUpdated, error) {
+	var body EventMessageUpdated
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventMessageUpdated overwrites any union data inside the Event as the provided EventMessageUpdated
+func (t *Event) FromEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventMessageUpdated performs a merge with any union data inside the Event, using the provided EventMessageUpdated
+func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsEventSessionUpdated returns the union data inside the Event as a EventSessionUpdated
+func (t Event) AsEventSessionUpdated() (EventSessionUpdated, error) {
+	var body EventSessionUpdated
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventSessionUpdated overwrites any union data inside the Event as the provided EventSessionUpdated
+func (t *Event) FromEventSessionUpdated(v EventSessionUpdated) error {
+	v.Type = "session.updated"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventSessionUpdated performs a merge with any union data inside the Event, using the provided EventSessionUpdated
+func (t *Event) MergeEventSessionUpdated(v EventSessionUpdated) error {
+	v.Type = "session.updated"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t Event) Discriminator() (string, error) {
+	var discriminator struct {
+		Discriminator string `json:"type"`
+	}
+	err := json.Unmarshal(t.union, &discriminator)
+	return discriminator.Discriminator, err
+}
+
+func (t Event) ValueByDiscriminator() (interface{}, error) {
+	discriminator, err := t.Discriminator()
+	if err != nil {
+		return nil, err
+	}
+	switch discriminator {
+	case "lsp.client.diagnostics":
+		return t.AsEventLspClientDiagnostics()
+	case "message.updated":
+		return t.AsEventMessageUpdated()
+	case "session.updated":
+		return t.AsEventSessionUpdated()
+	case "storage.write":
+		return t.AsEventStorageWrite()
+	default:
+		return nil, errors.New("unknown discriminator value: " + discriminator)
+	}
+}
+
+func (t Event) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *Event) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
 // AsMessagePartText returns the union data inside the MessagePart as a MessagePartText
 func (t MessagePart) AsMessagePartText() (MessagePartText, error) {
 	var body MessagePartText
@@ -592,6 +781,9 @@ func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
 
 // The interface specification for the client above.
 type ClientInterface interface {
+	// GetEvent request
+	GetEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
+
 	// PostProviderList request
 	PostProviderList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
 
@@ -622,6 +814,18 @@ type ClientInterface interface {
 	PostSessionShare(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 }
 
+func (c *Client) GetEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewGetEventRequest(c.Server)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
 func (c *Client) PostProviderList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
 	req, err := NewPostProviderListRequest(c.Server)
 	if err != nil {
@@ -754,6 +958,33 @@ func (c *Client) PostSessionShare(ctx context.Context, body PostSessionShareJSON
 	return c.Client.Do(req)
 }
 
+// NewGetEventRequest generates requests for GetEvent
+func NewGetEventRequest(server string) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/event")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
 // NewPostProviderListRequest generates requests for PostProviderList
 func NewPostProviderListRequest(server string) (*http.Request, error) {
 	var err error
@@ -1038,6 +1269,9 @@ func WithBaseURL(baseURL string) ClientOption {
 
 // ClientWithResponsesInterface is the interface specification for the client with responses above.
 type ClientWithResponsesInterface interface {
+	// GetEventWithResponse request
+	GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error)
+
 	// PostProviderListWithResponse request
 	PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error)
 
@@ -1068,6 +1302,28 @@ type ClientWithResponsesInterface interface {
 	PostSessionShareWithResponse(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error)
 }
 
+type GetEventResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON200      *Event
+}
+
+// Status returns HTTPResponse.Status
+func (r GetEventResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r GetEventResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
 type PostProviderListResponse struct {
 	Body         []byte
 	HTTPResponse *http.Response
@@ -1226,6 +1482,15 @@ func (r PostSessionShareResponse) StatusCode() int {
 	return 0
 }
 
+// GetEventWithResponse request returning *GetEventResponse
+func (c *ClientWithResponses) GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error) {
+	rsp, err := c.GetEvent(ctx, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParseGetEventResponse(rsp)
+}
+
 // PostProviderListWithResponse request returning *PostProviderListResponse
 func (c *ClientWithResponses) PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error) {
 	rsp, err := c.PostProviderList(ctx, reqEditors...)
@@ -1321,6 +1586,32 @@ func (c *ClientWithResponses) PostSessionShareWithResponse(ctx context.Context,
 	return ParsePostSessionShareResponse(rsp)
 }
 
+// ParseGetEventResponse parses an HTTP response from a GetEventWithResponse call
+func ParseGetEventResponse(rsp *http.Response) (*GetEventResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &GetEventResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest Event
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	}
+
+	return response, nil
+}
+
 // ParsePostProviderListResponse parses an HTTP response from a PostProviderListWithResponse call
 func ParsePostProviderListResponse(rsp *http.Response) (*PostProviderListResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
diff --git a/pkg/client/generated-event.go b/pkg/client/generated-event.go
deleted file mode 100644
index 12485b648..000000000
--- a/pkg/client/generated-event.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Code generated by github.com/atombender/go-jsonschema, DO NOT EDIT.
-
-package client
-
-import "encoding/json"
-import "fmt"
-
-type EventLspClientDiagnostics struct {
-	// Path corresponds to the JSON schema field "path".
-	Path string `json:"path" yaml:"path" mapstructure:"path"`
-
-	// ServerID corresponds to the JSON schema field "serverID".
-	ServerID string `json:"serverID" yaml:"serverID" mapstructure:"serverID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventLspClientDiagnostics) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["path"]; raw != nil && !ok {
-		return fmt.Errorf("field path in EventLspClientDiagnostics: required")
-	}
-	if _, ok := raw["serverID"]; raw != nil && !ok {
-		return fmt.Errorf("field serverID in EventLspClientDiagnostics: required")
-	}
-	type Plain EventLspClientDiagnostics
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventLspClientDiagnostics(plain)
-	return nil
-}
-
-type EventMessageUpdated struct {
-	// MessageID corresponds to the JSON schema field "messageID".
-	MessageID string `json:"messageID" yaml:"messageID" mapstructure:"messageID"`
-
-	// SessionID corresponds to the JSON schema field "sessionID".
-	SessionID string `json:"sessionID" yaml:"sessionID" mapstructure:"sessionID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventMessageUpdated) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["messageID"]; raw != nil && !ok {
-		return fmt.Errorf("field messageID in EventMessageUpdated: required")
-	}
-	if _, ok := raw["sessionID"]; raw != nil && !ok {
-		return fmt.Errorf("field sessionID in EventMessageUpdated: required")
-	}
-	type Plain EventMessageUpdated
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventMessageUpdated(plain)
-	return nil
-}
-
-type EventSessionUpdated struct {
-	// SessionID corresponds to the JSON schema field "sessionID".
-	SessionID string `json:"sessionID" yaml:"sessionID" mapstructure:"sessionID"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventSessionUpdated) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["sessionID"]; raw != nil && !ok {
-		return fmt.Errorf("field sessionID in EventSessionUpdated: required")
-	}
-	type Plain EventSessionUpdated
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventSessionUpdated(plain)
-	return nil
-}
-
-type EventStorageWrite struct {
-	// Content corresponds to the JSON schema field "content".
-	Content interface{} `json:"content" yaml:"content" mapstructure:"content"`
-
-	// Key corresponds to the JSON schema field "key".
-	Key string `json:"key" yaml:"key" mapstructure:"key"`
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (j *EventStorageWrite) UnmarshalJSON(value []byte) error {
-	var raw map[string]interface{}
-	if err := json.Unmarshal(value, &raw); err != nil {
-		return err
-	}
-	if _, ok := raw["content"]; raw != nil && !ok {
-		return fmt.Errorf("field content in EventStorageWrite: required")
-	}
-	if _, ok := raw["key"]; raw != nil && !ok {
-		return fmt.Errorf("field key in EventStorageWrite: required")
-	}
-	type Plain EventStorageWrite
-	var plain Plain
-	if err := json.Unmarshal(value, &plain); err != nil {
-		return err
-	}
-	*j = EventStorageWrite(plain)
-	return nil
-}