chore(sdk): add hash compute function and field to store it

Author: destifo

libs/common/src/typegraph/runtimes/wasmedge.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 pub struct WasiMatData {
     pub wasm: String,
     pub func: String,
+    pub artifact_hash: String,
 }
 
 #[cfg_attr(feature = "codegen", derive(JsonSchema))]

typegraph/core/wit/typegraph.wit

@@ -360,6 +360,7 @@ interface runtimes {
     record materializer-wasi {
         func-name: string,
         module: string,
+        artifact-hash: string,
     }
 
     register-wasmedge-runtime: func() -> result<runtime-id, error>

typegraph/node/sdk/src/runtimes/wasmedge.ts

@@ -6,6 +6,7 @@ import { runtimes } from "../wit.js";
 import { Effect } from "../gen/interfaces/metatype-typegraph-runtimes.js";
 import { Materializer, Runtime } from "./mod.js";
 import { fx } from "../index.js";
+import { getFileHash } from "../utils/file_utils.js";
 
 interface WasiMat extends Materializer {
   module: string;
@@ -30,6 +31,13 @@ export class WasmEdgeRuntime extends Runtime {
       effect?: Effect;
     },
   ): t.Func<I, O, WasiMat> {
+    let fileHash = "";
+    getFileHash(wasm).then((hash) => {
+      fileHash = hash;
+    }).catch((err) => {
+      console.error(err);
+    });
+
     const matId = runtimes.fromWasiModule(
       {
         runtime: this._id,
@@ -38,6 +46,7 @@ export class WasmEdgeRuntime extends Runtime {
       {
         module: `file:${wasm}`,
         funcName: func,
+        artifactHash: fileHash,
       },
     );
 

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

@@ -0,0 +1,44 @@
+// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0.
+// SPDX-License-Identifier: MPL-2.0
+
+import * as fs from "fs";
+import * as crypto from "crypto";
+
+export function getFileHash(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const fileDescriptor = fs.openSync(filePath, "r");
+
+    const CHUNK_SIZE = 4096;
+    let buffer = Buffer.alloc(CHUNK_SIZE);
+    let bytesRead = 0;
+
+    function readChunk() {
+      fs.read(
+        fileDescriptor,
+        buffer,
+        0,
+        CHUNK_SIZE,
+        bytesRead,
+        (err, bytesRead) => {
+          if (err) {
+            fs.closeSync(fileDescriptor);
+            reject(err);
+            return;
+          }
+
+          if (bytesRead === 0) {
+            fs.closeSync(fileDescriptor);
+            resolve(hash.digest("hex"));
+            return;
+          }
+
+          hash.update(buffer.subarray(0, bytesRead));
+          readChunk();
+        },
+      );
+    }
+
+    readChunk();
+  });
+}

typegraph/python/typegraph/runtimes/wasmedge.py

@@ -12,6 +12,7 @@
 )
 from typegraph.gen.types import Err
 from typegraph.runtimes.base import Materializer, Runtime
+from typegraph.utils import get_file_hash
 from typegraph.wit import runtimes, store
 
 
@@ -29,12 +30,13 @@ def wasi(
         effect: Optional[Effect] = None,
     ):
         effect = effect or EffectRead()
+        file_hash = get_file_hash(wasm)
         wasm = f"file:{wasm}"
 
         mat_id = runtimes.from_wasi_module(
             store,
             BaseMaterializer(runtime=self.id.value, effect=effect),
-            MaterializerWasi(module=wasm, func_name=func),
+            MaterializerWasi(module=wasm, func_name=func, artifact_hash=file_hash),
         )
 
         if isinstance(mat_id, Err):

typegraph/python/typegraph/utils.py

@@ -1,7 +1,10 @@
 # Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0.
 # SPDX-License-Identifier: MPL-2.0
 
+import hashlib
 import json
+import os
+import sys
 from functools import reduce
 from typing import Dict, List, Union, Tuple, Optional, Any
 from typegraph.injection import InheritDef
@@ -77,3 +80,17 @@ def build_reduce_data(node: Any, paths: List[ReducePath], curr_path: List[str]):
 
 def unpack_tarb64(tar_b64: str, dest: str):
     return wit_utils.unpack_tarb64(store, tar_b64, dest)
+
+
+def get_file_hash(file_path: str) -> str:
+    sha256_hasher = hashlib.sha256()
+
+    curr_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+    file_dir = os.path.join(curr_dir, file_path)
+
+    with open(file_dir, "rb") as file:
+        chunk = 0
+        while chunk := file.read(4096):
+            sha256_hasher.update(chunk)
+
+    return sha256_hasher.hexdigest()