Made BackendPipeline a little cleaner and moved inserts into services

smojol-api/src/main/java/org/smojol/api/ApiMain.java

@@ -52,40 +52,40 @@ public static void main(String[] args) throws IOException, URISyntaxException, S
         ConnectionBuilder connectionBuilder = new ConnectionBuilder(System.getenv("DATABASE_URL"),
                 System.getenv("DATABASE_USER"),
                 System.getenv("DATABASE_PASSWORD"));
-        runServer(7070, gsonMapper, connectionBuilder);
+        runServer(7070, gsonMapper, connectionBuilder, gson);
     }
 
-    private static void runServer(int port, JsonMapper gsonMapper, ConnectionBuilder connectionBuilder) {
+    private static void runServer(int port, JsonMapper gsonMapper, ConnectionBuilder connectionBuilder, Gson gson) {
         Javalin.create(config -> {
                     config.jsonMapper(gsonMapper);
                     config.staticFiles.add("/static/dist");
                     config.requestLogger.http((ctx, ms) -> LOGGER.info("Got a request: " + ctx.path()));
                 })
                 .get("/api/heartbeat", ctx -> ctx.result("Hello World!"))
                 .get("/api/ir-ast/{id}", ctx -> {
-                    Optional<Map<String, Object>> ast = irAST(ctx.pathParam("id"), connectionBuilder);
+                    Optional<Map<String, Object>> ast = irAST(ctx.pathParam("id"), connectionBuilder, gson);
                     if (ast.isEmpty()) {
                         ctx.status(404);
                         return;
                     }
                     ctx.json(ast.get());
                 })
                 .get("/api/ir-cfg/{id}", ctx -> {
-                    Optional<Map<String, Object>> cfg = irCFG(ctx.pathParam("id"), connectionBuilder);
+                    Optional<Map<String, Object>> cfg = irCFG(ctx.pathParam("id"), connectionBuilder, gson);
                     if (cfg.isEmpty()) {
                         ctx.status(404);
                         return;
                     }
                     ctx.json(cfg.get());
                 })
-                .get("/api/projects", ctx -> ctx.json(projectListings(connectionBuilder)))
+                .get("/api/projects", ctx -> ctx.json(projectListings(connectionBuilder, gson)))
                 .start(port);
     }
 
-    private static Optional<Map<String, Object>> irCFG(String id, ConnectionBuilder connectionBuilder) throws SQLException {
+    private static Optional<Map<String, Object>> irCFG(String id, ConnectionBuilder connectionBuilder, Gson gson) throws SQLException {
         try (Connection conn = connectionBuilder.getConnection()) {
             DSLContext using = DSL.using(conn, SQLDialect.SQLITE);
-            return new IntermediateASTService().intermediateCFG(Integer.parseInt(id), using);
+            return new IntermediateFormService(gson).intermediateCFG(Integer.parseInt(id), using);
         }
     }
 
@@ -107,17 +107,17 @@ public <T> T fromJsonString(@NotNull String json, @NotNull Type targetType) {
         return gsonMapper;
     }
 
-    private static List<ProjectListing> projectListings(ConnectionBuilder connectionBuilder) throws SQLException {
+    private static List<ProjectListing> projectListings(ConnectionBuilder connectionBuilder, Gson gson) throws SQLException {
         try (Connection conn = connectionBuilder.getConnection()) {
             DSLContext using = DSL.using(conn, SQLDialect.SQLITE);
-            return new IntermediateASTService().allProjectEntities(using);
+            return new IntermediateFormService(gson).allProjectEntities(using);
         }
     }
 
-    private static Optional<Map<String, Object>> irAST(String id, ConnectionBuilder connectionBuilder) throws SQLException {
+    private static Optional<Map<String, Object>> irAST(String id, ConnectionBuilder connectionBuilder, Gson gson) throws SQLException {
         try (Connection conn = connectionBuilder.getConnection()) {
             DSLContext using = DSL.using(conn, SQLDialect.SQLITE);
-            return new IntermediateASTService().intermediateAST(Integer.parseInt(id), using);
+            return new IntermediateFormService(gson).intermediateAST(Integer.parseInt(id), using);
         }
     }
 

smojol-api/src/main/java/org/smojol/api/IntermediateASTService.java → smojol-api/src/main/java/org/smojol/api/IntermediateFormService.java

@@ -9,6 +9,7 @@
 import org.smojol.api.contract.IntermediateASTListing;
 import org.smojol.api.contract.IntermediateCFGListing;
 import org.smojol.api.contract.ProjectListing;
+import org.smojol.common.transpiler.TranspilerNode;
 
 import java.util.List;
 import java.util.Map;
@@ -21,11 +22,16 @@
 import static org.jooq.impl.DSL.field;
 import static org.jooq.impl.DSL.table;
 
-public class IntermediateASTService {
+public class IntermediateFormService {
+    private final Gson gson;
     Table<Record> IR_AST = table("IR_AST");
     Table<Record> IR_CFG = table("IR_CFG");
     Table<Record> PROJECT = table("PROJECT");
 
+    public IntermediateFormService(Gson gson) {
+        this.gson = gson;
+    }
+
     Map<String, List<Map<String, String>>> intermediateASTListingsByProject2(DSLContext using) {
         Result<Record4<String, String, Integer, Integer>> allIntermediateASTs = using
                 .select(field("IR_AST.PROGRAM_NAME", String.class),
@@ -83,19 +89,37 @@ List<ProjectListing> allProjectEntities(DSLContext using) {
     }
 
     public Optional<Map<String, Object>> intermediateAST(int id, DSLContext using) {
-        Gson gson = new Gson();
         @NotNull Result<Record2<Integer, String>> ast = using.select(field("id", Integer.class), field("IR_AST", String.class)).from(IR_AST).where(field("ID", Integer.class).eq(id)).fetch();
         if (ast.isEmpty()) return Optional.empty();
         return Optional.of(ImmutableMap.of("id", id, "ast", gson.fromJson(ast.getFirst().component2(), JsonObject.class)));
     }
 
     public Optional<Map<String, Object>> intermediateCFG(int id, DSLContext using) {
-        Gson gson = new Gson();
         @NotNull Result<Record2<Integer, String>> ast = using.select(field("id", Integer.class), field("IR_CFG", String.class))
                 .from(IR_CFG)
                 .where(field("ID", Integer.class).eq(id))
                 .fetch();
         if (ast.isEmpty()) return Optional.empty();
         return Optional.of(ImmutableMap.of("id", id, "cfg", gson.fromJson(ast.getFirst().component2(), JsonObject.class)));
     }
+
+    public long insertIntermediateAST(TranspilerNode tree, String programName, long projectID, DSLContext using) {
+        return using.insertInto(table("IR_AST"))
+                .columns(field("PROGRAM_NAME"), field("PROJECT_ID"),
+                        field("IR_AST"))
+                .values(programName, projectID, gson.toJson(tree))
+                .returningResult(field("ID", Long.class))
+                .fetchOne()
+                .into(Long.class);
+    }
+
+    public long insertIntermediateCFG(Map<String, Set<?>> irCFGForDB, String programName, long projectID, DSLContext using) {
+        return using.insertInto(table("IR_CFG"))
+                .columns(field("PROGRAM_NAME"), field("PROJECT_ID"),
+                        field("IR_CFG"))
+                .values(programName, projectID, this.gson.toJson(irCFGForDB))
+                .returningResult(field("ID", Long.class))
+                .fetchOne()
+                .into(Long.class);
+    }
 }

smojol-api/src/main/java/org/smojol/api/ProjectService.java

@@ -0,0 +1,22 @@
+package org.smojol.api;
+
+import org.jooq.DSLContext;
+import org.jooq.Record;
+import org.jooq.Table;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.table;
+
+public class ProjectService {
+    Table<Record> PROJECT = table("PROJECT");
+
+    public long insertProject(String projectName, DSLContext using) {
+        Long into = using.insertInto(PROJECT)
+                .columns(field("NAME"))
+                .values(projectName)
+                .returningResult(field("ID", Long.class))
+                .fetchOne()
+                .into(Long.class);
+        return into;
+    }
+}

smojol-toolkit/src/main/java/org/smojol/toolkit/examples/BackendPipelineMain.java → smojol-api/src/main/java/org/smojol/api/pipeline/BackendPipelineMain.java

@@ -1,14 +1,15 @@
-package org.smojol.toolkit.examples;
+package org.smojol.api.pipeline;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.gson.Gson;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.DefaultEdge;
-import org.jgrapht.nio.json.JSONExporter;
 import org.jooq.DSLContext;
 import org.jooq.SQLDialect;
 import org.jooq.impl.DSL;
+import org.smojol.api.IntermediateFormService;
+import org.smojol.api.ProjectService;
 import org.smojol.common.dialect.LanguageDialect;
 import org.smojol.common.flowchart.FlowchartOutputFormat;
 import org.smojol.common.id.UUIDProvider;
@@ -29,7 +30,6 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.io.StringWriter;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
@@ -38,8 +38,6 @@
 import java.util.Set;
 import java.util.UUID;
 
-import static org.jooq.impl.DSL.field;
-import static org.jooq.impl.DSL.table;
 import static org.smojol.toolkit.task.CommandLineAnalysisTask.BUILD_BASE_ANALYSIS;
 
 public class BackendPipelineMain {
@@ -63,24 +61,20 @@ LanguageDialect.IDMS, new FullProgram(FlowchartOutputFormat.MERMAID), new UUIDPr
         String url = System.getenv("DATABASE_URL");
         String user = System.getenv("DATABASE_USER");
         String password = System.getenv("DATABASE_PASSWORD");
+        IntermediateFormService intermediateFormService = new IntermediateFormService(gson);
+        ProjectService projectService = new ProjectService();
         try (Connection conn = DriverManager.getConnection(url, user, password)) {
-            DSLContext using = DSL.using(conn, SQLDialect.MYSQL);
+            DSLContext using = DSL.using(conn, SQLDialect.SQLITE);
             String projectName = UUID.randomUUID().toString();
-            using.insertInto(table("PROJECT"))
-                    .columns(field("NAME"))
-                    .values(projectName).execute();
-            List<Integer> where = using.select(field("ID")).from(table("PROJECT")).where(field("NAME").eq(projectName)).fetchInto(Integer.class);
-//            JumpIfTranspilerNode transpilerNode = new JumpIfTranspilerNode(new NamedLocationNode("ABCD"), new EqualToNode(new ValueOfNode(new SymbolReferenceNode("A")), new PrimitiveValueTranspilerNode(TypedRecord.typedNumber(10))));
-            using.insertInto(table("IR_AST"))
-                    .columns(field("PROGRAM_NAME"), field("PROJECT_ID"),
-                            field("IR_AST"))
-                    .values(programName, where.getFirst(), gson.toJson(tree)).execute();
-            using.insertInto(table("IR_CFG"))
-                    .columns(field("PROGRAM_NAME"), field("PROJECT_ID"),
-                            field("IR_CFG"))
-                    .values(programName, where.getFirst(), gson.toJson(irCFGForDB)).execute();
-
+            long projectID = projectService.insertProject(projectName, using);
+            long irAstID = intermediateFormService.insertIntermediateAST(tree, programName, projectID, using);
+            long irCfgID = intermediateFormService.insertIntermediateCFG(irCFGForDB, programName, projectID, using);
+            System.out.println(projectID);
+            System.out.println(irAstID);
+            System.out.println(irCfgID);
         }
         System.out.println("DONE");
     }
+
+
 }