space-data-module-sdk 0.5.15 → 0.5.18

package/src/testing/processInvoke.js

@@ -10,6 +10,23 @@ import {
 } from "../invoke/index.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 
+const WASMEDGE_HOST_MAGIC = Uint8Array.from([0x4f, 0x52, 0x50, 0x57]); // ORPW
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const HOST_CONTROL_OPCODE = Object.freeze({
+  INSTALL_MODULE: 16,
+  LIST_MODULES: 17,
+  UNLOAD_MODULE: 18,
+  INVOKE_MODULE: 19,
+  APPEND_ROW: 20,
+  LIST_ROWS: 21,
+  RESOLVE_ROW: 22,
+  ALLOCATE_REGION: 23,
+  DESCRIBE_REGION: 24,
+  RESOLVE_RECORD: 25,
+  QUERY_ROWS: 26,
+});
+
 function formatProcessFailure(message, stderrChunks = [], cause = null) {
   const stderrText = Buffer.concat(stderrChunks).toString("utf8").trim();
   const details = stderrText ? `${message}\n${stderrText}` : message;
@@ -49,6 +66,25 @@ export function buildWasmEdgeSpawnEnv(baseEnv = process.env) {
 }
 
 export function resolveWasmEdgePluginLaunchPlan(options = {}) {
+  const hostProfile = String(options.hostProfile ?? "").trim().toLowerCase();
+  if (hostProfile === "runtime-host") {
+    if (
+      typeof options.wasmEdgeRunnerBinary !== "string" ||
+      options.wasmEdgeRunnerBinary.trim().length === 0
+    ) {
+      throw new Error(
+        "resolveWasmEdgePluginLaunchPlan requires wasmEdgeRunnerBinary for runtime-host mode.",
+      );
+    }
+    return {
+      command: options.wasmEdgeRunnerBinary,
+      args: ["--serve-runtime-host"],
+      env: buildWasmEdgeSpawnEnv(options.env),
+      wasmPath: null,
+      hostProfile: "runtime-host",
+    };
+  }
+
   const wasmPath =
     typeof options.wasmPath === "string" && options.wasmPath.trim().length > 0
       ? path.resolve(options.wasmPath)
@@ -83,7 +119,7 @@ export function resolveWasmEdgePluginLaunchPlan(options = {}) {
   };
 }
 
-export async function createPluginInvokeProcessClient(options = {}) {
+async function createLengthPrefixedProcessClient(options = {}) {
   const launchPlan = normalizeLaunchPlan(options);
   if (
     typeof launchPlan.command !== "string" ||
@@ -202,15 +238,7 @@ export async function createPluginInvokeProcessClient(options = {}) {
 
   return {
     launchPlan,
-
-    async invoke(request = {}) {
-      const requestBytes = encodePluginInvokeRequest(request);
-      const responseBytes = await invokeRaw(requestBytes);
-      return decodePluginInvokeResponse(responseBytes);
-    },
-
     invokeRaw,
-
     async destroy() {
       expectedShutdown = true;
       if (!closed) {
@@ -224,3 +252,216 @@ export async function createPluginInvokeProcessClient(options = {}) {
     },
   };
 }
+
+function encodeHostControl(opcode, payload = new Uint8Array()) {
+  const message = new Uint8Array(5 + payload.length);
+  message.set(WASMEDGE_HOST_MAGIC, 0);
+  message[4] = opcode;
+  message.set(payload, 5);
+  return message;
+}
+
+function encodeJsonPayload(value) {
+  return textEncoder.encode(JSON.stringify(value));
+}
+
+function decodeJsonPayload(bytes) {
+  if (!bytes || bytes.length === 0) {
+    return null;
+  }
+  return JSON.parse(textDecoder.decode(bytes));
+}
+
+function encodeU32(value) {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value >>> 0, true);
+  return bytes;
+}
+
+function decodeU32(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(
+    0,
+    true,
+  );
+}
+
+function encodeModuleInvokePayload(moduleId, requestBytes) {
+  if (typeof moduleId !== "string" || moduleId.trim().length === 0) {
+    throw new TypeError("moduleId must be a non-empty string");
+  }
+  const moduleIdBytes = textEncoder.encode(moduleId.trim());
+  const requestPayload = toUint8Array(requestBytes);
+  if (!requestPayload) {
+    throw new TypeError("module invoke request bytes are required");
+  }
+  const payload = new Uint8Array(4 + moduleIdBytes.length + requestPayload.length);
+  payload.set(encodeU32(moduleIdBytes.length), 0);
+  payload.set(moduleIdBytes, 4);
+  payload.set(requestPayload, 4 + moduleIdBytes.length);
+  return payload;
+}
+
+function serializeRegionOptions(options = {}) {
+  return {
+    ...options,
+    initialRecords: Array.isArray(options.initialRecords)
+      ? options.initialRecords.map((record) =>
+          record === null || record === undefined
+            ? null
+            : Array.from(
+                toUint8Array(record) ??
+                  (() => {
+                    throw new TypeError(
+                      "runtime region initialRecords must be byte-oriented",
+                    );
+                  })(),
+              ),
+        )
+      : [],
+  };
+}
+
+function normalizeRecordResponse(record) {
+  if (!record) {
+    return null;
+  }
+  return {
+    ...record,
+    bytes: Uint8Array.from(record.bytes ?? []),
+  };
+}
+
+async function invokeJsonHostControl(rawClient, opcode, payload) {
+  const responseBytes = await rawClient.invokeRaw(
+    encodeHostControl(opcode, encodeJsonPayload(payload)),
+  );
+  return decodeJsonPayload(responseBytes);
+}
+
+function attachRuntimeHostControls(client, rawClient, options = {}) {
+  const encodeRequest = options.encodeRequest ?? ((request) => request);
+  const decodeResponse = options.decodeResponse ?? ((response) => response);
+
+  return Object.assign(client, {
+    installModule(definition = {}) {
+      return invokeJsonHostControl(
+        rawClient,
+        HOST_CONTROL_OPCODE.INSTALL_MODULE,
+        definition,
+      );
+    },
+    listModules() {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.LIST_MODULES, {});
+    },
+    unloadModule(moduleId) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.UNLOAD_MODULE, {
+        moduleId,
+      });
+    },
+    async invokeModule(moduleId, request = {}) {
+      const responseBytes = await rawClient.invokeRaw(
+        encodeHostControl(
+          HOST_CONTROL_OPCODE.INVOKE_MODULE,
+          encodeModuleInvokePayload(moduleId, encodeRequest(request)),
+        ),
+      );
+      return decodeResponse(responseBytes);
+    },
+    appendRow(options = {}) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.APPEND_ROW, options);
+    },
+    listRows(schemaFileId = null) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.LIST_ROWS, {
+        schemaFileId,
+      });
+    },
+    resolveRow(handle) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.RESOLVE_ROW, handle);
+    },
+    queryRows(sql) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.QUERY_ROWS, {
+        sql,
+      });
+    },
+    allocateRegion(options = {}) {
+      return invokeJsonHostControl(
+        rawClient,
+        HOST_CONTROL_OPCODE.ALLOCATE_REGION,
+        serializeRegionOptions(options),
+      );
+    },
+    describeRegion(regionId) {
+      return invokeJsonHostControl(rawClient, HOST_CONTROL_OPCODE.DESCRIBE_REGION, {
+        regionId,
+      });
+    },
+    async resolveRecord(query = {}) {
+      const record = await invokeJsonHostControl(
+        rawClient,
+        HOST_CONTROL_OPCODE.RESOLVE_RECORD,
+        query,
+      );
+      return normalizeRecordResponse(record);
+    },
+  });
+}
+
+export async function createWasmEdgeStreamProcessClient(options = {}) {
+  const rawClient = await createLengthPrefixedProcessClient(options);
+
+  const client = {
+    launchPlan: rawClient.launchPlan,
+
+    invokeRaw(requestBytes) {
+      return rawClient.invokeRaw(requestBytes);
+    },
+
+    async invoke(request = {}) {
+      const requestBytes = encodePluginInvokeRequest(request);
+      const responseBytes = await rawClient.invokeRaw(requestBytes);
+      return decodePluginInvokeResponse(responseBytes);
+    },
+
+    destroy() {
+      return rawClient.destroy();
+    },
+  };
+
+  return attachRuntimeHostControls(client, rawClient, {
+    encodeRequest(request) {
+      return encodePluginInvokeRequest(request);
+    },
+    decodeResponse(responseBytes) {
+      return decodePluginInvokeResponse(responseBytes);
+    },
+  });
+}
+
+export async function createPluginInvokeProcessClient(options = {}) {
+  const rawClient = await createLengthPrefixedProcessClient(options);
+
+  const client = {
+    launchPlan: rawClient.launchPlan,
+
+    async invoke(request = {}) {
+      const requestBytes = encodePluginInvokeRequest(request);
+      const responseBytes = await rawClient.invokeRaw(requestBytes);
+      return decodePluginInvokeResponse(responseBytes);
+    },
+
+    invokeRaw: rawClient.invokeRaw,
+
+    destroy() {
+      return rawClient.destroy();
+    },
+  };
+
+  return attachRuntimeHostControls(client, rawClient, {
+    encodeRequest(request) {
+      return encodePluginInvokeRequest(request);
+    },
+    decodeResponse(responseBytes) {
+      return decodePluginInvokeResponse(responseBytes);
+    },
+  });
+}

