chore(test): add tg deployer through shell in meta test

Author: destifo

typegate/tests/runtimes/wasmedge/wasmedge.py

@@ -1,3 +1,10 @@
+from typegraph.gen.exports.core import (
+    ArtifactResolutionConfig,
+    MigrationAction,
+    MigrationConfig,
+)
+from typegraph.graph.shared_types import BasicAuth
+from typegraph.graph.tg_deploy import TypegraphDeployParams, tg_deploy
 from typegraph.graph.typegraph import Graph
 from typegraph.policy import Policy
 from typegraph.runtimes.wasmedge import WasmEdgeRuntime
@@ -18,3 +25,24 @@ def wasmedge(g: Graph):
             func="add",
         ).with_policy(pub),
     )
+
+
+PORT = 7698
+gate = f"http://localhost:{PORT}"
+auth = BasicAuth("admin", "password")
+
+wasmedge_tg = wasmedge()
+serialized, typegate = tg_deploy(
+    wasmedge_tg,
+    TypegraphDeployParams(
+        base_url=gate,
+        artifacts_config=ArtifactResolutionConfig(
+            prisma_migration=MigrationConfig(
+                migration_dir="prisma-migrations",
+                global_action=MigrationAction(reset=False, create=True),
+            )
+        ),
+    ),
+)
+
+print(serialized)

typegate/tests/runtimes/wasmedge/wasmedge_test.ts

@@ -5,27 +5,34 @@ import { BasicAuth, tgDeploy } from "@typegraph/sdk/tg_deploy.js";
 import { gql, Meta } from "../../utils/mod.ts";
 import { testDir } from "test-utils/dir.ts";
 import { tg } from "./wasmedge.ts";
+import { SDKLangugage } from "test-utils/test.ts";
 
 const port = 7698;
 const gate = `http://localhost:${port}`;
 const cwdDir = testDir;
 const auth = new BasicAuth("admin", "password");
 
-// Meta.test("WasmEdge runtime", async (t) => {
-//   const e = await t.engine("runtimes/wasmedge/wasmedge.py", {}, { port });
-
-//   await t.should("works", async () => {
-//     await gql`
-//       query {
-//         test(a: 1, b: 2)
-//       }
-//     `
-//       .expectData({
-//         test: 3,
-//       })
-//       .on(e);
-//   });
-// }, { port: port });
+Meta.test("WasmEdge runtime", async (t) => {
+  await t.should("works", async () => {
+    const serialized = await t.serializeTypegraphFromShell(
+      "runtimes/wasmedge/wasmedge.py",
+      SDKLangugage.Python,
+    );
+
+    const engine = await t.engineFromDeployed(serialized);
+
+    await gql`
+      query {
+        test(a: 1, b: 2)
+      }
+    `
+      .expectData({
+        test: 3,
+      })
+      .on(engine);
+    await engine.terminate();
+  });
+}, { port: port });
 
 Meta.test("WasmEdge Runtime typescript sdk", async (metaTest) => {
   await metaTest.should("work after deploying artifact", async () => {

typegate/tests/utils/test.ts

@@ -31,6 +31,11 @@ export interface ParseOptions {
   pretty?: boolean;
 }
 
+export enum SDKLangugage {
+  Python = "python3",
+  TypeScript = "deno",
+}
+
 function serve(typegate: Typegate, port: number): () => void {
   const server = Deno.serve({ port }, (req) => {
     return typegate.handle(req, {
@@ -157,6 +162,24 @@ export class MetaTest {
     return engine;
   }
 
+  async serializeTypegraphFromShell(
+    path: string,
+    lang: SDKLangugage,
+  ): Promise<string> {
+    // run self deployed typegraph
+    const { stderr, stdout } = await this.shell([lang.toString(), path]);
+
+    if (stderr.length > 0) {
+      throw new Error(`${stderr}`);
+    }
+
+    if (stdout.length === 0) {
+      throw new Error("No typegraph");
+    }
+
+    return stdout;
+  }
+
   async unregister(engine: QueryEngine) {
     await Promise.all(
       this.register