Switch out old APIs

api/thrift/api.thrift

@@ -432,4 +432,8 @@ struct Model {
     3: optional TDataType outputSchema
     4: optional Source source
     5: optional map<string, string> modelParams
+}
+
+struct JoinRequest {
+  1: optional string name
 }

frontend/src/lib/api/api.ts

@@ -5,6 +5,7 @@ import type {
 	JoinTimeSeriesResponse,
 	ModelsResponse
 } from '$lib/types/Model/Model';
+import type { Join } from '$lib/types/codegen';
 
 export type ApiOptions = {
 	base?: string;
@@ -43,6 +44,13 @@ export class Api {
 		return this.#send<JoinsResponse>(`joins?${params.toString()}`);
 	}
 
+	async getJoin(name: string): Promise<Join> {
+		// ideally, we would do this so join instanceof Join === true. however, new Join() will not work until the sample data is updated w/ compile.py to match the latest thrift definition
+		// const response = await this.#send<Join>(`join/${name}`);
+		// return Object.assign(new Join(), response);
+		return this.#send<Join>(`join/${name}`);
+	}
+
 	async search(term: string, limit: number = 20) {
 		const params = new URLSearchParams({
 			term,
@@ -151,7 +159,7 @@ export class Api {
 			} else {
 				const text = (await response.text?.()) ?? '';
 				console.error(`Failed request: "${text}" for url: ${url}`);
-				error(response.status);
+				throw error(response.status);
 			}
 		});
 	}

frontend/src/routes/thrift/+page.svelte

@@ -0,0 +1,14 @@
+<!-- todo: this is only for testing, will be deleted before merge -->
+<script lang="ts">
+	import { Api } from '$lib/api/api';
+
+	$effect(() => {
+		const api = new Api({ fetch });
+
+		api.getJoin('sample_team.sample_chaining_join.parent_join').then((join) => {
+			console.log(join);
+		});
+	});
+</script>
+
+<div>hello!</div>

hub/src/main/java/ai/chronon/hub/HubVerticle.java

@@ -1,13 +1,15 @@
 package ai.chronon.hub;
 
 import ai.chronon.api.Constants;
+import ai.chronon.api.JoinRequest;
 import ai.chronon.hub.handlers.*;
 import ai.chronon.hub.store.MonitoringModelStore;
 import ai.chronon.online.Api;
 import ai.chronon.online.KVStore;
 import ai.chronon.online.stats.DriftStore;
 import ai.chronon.service.ApiProvider;
 import ai.chronon.service.ConfigStore;
+import ai.chronon.service.RouteHandlerWrapper;
 import ai.chronon.spark.utils.InMemoryKvStore;
 import io.vertx.core.AbstractVerticle;
 import io.vertx.core.Promise;
@@ -56,8 +58,9 @@ protected void startHttpServer(int port, String configJsonString, Api api, Promi
 
         // Add routes for metadata retrieval
         MonitoringModelStore store = new MonitoringModelStore(api);
+        ConfHandler confHandler = new ConfHandler(store);
         router.get("/api/v1/models").handler(new ModelsHandler(store));
-        router.get("/api/v1/join/:name").handler(new JoinsHandler(store).getHandler());
+        router.get("/api/v1/join/:name").handler(RouteHandlerWrapper.createHandler(confHandler::getJoin, JoinRequest.class));
         router.get("/api/v1/joins").handler(new JoinsHandler(store).listHandler());
         router.get("/api/v1/search").handler(new SearchHandler(store));
 

hub/src/main/scala/ai/chronon/hub/handlers/ConfHandler.scala

@@ -0,0 +1,23 @@
+package ai.chronon.hub.handlers
+
+import ai.chronon.api.{JoinRequest, Join}
+import ai.chronon.hub.store.MonitoringModelStore
+import org.slf4j.{Logger, LoggerFactory}
+
+class ConfHandler(store: MonitoringModelStore) {
+  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+
+  /**
+  * Returns a specific join by name (/api/v1/join/:name)
+  */
+  def getJoin(req: JoinRequest): Join = {
+    logger.debug("Retrieving {}", req.getName);
+    val joins = store.configRegistryCache("default").joins
+    joins
+      .find(_.getMetaData.getName.equalsIgnoreCase(req.getName))
+      .getOrElse(throw new RuntimeException(s"Unable to retrieve ${req.getName}"))
+  }
+
+  // todo getJoinNames, listNames, etc
+  // todo all others (groupBy, model, observability etc)
+}

service_commons/src/main/java/ai/chronon/service/RouteHandlerWrapper.java

@@ -2,6 +2,7 @@
 
 import ai.chronon.api.thrift.*;
 import ai.chronon.api.thrift.protocol.TBinaryProtocol;
+import ai.chronon.api.thrift.protocol.TSimpleJSONProtocol;
 import ai.chronon.api.thrift.transport.TTransportException;
 import io.vertx.core.Handler;
 import io.vertx.core.json.JsonObject;
@@ -49,7 +50,13 @@ public class RouteHandlerWrapper {
 
     private static final ThreadLocal<Base64.Encoder> base64Encoder = ThreadLocal.withInitial(Base64::getEncoder);
     private static final ThreadLocal<Base64.Decoder> base64Decoder = ThreadLocal.withInitial(Base64::getDecoder);
-
+    private static final ThreadLocal<TSerializer> jsonSerializer = ThreadLocal.withInitial(() -> {
+        try {
+            return new TSerializer(new TSimpleJSONProtocol.Factory());
+        } catch (TTransportException e) {
+            throw new RuntimeException(e);
+        }
+    });
 
     public static <T extends TBase> T deserializeTBinaryBase64(String base64Data, Class<? extends TBase> clazz) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, TException {
         byte[] binaryData = base64Decoder.get().decode(base64Data);
@@ -87,8 +94,19 @@ public static <I, O> Handler<RoutingContext> createHandler(Function<I, O> transf
 
                 String responseFormat = ctx.request().getHeader(RESPONSE_CONTENT_TYPE_HEADER);
                 if (responseFormat == null || responseFormat.equals("application/json")) {
-                    // Send json response
-                    ctx.response().setStatusCode(200).putHeader("content-type", JSON_TYPE_VALUE).end(JsonObject.mapFrom(output).encode());
+                    try {
+                        String jsonString = jsonSerializer.get().toString((TBase)output);
+                        ctx.response()
+                           .setStatusCode(200)
+                           .putHeader("content-type", JSON_TYPE_VALUE)
+                           .end(jsonString);
+                    } catch (TException e) {
+                        LOGGER.error("Failed to serialize response", e);
+                        throw new RuntimeException(e);
+                    } catch (Exception e) {
+                        LOGGER.error("Unexpected error during serialization", e);
+                        throw new RuntimeException(e);
+                    }
                 } else {
                     if (!responseFormat.equals(TBINARY_B64_TYPE_VALUE)) {
                         throw new IllegalArgumentException(String.format("Unsupported response-content-type: %s. Supported values are: %s and %s", responseFormat, JSON_TYPE_VALUE, TBINARY_B64_TYPE_VALUE));