package/src/testing/streamInvokeCodec.js

@@ -0,0 +1,175 @@
+import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+
+import { DrainPolicy } from "../generated/orbpro/manifest/drain-policy.js";
+import { TypedArenaBuffer } from "../generated/orbpro/stream/typed-arena-buffer.js";
+
+function toByteBuffer(data) {
+  if (data instanceof flatbuffers.ByteBuffer) {
+    return data;
+  }
+  return new flatbuffers.ByteBuffer(data);
+}
+
+class StreamInvokeRequest {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+
+  static getRootAsStreamInvokeRequest(bb, obj) {
+    return (obj || new StreamInvokeRequest()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
+
+  static startStreamInvokeRequest(builder) {
+    builder.startObject(4);
+  }
+
+  static addMethodId(builder, methodIdOffset) {
+    builder.addFieldOffset(0, methodIdOffset, 0);
+  }
+
+  static addInputs(builder, inputsOffset) {
+    builder.addFieldOffset(1, inputsOffset, 0);
+  }
+
+  static createInputsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i -= 1) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+
+  static addOutputStreamCap(builder, outputStreamCap) {
+    builder.addFieldInt32(2, outputStreamCap, 0);
+  }
+
+  static addDrainPolicy(builder, drainPolicy) {
+    builder.addFieldInt8(3, drainPolicy, DrainPolicy.DRAIN_UNTIL_YIELD);
+  }
+
+  static endStreamInvokeRequest(builder) {
+    const offset = builder.endObject();
+    builder.requiredField(offset, 4);
+    return offset;
+  }
+}
+
+class StreamInvokeRequestT {
+  constructor(
+    methodId = null,
+    inputs = [],
+    outputStreamCap = 0,
+    drainPolicy = DrainPolicy.DRAIN_UNTIL_YIELD,
+  ) {
+    this.methodId = methodId;
+    this.inputs = inputs;
+    this.outputStreamCap = outputStreamCap;
+    this.drainPolicy = drainPolicy;
+  }
+
+  pack(builder) {
+    const methodId =
+      this.methodId !== null ? builder.createString(this.methodId) : 0;
+    const inputs = StreamInvokeRequest.createInputsVector(
+      builder,
+      builder.createObjectOffsetList(this.inputs),
+    );
+    StreamInvokeRequest.startStreamInvokeRequest(builder);
+    StreamInvokeRequest.addMethodId(builder, methodId);
+    StreamInvokeRequest.addInputs(builder, inputs);
+    StreamInvokeRequest.addOutputStreamCap(builder, this.outputStreamCap);
+    StreamInvokeRequest.addDrainPolicy(builder, this.drainPolicy);
+    return StreamInvokeRequest.endStreamInvokeRequest(builder);
+  }
+}
+
+class StreamInvokeResponse {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+
+  static getRootAsStreamInvokeResponse(bb, obj) {
+    return (obj || new StreamInvokeResponse()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
+
+  outputs(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset
+      ? (obj || new TypedArenaBuffer()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb,
+        )
+      : null;
+  }
+
+  outputsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+
+  backlogRemaining() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+  }
+
+  yielded() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+
+  errorCode() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+
+  errorMessage(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+
+  unpack() {
+    return {
+      outputs: this.bb.createObjList(this.outputs.bind(this), this.outputsLength()),
+      backlogRemaining: this.backlogRemaining(),
+      yielded: this.yielded(),
+      errorCode: this.errorCode(),
+      errorMessage: this.errorMessage(),
+    };
+  }
+}
+
+export function encodeStreamInvokeRequest(request) {
+  const normalized =
+    request instanceof StreamInvokeRequestT
+      ? request
+      : Object.assign(new StreamInvokeRequestT(), request);
+  const builder = new flatbuffers.Builder(1024);
+  builder.finish(normalized.pack(builder));
+  return builder.asUint8Array();
+}
+
+export function decodeStreamInvokeResponse(data) {
+  return StreamInvokeResponse.getRootAsStreamInvokeResponse(
+    toByteBuffer(data),
+  ).unpack();
+}

package/src/transport/records.js

@@ -1,6 +1,12 @@
-import * as flatbuffers from "flatbuffers";
+import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
 
-import { ENC, ENCT, KDF, KeyExchange, SymmetricAlgo } from "spacedatastandards.org/lib/js/ENC/main.js";
+import {
+  ENC,
+  ENCT,
+  KDF,
+  KeyExchange,
+  SymmetricAlgo,
+} from "spacedatastandards.org/lib/js/ENC/main.js";
 import { PNM, PNMT } from "spacedatastandards.org/lib/js/PNM/main.js";
 import { REC, RECT } from "spacedatastandards.org/lib/js/REC/REC.js";
 import { Record, RecordT } from "spacedatastandards.org/lib/js/REC/Record.js";
@@ -75,6 +81,16 @@ function readUint16LE(buffer, offset, label) {
   return buffer[offset] | (buffer[offset + 1] << 8);
 }
 
+function getRecordValueType(recordTable) {
+  if (typeof recordTable.valueType === "function") {
+    return recordTable.valueType();
+  }
+  if (typeof recordTable.value_type === "function") {
+    return recordTable.value_type();
+  }
+  throw new TypeError("REC record table does not expose a value type accessor.");
+}
+
 function readUint32LE(buffer, offset, label) {
   assertBounds(buffer, offset, 4, label);
   return (
@@ -609,10 +625,7 @@ export function decodePublicationRecordCollection(bytes) {
       8,
       `REC trailer record ${index} standard`,
     );
-    const recordType =
-      typeof recordTable.valueType === "function"
-        ? recordTable.valueType()
-        : recordTable.value_type();
+    const recordType = getRecordValueType(recordTable);
     const standard =
       normalizeStringField(recordTable.standard()) ??
       STANDARD_BY_RECORD_TYPE[recordType] ??