chore(sdk, test): change file hash impl and modify wasmedge test

Author: destifo

typegate/tests/runtimes/wasmedge/wasmedge.ts

@@ -4,7 +4,7 @@
 import { Policy, t, typegraph } from "@typegraph/sdk/index.js";
 import { WasmEdgeRuntime } from "@typegraph/sdk/runtimes/wasmedge.js";
 
-typegraph("wasmedge_ts", async (g: any) => {
+export const tg = await typegraph("wasmedge_ts", async (g: any) => {
   const pub = Policy.public();
   const wasmedge = new WasmEdgeRuntime();
 
@@ -18,7 +18,7 @@ typegraph("wasmedge_ts", async (g: any) => {
         t.integer(),
         {
           func: "add",
-          wasm: "artifacts/rust.wasm",
+          wasm: "typegate/tests/artifacts/rust.wasm",
         },
       );
     g.expose({

typegate/tests/runtimes/wasmedge/wasmedge_test.ts

@@ -1,30 +1,51 @@
 // Copyright Metatype OÜ, licensed under the Elastic License 2.0.
 // SPDX-License-Identifier: Elastic-2.0
 
+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";
 
-Meta.test("WasmEdge runtime", async (t) => {
-  const e = await t.engine("runtimes/wasmedge/wasmedge.py", { deploy: true });
+const port = 7698;
+const gate = `http://localhost:${port}`;
+const cwdDir = testDir;
+const auth = new BasicAuth("admin", "password");
 
-  await t.should("works", async () => {
-    await gql`
-      query {
-        test(a: 1, b: 2)
-      }
-    `
-      .expectData({
-        test: 3,
-      })
-      .on(e);
-  });
-});
+// 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 typescript sdk", async (metaTest) => {
-  const engine = await metaTest.engine("runtimes/wasmedge/wasmedge.ts", {
-    deploy: true,
+  const { serialized, typegate: _gateResponseAdd } = await tgDeploy(tg, {
+    baseUrl: gate,
+    auth,
+    artifactsConfig: {
+      prismaMigration: {
+        globalAction: {
+          create: true,
+          reset: false,
+        },
+        migrationDir: "prisma-migrations",
+      },
+      dir: cwdDir,
+    },
   });
 
-  await metaTest.should("work", async () => {
+  const engine = await metaTest.engineFromDeployed(serialized);
+
+  await metaTest.should("work after deploying artifact", async () => {
     await gql`
       query {
         test_wasi_ts(a: 11, b: 2)
@@ -35,4 +56,5 @@ Meta.test("WasmEdge Runtime typescript sdk", async (metaTest) => {
       })
       .on(engine);
   });
-});
+  await engine.terminate();
+}, { port: port, systemTypegraphs: true });

typegate/tests/utils/test.ts

@@ -142,6 +142,21 @@ export class MetaTest {
     return engine;
   }
 
+  async engineFromDeployed(tgString: string): Promise<QueryEngine> {
+    const tg = await TypeGraph.parseJson(tgString);
+    const { engine, response } = await this.typegate.pushTypegraph(
+      tg,
+      {},
+      this.introspection,
+    );
+
+    if (engine == null) {
+      throw response.failure!;
+    }
+
+    return engine;
+  }
+
   async unregister(engine: QueryEngine) {
     await Promise.all(
       this.register

typegraph/node/sdk/src/tg_deploy.ts

@@ -107,6 +107,7 @@ export async function tgDeploy(
       body: byteArray,
     });
 
+    const _ = await artifactUploadResponse.json();
     if (!artifactUploadResponse.ok) {
       throw new Error(
         `Failed to upload artifact ${filePath} to typegate: ${artifactUploadResponse.status} ${artifactUploadResponse.statusText}`,

typegraph/node/sdk/src/utils/file_utils.ts

@@ -5,44 +5,37 @@ import * as fs from "node:fs";
 import * as crypto from "node:crypto";
 import { wit_utils } from "../wit.js";
 
-export function getFileHash(filePath: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const currDir = wit_utils.getCwd();
-    filePath = `${currDir}/${filePath}`;
-    const hash = crypto.createHash("sha256");
-    const fileDescriptor = fs.openSync(filePath, "r");
+export async function getFileHash(filePath: string): Promise<string> {
+  const cwd = wit_utils.getCwd();
+  filePath = `${cwd}/${filePath}`;
+  const hash = crypto.createHash("sha256");
+  let file;
+
+  try {
+    await fs.promises.access(filePath, fs.constants.F_OK);
+    file = await fs.promises.open(filePath, "r");
 
     const CHUNK_SIZE = 4096;
     let buffer = new Uint8Array(CHUNK_SIZE);
     let bytesRead = 0;
-
-    function readChunk() {
-      fs.read(
-        fileDescriptor,
+    let numBytesRead = 0;
+    do {
+      const { bytesRead: numBytesRead } = await file.read(
         buffer,
         0,
         CHUNK_SIZE,
         bytesRead,
-        (err, numBytesRead) => {
-          if (err) {
-            fs.closeSync(fileDescriptor);
-            reject(err);
-            return;
-          }
-
-          if (numBytesRead === 0) {
-            fs.closeSync(fileDescriptor);
-            resolve(hash.digest("hex"));
-            return;
-          }
-
-          bytesRead += numBytesRead;
-          hash.update(buffer.subarray(0, numBytesRead));
-          readChunk();
-        },
       );
-    }
+      bytesRead += numBytesRead;
+      hash.update(buffer.subarray(0, numBytesRead));
+    } while (numBytesRead > 0);
 
-    readChunk();
-  });
+    return hash.digest("hex");
+  } catch (err) {
+    throw new Error(`Failed to calculate hash for ${filePath}: \n${err}`);
+  } finally {
+    if (file !== undefined) {
+      await file.close(); // Ensure file closure
+    }
+  }
 }