space-data-module-sdk 0.2.0 → 0.2.6

package/src/compiler/emceptionNode.js

@@ -0,0 +1,234 @@
+import os from "node:os";
+import path from "node:path";
+import { cp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+const require = createRequire(import.meta.url);
+const PATCH_VERSION = "space-data-module-sdk-emception-node-v1";
+const PATCH_MARKER_FILENAME = ".space-data-module-sdk-emception-patch";
+const EMCEPTION_PATCH_ROOT = path.join(
+  os.tmpdir(),
+  `space-data-module-sdk-emception-node-${process.pid}`,
+);
+const FILE_URL_FETCH_PATCH_FLAG =
+  "__spaceDataModuleSdkFileUrlFetchPatched";
+
+let patchedEmceptionRootPromise = null;
+
+function installNodeRuntimeShims() {
+  if (typeof globalThis.require !== "function") {
+    globalThis.require = require;
+  }
+
+  if (!globalThis.XMLHttpRequest) {
+    class FileUrlXMLHttpRequest {
+      open(method, url, async = true) {
+        this.method = method;
+        this.url = url;
+        this.async = async;
+        this.status = 0;
+        this.response = null;
+      }
+
+      overrideMimeType() {}
+
+      send() {
+        if (this.async) {
+          throw new Error("Async file XMLHttpRequest is not supported.");
+        }
+        const target =
+          typeof this.url === "string" && this.url.startsWith("file:")
+            ? new URL(this.url)
+            : this.url;
+        const data = readFileSync(target);
+        this.status = 200;
+        this.response = data.buffer.slice(
+          data.byteOffset,
+          data.byteOffset + data.byteLength,
+        );
+      }
+    }
+
+    globalThis.XMLHttpRequest = FileUrlXMLHttpRequest;
+  }
+
+  if (!globalThis[FILE_URL_FETCH_PATCH_FLAG]) {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      const url =
+        typeof input === "string"
+          ? input
+          : input?.url ?? String(input);
+      if (!url.startsWith("file:")) {
+        if (typeof originalFetch !== "function") {
+          throw new Error("fetch is not available for non-file URLs.");
+        }
+        return originalFetch(input, init);
+      }
+      const bytes = await readFile(new URL(url));
+      return {
+        ok: true,
+        status: 200,
+        url,
+        async arrayBuffer() {
+          return bytes.buffer.slice(
+            bytes.byteOffset,
+            bytes.byteOffset + bytes.byteLength,
+          );
+        },
+      };
+    };
+    globalThis[FILE_URL_FETCH_PATCH_FLAG] = true;
+  }
+}
+
+async function patchEmceptionModuleTree(rootDir) {
+  const entries = await readdir(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      await patchEmceptionModuleTree(fullPath);
+      continue;
+    }
+    if (!entry.name.endsWith(".mjs")) {
+      continue;
+    }
+
+    let source = await readFile(fullPath, "utf8");
+    source = source.replaceAll(
+      'scriptDirectory=__dirname+"/"',
+      'scriptDirectory=(new URL(".", import.meta.url)).pathname',
+    );
+
+    if (entry.name === "emception.mjs") {
+      source = source.replace(
+        "this.#fs = await new FileSystem();",
+        [
+          "this.#fs = await new FileSystem({",
+          "      locateFile: (file, scriptDirectory) => scriptDirectory + file,",
+          '      cache: "/tmp/emception-cache",',
+          "    });",
+        ].join("\n"),
+      );
+      source = source.replace(
+        "const config = {",
+        [
+          "const config = {",
+          "      locateFile: (file, scriptDirectory) => scriptDirectory + file,",
+        ].join("\n"),
+      );
+    }
+
+    if (entry.name === "FileSystem.mjs") {
+      source = source.replace(
+        [
+          "        if (!this.exists(cache)) {",
+          "            this.persist(cache);",
+          "        }",
+          "        await this.pull();",
+        ].join("\n"),
+        [
+          '        if (typeof indexedDB !== "undefined") {',
+          "            if (!this.exists(cache)) {",
+          "                this.persist(cache);",
+          "            }",
+          "            await this.pull();",
+          "        }",
+        ].join("\n"),
+      );
+    }
+
+    await writeFile(fullPath, source, "utf8");
+  }
+}
+
+async function preparePatchedEmceptionRoot() {
+  if (!patchedEmceptionRootPromise) {
+    patchedEmceptionRootPromise = (async () => {
+      const sourceRoot = path.dirname(require.resolve("sdn-emception"));
+      const markerPath = path.join(EMCEPTION_PATCH_ROOT, PATCH_MARKER_FILENAME);
+      let marker = null;
+      try {
+        marker = await readFile(markerPath, "utf8");
+      } catch {
+        marker = null;
+      }
+
+      if (marker?.trim() !== PATCH_VERSION) {
+        await rm(EMCEPTION_PATCH_ROOT, { recursive: true, force: true });
+        await cp(sourceRoot, EMCEPTION_PATCH_ROOT, { recursive: true });
+        await patchEmceptionModuleTree(EMCEPTION_PATCH_ROOT);
+        await writeFile(markerPath, `${PATCH_VERSION}\n`, "utf8");
+      }
+
+      return EMCEPTION_PATCH_ROOT;
+    })().catch((error) => {
+      patchedEmceptionRootPromise = null;
+      throw error;
+    });
+  }
+
+  return patchedEmceptionRootPromise;
+}
+
+class EmceptionController {
+  #instancePromise = null;
+  #executionQueue = Promise.resolve();
+
+  async load() {
+    if (!this.#instancePromise) {
+      this.#instancePromise = (async () => {
+        installNodeRuntimeShims();
+        const patchedRoot = await preparePatchedEmceptionRoot();
+        const moduleUrl = pathToFileURL(path.join(patchedRoot, "emception.mjs")).href;
+        const { default: Emception } = await import(moduleUrl);
+        const emception = new Emception({
+          baseUrl: pathToFileURL(`${patchedRoot}${path.sep}`).href,
+        });
+        await emception.init();
+        return emception;
+      })().catch((error) => {
+        this.#instancePromise = null;
+        throw error;
+      });
+    }
+
+    return this.#instancePromise;
+  }
+
+  async withLock(task) {
+    const previous = this.#executionQueue;
+    let release = () => {};
+    this.#executionQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous.catch(() => {});
+    try {
+      const emception = await this.load().catch((error) => {
+        if (!error.code) {
+          error.code = "EMCEPTION_LOAD_FAILED";
+        }
+        throw error;
+      });
+      return await task(emception);
+    } finally {
+      release();
+    }
+  }
+}
+
+const sharedEmceptionController = new EmceptionController();
+
+export function getSharedEmceptionController() {
+  return sharedEmceptionController;
+}
+
+export async function loadEmception() {
+  return sharedEmceptionController.load();
+}
+
+export async function runWithEmceptionLock(task) {
+  return sharedEmceptionController.withLock(task);
+}

