@bytecodealliance/preview2-shim 0.0.3 → 0.0.5

package/lib/http/wasi-http.js

@@ -0,0 +1,267 @@
+// Based on:
+// https://github.com/bytecodealliance/wasmtime/blob/76eb40e0756d90cc9c16b26a8d8b1e0ebf75f44d/crates/wasi-http/src/http_impl.rs
+
+/**
+ * @typedef {import("../../types/imports/types").Fields} Fields
+ * @typedef {import("../../types/imports/types").FutureIncomingResponse} FutureIncomingResponse
+ * @typedef {import("../../types/imports/types").Headers} Headers
+ * @typedef {import("../../types/imports/types").IncomingResponse} IncomingResponse
+ * @typedef {import("../../types/imports/types").IncomingStream} IncomingStream
+ * @typedef {import("../../types/imports/types").Method} Method
+ * @typedef {import("../../types/imports/types").OutgoingRequest} OutgoingRequest
+ * @typedef {import("../../types/imports/types").RequestOptions} RequestOptions
+ * @typedef {import("../../types/imports/types").Scheme} Scheme
+ * @typedef {import("../../types/imports/types").StatusCode} StatusCode
+ */
+
+import * as io from '@bytecodealliance/preview2-shim/io';
+import * as http from '@bytecodealliance/preview2-shim/http';
+
+export class WasiHttp {
+  requestIdBase = 1;
+  responseIdBase = 1;
+  fieldsIdBase = 1;
+  streamsIdBase = 3;
+  /** @type {Map<number,ActiveRequest>} */ requests = new Map();
+  /** @type {Map<number,ActiveResponse>} */ responses = new Map();
+  /** @type {Map<number,Map<string,string[]>>} */ fields = new Map();
+  /** @type {Map<number,Uint8Array>} */ streams = new Map();
+
+  constructor() {}
+
+  /**
+   * @param {OutgoingRequest} requestId
+   * @param {RequestOptions | null} options
+   * @returns {FutureIncomingResponse}
+   */
+  handle = (requestId, {
+    connectTimeoutMs: _connectTimeoutMs = 600_000,
+    firstByteTimeoutMs: _firstByteTimeoutMs = 600_000,
+    betweenBytesTimeoutMs: _betweenBytesTimeoutMs = 600_000
+  } = {}) => {
+    const request = this.requests.get(requestId);
+    if (!request) throw Error("not found!");
+
+    const responseId = this.responseIdBase;
+    this.responseIdBase += 1;
+    const response = new ActiveResponse(responseId);
+
+    const scheme = request.scheme.tag === "HTTP" ? "http://" : "https://";
+
+    const url = scheme + request.authority + request.path + request.query;
+    const headers = {
+      "host": request.authority,
+    };
+    for (const [key, value] of request.headers.entries()) {
+      headers[key] = Array.isArray(value) ? value.join(",") : value;
+    }
+    const body =  this.streams.get(request.body);
+
+    const res = http.send({
+      method: request.method.tag,
+      uri: url,
+      headers: headers,
+      params: [],
+      body: body && body.length > 0 ? body : undefined,
+    });
+
+    response.status = res.status;
+    for (const [key, value] of res.headers) {
+      response.responseHeaders.set(key, [value]);
+    }
+    const buf = res.body;
+    response.body = this.streamsIdBase;
+    this.streamsIdBase = this.streamsIdBase + 1;
+    this.streams.set(response.body, buf);
+    this.responses.set(responseId, response);
+    return responseId;
+  }
+
+  /**
+   * @param {InputStream} stream 
+   * @param {bigint} len 
+   * @returns {[Uint8Array | ArrayBuffer, boolean]}
+   */
+  read = (stream, len) => {
+    if (stream < 3) {
+      return io.read(stream);
+    }
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`stream not found: ${stream}`);
+    const position = Number(len);
+    if (position === 0) {
+      return [new Uint8Array(), s.byteLength > 0];
+    } else if (s.byteLength > position) {
+      this.streams.set(stream, s.slice(position, s.byteLength));
+      return [s.slice(0, position), false];
+    } else {
+      return [s.slice(0, position), true];
+    }
+  }
+
+  /**
+   * @param {InputStream} stream 
+   * @returns {Pollable}
+   */
+  subscribeToInputStream = (_stream) => {
+    throw Error("unimplemented: subscribeToInputStream");
+  }
+
+  /**
+   * @param {InputStream} stream 
+   */
+  dropInputStream = (stream) => {
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`no such input stream ${stream}`);
+    s.set([]);
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   * @param {Uint8Array} buf 
+   * @returns {bigint}
+   */
+  write = (stream, buf) => {
+    if (stream < 3) {
+      return io.write(stream, buf);
+    }
+    this.streams.set(stream, buf);
+    return BigInt(buf.byteLength);
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   * @returns {Pollable}
+   */
+  subscribeToOutputStream = (_stream) => {
+    throw Error("unimplemented: subscribeToOutputStream");
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   */
+  dropOutputStream = (stream) => {
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`no such output stream ${stream}`);
+    s.set([]);
+  }
+
+  /**
+   * @param {[string, string][]} entries
+   * @returns {Fields}
+   */
+  newFields = (entries) => {
+    const map = new Map(entries);
+
+    const id = this.fieldsIdBase;
+    this.fieldsIdBase = id + 1;
+    this.fields.set(id, map);
+
+    return id;
+  }
+
+  /**
+   * @param {Fields} fields
+   * @returns {[string, string][]}
+   */
+  fieldsEntries = (fields) => {
+    return this.fields.get(fields) ?? [];
+  }
+
+  /**
+   * @param {OutgoingRequest} request
+   */
+  dropOutgoingRequest = (request) => {
+    this.requests.delete(request);
+  }
+
+  /**
+   * @param {Method} method
+   * @param {string} path
+   * @param {string} query
+   * @param {Scheme | null} scheme
+   * @param {string} authority
+   * @param {Headers} headers
+   * @returns {number}
+   */
+  newOutgoingRequest = (method, path, query, scheme, authority, headers) => {
+    const id = this.requestIdBase;
+    this.requestIdBase += 1;
+
+    const req = new ActiveRequest(id);
+    req.path = path;
+    req.query = query;
+    req.authority = authority;
+    req.method = method;
+    req.headers = this.fields.get(headers);
+    req.scheme = scheme;
+    this.requests.set(id, req);
+    return id;
+  }
+  
+  /**
+   * @param {IncomingResponse} response
+   */
+  dropIncomingResponse = (response) => {
+    this.responses.delete(response);
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {StatusCode}
+   */
+  incomingResponseStatus = (response) => {
+    const r = this.responses.get(response);
+    return r.status;
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {Headers}
+   */
+  incomingResponseHeaders = (response) => {
+    const r = this.responses.get(response);
+    const id = this.fieldsIdBase;
+    this.fieldsIdBase = this.fieldsIdBase + 1;
+
+    this.fields.set(id, r.responseHeaders);
+    return id;
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {IncomingStream}
+   */
+  incomingResponseConsume = (response) => {
+    const r = this.responses.get(response);
+    return r.body;
+  }
+}
+
+class ActiveRequest {
+  /** @type {number} */ id;
+  activeRequest = false;
+  /** @type {Method} */ method = { tag: 'get' };
+  /** @type {Scheme | null} */ scheme = { tag: 'HTTP' };
+  path = "";
+  query = "";
+  authority = "";
+  /** @type {Map<string,string[]>} */ headers = new Map();
+  body = 3;
+
+  constructor(id) {
+    this.id = id;
+  }
+}
+
+class ActiveResponse {
+  /** @type {number} */ id;
+  activeResponse = false;
+  status = 0;
+  body = 3;
+  /** @type {Map<string,string[]>} */ responseHeaders = new Map();
+
+  constructor(id) {
+    this.id = id;
+  }
+}

package/lib/nodejs/default-outgoing-HTTP.js

@@ -0,0 +1,3 @@
+export function handle(_request, _options) {
+  console.log("[default-outgoing-HTTP] Handle");
+}

package/lib/nodejs/environment-preopens.js

@@ -0,0 +1,3 @@
+export function preopens () {
+  return [];
+}

package/lib/nodejs/environment.js

@@ -1,3 +1,7 @@
 export function getEnvironment () {
   return [];
 }
+
+export function preopens () {
+  return [];
+}

package/lib/nodejs/filesystem.js

@@ -9,7 +9,7 @@
 //   ctim: Timestamp,
 // }
 
-export function flags(fd) {
+export function getFlags(fd) {
   console.log(`[filesystem] FLAGS FOR ${fd}`);
 }
 
@@ -49,14 +49,16 @@ export function stat(fd) {
   console.log(`[filesystem] STAT: ${fd}`);
 }
 
-export function todoType(fd) {
+export function getType(fd) {
   console.log(`[filesystem] TODO TYPE: ${fd}`);
 }
 
-export function dropDirEntryStream(s) {
+export function dropDirectoryEntryStream(s) {
   console.log(`[filesystem] CLOSE DIR ENTRY STREAM ${s}`);
 }
 
-export function getPreopens () {
-  console.log(`[filesystem] GET PREOPENS`);
+// backwards compat
+export function getPreopens() {
+  return [];
 }
+export { getFlags as flags, getType as todoType, dropDirectoryEntryStream as dropDirEntryStream }

package/lib/nodejs/http.js

@@ -1,12 +1,12 @@
-import { createSyncFn } from "synckit";
-import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { UnexpectedError } from "../http/error.js";
+import { createSyncFn } from "../http/synckit/index.js";
+
+const workerPath = fileURLToPath(new URL('../http/make-request.js', import.meta.url));
 
 export function send(req) {
   console.log(`[http] Send (nodejs) ${req.uri}`);
-  const dirname = path.dirname(fileURLToPath(import.meta.url));
-  const syncFn = createSyncFn(path.resolve(dirname, "../http/make-request.js"));
+  const syncFn = createSyncFn(workerPath);
   let rawResponse = syncFn(req);
   let response = JSON.parse(rawResponse);
   if (response.status) {

package/lib/nodejs/index.js

@@ -1,21 +1,43 @@
-import * as clocks from "./clocks.js";
-import * as defaultClocks from "./default-clocks.js";
+import * as console from "./console.js";
+import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
+import * as environment from "./environment.js";
+import * as environmentPreopens from "./environment-preopens.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
+import * as http from "./http.js";
+import * as instanceMonotonicClock from "./instance-monotonic-clock.js";
+import * as instanceWallClock from "./instance-wall-clock.js";
 import * as io from "./io.js";
-import * as logging from "./logging.js";
+import * as monotonicClock from "./monotonic-clock.js";
 import * as poll from "./poll.js";
+import * as preopens from "./preopens.js";
 import * as random from "./random.js";
 import * as stderr from "./stderr.js";
+import * as streams from "./streams.js";
+import * as types from "./types.js";
+import * as wallClock from "./wall-clock.js";
 
 export const importObject = {
-    "wasi-clocks": clocks,
-    "wasi-default-clocks": defaultClocks,
-    "wasi-exit": exit,
-    "wasi-filesystem": filesystem,
-    "wasi-io": io,
-    "wasi-logging": logging,
-    "wasi-poll": poll,
-    "wasi-random": random,
-    "wasi-stderr": stderr,
+    "console": console,
+    "default-outgoing-HTTP": defaultOutgoingHttp,
+    "environment": environment,
+    "environment-preopens": environmentPreopens,
+    "exit": exit,
+    "filesystem": filesystem,
+    "http": http,
+    "instance-monotonic-clock": instanceMonotonicClock,
+    "instance-wall-clock": instanceWallClock,
+    "io": io,
+    "monotonic-clock": monotonicClock,
+    "poll": poll,
+    "preopens": preopens,
+    "random": random,
+    "stderr": stderr,
+    "streams": streams,
+    "types": types,
+    "wall-clock": wallClock,
 };
+
+export { WasiHttp } from "../http/wasi-http.js";
+
+export default importObject;

package/lib/nodejs/instance-monotonic-clock.js

@@ -0,0 +1,3 @@
+export function instanceMonotonicClock() {
+  return 0;
+}

package/lib/nodejs/instance-wall-clock.js

@@ -0,0 +1,3 @@
+export function instanceWallClock() {
+  return 1;
+}

package/lib/nodejs/io.js

@@ -1,33 +1,25 @@
-export function dropInputStream(f) {
-  console.log(`[io] Drop input stream ${f}`);
-}
-
-export function dropOutputStream(f) {
-  console.log(`[io] Drop output stream ${f}`);
-}
-
-export function read(src, len) {
-  console.log(`[io] Read ${src}`, len);
+export function read(s, len) {
+  switch (s) {
+    case 0:
+      return [process.stdin.read(len), true];
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
 }
 
-export function write(dst, buf) {
-  switch (dst) {
+export function write(s, buf) {
+  switch (s) {
     case 0:
       throw new Error(`TODO: write stdin`);
-    case 1:
+    case 1: {
       process.stdout.write(buf);
       return BigInt(buf.byteLength);
-    case 2:
-      throw new Error(`TODO: write stdout`);
+    }
+    case 2: {
+      process.stderr.write(buf);
+      return BigInt(buf.byteLength);
+    }
     default:
-      throw new Error(`TODO: write ${dst}`);
+      throw new Error(`TODO: write ${s}`);
   }
 }
-
-export function skip(src, len) {
-  console.log(`[io] Skip ${src}`, len);
-}
-
-export function write_repeated(dst, byte, len) {
-  console.log(`[io] Write repeated ${dst}`, byte, len);
-}

package/lib/nodejs/monotonic-clock.js

@@ -12,3 +12,7 @@ export function now(clock) {
   }
   console.log("[clocks] UNKNOWN CLOCK");
 }
+
+export function instanceMonotonicClock () {
+  return 0;
+}

package/lib/nodejs/poll.js

@@ -1,3 +1,7 @@
+export function dropPollable(p) {
+  console.log(`[poll] Drop pollable ${p}`);
+}
+
 export function pollOneoff(f) {
   console.log(`[poll] Poll oneoff ${f}`);
 }

package/lib/nodejs/preopens.js

@@ -0,0 +1,11 @@
+export function getStdio () {
+  return {
+    stdin: 0,
+    stdout: 1,
+    stderr: 2,
+  };
+}
+
+export function getDirectories () {
+  return [];
+}

package/lib/nodejs/random.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
 
 export function getRandomBytes(len) {
-  return randomBytes(len);
+  return randomBytes(Number(len));
 }

package/lib/nodejs/streams.js

@@ -0,0 +1,63 @@
+export function read(s, len) {
+  switch (s) {
+    case 0:
+      return [process.stdin.read(len), true];
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
+}
+export function blockingRead(s, _len) {
+  console.log(`[streams] Blocking read ${s}`);
+}
+export function skip(s, _len) {
+  console.log(`[streams] Skip ${s}`);
+}
+export function blockingSkip(s, _len) {
+  console.log(`[streams] Blocking skip ${s}`);
+}
+export function subscribeToInputStream(s) {
+  console.log(`[streams] Subscribe to input stream ${s}`);
+}
+export function dropInputStream(s) {
+  console.log(`[streams] Drop input stream ${s}`);
+}
+export function write(s, buf) {
+  switch (s) {
+    case 0:
+      throw new Error(`TODO: write stdin`);
+    case 1: {
+      process.stdout.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    case 2: {
+      process.stderr.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
+}
+export function blockingWrite(s, _buf) {
+  console.log(`[streams] Blocking write ${s}`);
+}
+export function writeZeroes(s, _len) {
+  console.log(`[streams] Write zeroes ${s}`);
+}
+export function blockingWriteZeroes(s, _len) {
+  console.log(`[streams] Blocking write zeroes ${s}`);
+}
+export function splice(s, _src, _len) {
+  console.log(`[streams] Splice ${s}`);
+}
+export function blockingSplice(s, _src, _len) {
+  console.log(`[streams] Blocking splice ${s}`);
+}
+export function forward(s, _src) {
+  console.log(`[streams] Forward ${s}`);
+}
+export function subscribeToOutputStream(s) {
+  console.log(`[streams] Subscribe to output stream ${s}`);
+}
+export function dropOutputStream(s) {
+  console.log(`[streams] Drop output stream ${s}`);
+}

package/lib/nodejs/types.js

@@ -0,0 +1,99 @@
+export function dropFields(_fields) {
+  console.log("[types] Drop fields");
+}
+export function newFields(_entries) {
+  console.log("[types] New fields");
+}
+export function fieldsGet(_fields, _name) {
+  console.log("[types] Fields get");
+}
+export function fieldsSet(_fields, _name, _value) {
+  console.log("[types] Fields set");
+}
+export function fieldsDelete(_fields, _name) {
+  console.log("[types] Fields delete");
+}
+export function fieldsAppend(_fields, _name, _value) {
+  console.log("[types] Fields append");
+}
+export function fieldsEntries(_fields) {
+  console.log("[types] Fields entries");
+}
+export function fieldsClone(_fields) {
+  console.log("[types] Fields clone");
+}
+export function finishIncomingStream(s) {
+  console.log(`[types] Finish incoming stream ${s}`);
+}
+export function finishOutgoingStream(s, _trailers) {
+  console.log(`[types] Finish outgoing stream ${s}`);
+}
+export function dropIncomingRequest(_req) {
+  console.log("[types] Drop incoming request");
+}
+export function dropOutgoingRequest(_req) {
+  console.log("[types] Drop outgoing request");
+}
+export function incomingRequestMethod(_req) {
+  console.log("[types] Incoming request method");
+}
+export function incomingRequestPath(_req) {
+  console.log("[types] Incoming request path");
+}
+export function incomingRequestQuery(_req) {
+  console.log("[types] Incoming request query");
+}
+export function incomingRequestScheme(_req) {
+  console.log("[types] Incoming request scheme");
+}
+export function incomingRequestAuthority(_req) {
+  console.log("[types] Incoming request authority");
+}
+export function incomingRequestHeaders(_req) {
+  console.log("[types] Incoming request headers");
+}
+export function incomingRequestConsume(_req) {
+  console.log("[types] Incoming request consume");
+}
+export function newOutgoingRequest(_method, _path, _query, _scheme, _authority, _headers) {
+  console.log("[types] New outgoing request");
+}
+export function outgoingRequestWrite(_req) {
+  console.log("[types] Outgoing request write");
+}
+export function dropResponseOutparam(_res) {
+  console.log("[types] Drop response outparam");
+}
+export function setResponseOutparam(_response) {
+  console.log("[types] Drop fields");
+}
+export function dropIncomingResponse(_res) {
+  console.log("[types] Drop incoming response");
+}
+export function dropOutgoingResponse(_res) {
+  console.log("[types] Drop outgoing response");
+}
+export function incomingResponseStatus(_res) {
+  console.log("[types] Incoming response status");
+}
+export function incomingResponseHeaders(_res) {
+  console.log("[types] Incoming response headers");
+}
+export function incomingResponseConsume(_res) {
+  console.log("[types] Incoming response consume");
+}
+export function newOutgoingResponse(_statusCode, _headers) {
+  console.log("[types] New outgoing response");
+}
+export function outgoingResponseWrite(_res) {
+  console.log("[types] Outgoing response write");
+}
+export function dropFutureIncomingResponse(_f) {
+  console.log("[types] Drop future incoming response");
+}
+export function futureIncomingResponseGet(_f) {
+  console.log("[types] Future incoming response get");
+}
+export function listenToFutureIncomingResponse(_f) {
+  console.log("[types] Listen to future incoming response");
+}

package/lib/nodejs/wall-clock.js

@@ -10,3 +10,7 @@ export function now(clock) {
 export function resolution(clock) {
   console.log(`[clocks] Wall clock resolution ${clock}`);
 }
+
+export function instanceWallClock () {
+  return 1;
+}