package/src/compiler/flatcSupport.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+import { FlatcRunner } from "flatc-wasm";
+
+const SDK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const SCHEMA_DIR = path.join(SDK_ROOT, "schemas");
+
+let flatcRunnerPromise = null;
+let flatbuffersCppRuntimeHeadersPromise = null;
+let invokeCppSchemaHeadersPromise = null;
+
+function loadFlatcRunner() {
+  if (!flatcRunnerPromise) {
+    flatcRunnerPromise = FlatcRunner.init();
+  }
+  return flatcRunnerPromise;
+}
+
+async function loadInvokeSchemaFiles() {
+  const filenames = [
+    "TypedArenaBuffer.fbs",
+    "PluginInvokeRequest.fbs",
+    "PluginInvokeResponse.fbs",
+  ];
+  const entries = await Promise.all(
+    filenames.map(async (filename) => [
+      `/schemas/${filename}`,
+      await readFile(path.join(SCHEMA_DIR, filename), "utf8"),
+    ]),
+  );
+  return Object.fromEntries(entries);
+}
+
+export async function getFlatbuffersCppRuntimeHeaders() {
+  if (!flatbuffersCppRuntimeHeadersPromise) {
+    flatbuffersCppRuntimeHeadersPromise = (async () => {
+      const flatc = await loadFlatcRunner();
+      return flatc.getEmbeddedRuntime("cpp");
+    })();
+  }
+  return flatbuffersCppRuntimeHeadersPromise;
+}
+
+export async function getInvokeCppSchemaHeaders() {
+  if (!invokeCppSchemaHeadersPromise) {
+    invokeCppSchemaHeadersPromise = (async () => {
+      const flatc = await loadFlatcRunner();
+      const schemaFiles = await loadInvokeSchemaFiles();
+      const generatedHeaders = {};
+      for (const entry of Object.keys(schemaFiles)) {
+        Object.assign(
+          generatedHeaders,
+          flatc.generateCode(
+            { entry, files: schemaFiles },
+            "cpp",
+            { genObjectApi: true },
+          ),
+        );
+      }
+      return generatedHeaders;
+    })();
+  }
+  return invokeCppSchemaHeadersPromise;
+}

package/src/compiler/index.d.ts

@@ -0,0 +1,24 @@
+export type {
+  CompilationResult,
+  ProtectedArtifact,
+} from "../index.js";
+
+export {
+  cleanupCompilation,
+  compileModuleFromSource,
+  createRecipientKeypairHex,
+  protectModuleArtifact,
+} from "../index.js";
+
+export type {
+  EmceptionCommandResult,
+  SharedEmceptionFileContent,
+  SharedEmceptionHandle,
+  SharedEmceptionSession,
+} from "./emception.js";
+
+export {
+  createSharedEmceptionSession,
+  loadSharedEmception,
+  withSharedEmception,
+} from "./emception.js";

package/src/compiler/index.js

@@ -5,3 +5,8 @@ export {
   protectModuleArtifact,
 } from "./compileModule.js";
 
+export {
+  createSharedEmceptionSession,
+  loadSharedEmception,
+  withSharedEmception,
+} from "./emception.js";