@bytecodealliance/preview2-shim 0.0.4 → 0.0.6

package/lib/http/wasi-http.js

@@ -0,0 +1,335 @@
+// 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").Result} Result
+ * @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';
+import { UnexpectedError } from './error.js';
+
+export class WasiHttp {
+  requestIdBase = 1;
+  responseIdBase = 1;
+  fieldsIdBase = 1;
+  streamIdBase = 3;
+  futureIdBase = 1;
+  /** @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();
+  /** @type {Map<number,ActiveFuture>} */ futures = new Map();
+
+  constructor() {}
+
+  /**
+   * @param {OutgoingRequest} requestId
+   * @param {RequestOptions | null} options
+   * @returns {FutureIncomingResponse}
+   */
+  handle = (requestId, _options) => {
+    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.streamIdBase;
+    this.streamIdBase += 1;
+    this.streams.set(response.body, buf);
+    this.responses.set(responseId, response);
+
+    const futureId = this.futureIdBase;
+    this.futureIdBase += 1;
+    const future = new ActiveFuture(futureId, responseId);
+    this.futures.set(futureId, future);
+    return futureId;
+  }
+
+  /**
+   * @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 {Fields} fields
+   */
+  dropFields = (fields) => {
+    this.fields.delete(fields);
+  }
+
+  /**
+   * @param {[string, string][]} entries
+   * @returns {Fields}
+   */
+  newFields = (entries) => {
+    const map = new Map(entries);
+
+    const id = this.fieldsIdBase;
+    this.fieldsIdBase += 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 {OutgoingRequest} request
+   * @returns {OutgoingStream}
+   */
+  outgoingRequestWrite = (request) => {
+    const req = this.requests.get(request);
+    req.body = this.streamIdBase;
+    this.streamIdBase += 1;
+    return req.body;
+  }
+  
+  /**
+   * @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 += 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;
+  }
+
+  /**
+   * @param {FutureIncomingResponse} future
+   */
+  dropFutureIncomingResponse = (future) => {
+    return this.futures.delete(future);
+  }
+
+  /**
+   * @param {FutureIncomingResponse} future
+   * @returns {Result<IncomingResponse, Error> | null}
+   */
+  futureIncomingResponseGet = (future) => {
+    const f = this.futures.get(future);
+    if (!f) {
+      return {
+        tag: "err",
+        val: UnexpectedError(`no such future ${f}`),
+      };
+    }
+    // For now this will assume the future will return
+    // the response immediately
+    const response = f.responseId;
+    const r = this.responses.get(response);
+    if (!r) {
+      return {
+        tag: "err",
+        val: UnexpectedError(`no such response ${response}`),
+      };
+    }
+    return {
+      tag: "ok",
+      val: response,
+    };
+  }
+}
+
+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;
+  }
+}
+
+class ActiveFuture {
+  /** @type {number} */ id;
+  /** @type {number} */ responseId;
+
+  constructor(id, responseId) {
+    this.id = id;
+    this.responseId = responseId;
+  }
+}

package/lib/nodejs/environment-preopens.js

@@ -0,0 +1,4 @@
+// TODO: remove
+export function preopens () {
+  return [];
+}

package/lib/nodejs/filesystem.js

@@ -9,56 +9,142 @@
 //   ctim: Timestamp,
 // }
 
+export function readViaStream(fd, offset) {
+  console.log(`[filesystem] READ STREAM ${fd} ${offset}`);
+}
+
+export function writeViaStream(fd, offset) {
+  console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
+}
+
+export function appendViaStream(fd) {
+  console.log(`[filesystem] APPEND STREAM ${fd}`);
+}
+
+export function advise(fd, offset, length, advice) {
+  console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
+}
+
+export function syncData(fd) {
+  console.log(`[filesystem] SYNC DATA ${fd}`);
+}
+
 export function getFlags(fd) {
   console.log(`[filesystem] FLAGS FOR ${fd}`);
 }
 
+export function getType(fd) {
+  console.log(`[filesystem] GET TYPE ${fd}`);
+}
+
 export function setFlags(fd, flags) {
   console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
 }
 
-export function dropDescriptor(fd) {
-  console.log(`[filesystem] CLOSE: ${fd}`);
+export function setSize(fd, size) {
+  console.log(`[filesystem] SET SIZE`, fd, size);
 }
 
-export function removeDirectoryAt(fd, path) {
-  console.log(`[filesystem] RM DIR: ${fd} ${path}`);
+export function setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
+  console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
 }
 
-export function unlinkFileAt(fd, path) {
-  console.log(`[filesystem] UNLINK: ${fd} ${path}`);
+export function read(fd, length, offset) {
+  console.log(`[filesystem] READ`, fd, length, offset);
 }
 
-export function writeViaStream(fd, offset) {
-  console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
+export function write(fd, buffer, offset) {
+  console.log(`[filesystem] WRITE`, fd, buffer, offset);
 }
 
-export function appendViaStream(fd, offset) {
-  console.log(`[filesystem] APPEND STREAM ${fd} ${offset}`);
+export function readDirectory(fd) {
+  console.log(`[filesystem] READ DIR`, fd);
 }
 
-export function readViaStream(fd, offset) {
-  console.log(`[filesystem] READ STREAM ${fd} ${offset}`);
+export function sync(fd) {
+  console.log(`[filesystem] SYNC`, fd);
 }
 
-export function openAt(fd, atFlags, path, offset) {
-  console.log(`[filesystem] OPEN AT ${fd}`, atFlags, path, offset);
+export function createDirectoryAt(fd, path) {
+  console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
 }
 
 export function stat(fd) {
-  console.log(`[filesystem] STAT: ${fd}`);
+  console.log(`[filesystem] STAT`, fd);
 }
 
-export function getType(fd) {
-  console.log(`[filesystem] TODO TYPE: ${fd}`);
+export function statAt(fd, pathFlags, path) {
+  console.log(`[filesystem] STAT`, fd, pathFlags, path);
+}
+
+export function setTimesAt(fd) {
+  console.log(`[filesystem] SET TIMES AT`, fd);
+}
+
+export function linkAt(fd) {
+  console.log(`[filesystem] LINK AT`, fd);
+}
+
+export function openAt(fd) {
+  console.log(`[filesystem] OPEN AT`, fd);
+}
+
+export function readlinkAt(fd) {
+  console.log(`[filesystem] READLINK AT`, fd);
+}
+
+export function removeDirectoryAt(fd) {
+  console.log(`[filesystem] REMOVE DIR AT`, fd);
+}
+
+export function renameAt(fd) {
+  console.log(`[filesystem] RENAME AT`, fd);
+}
+
+export function symlinkAt(fd) {
+  console.log(`[filesystem] SYMLINK AT`, fd);
+}
+
+export function unlinkFileAt(fd) {
+  console.log(`[filesystem] UNLINK FILE AT`, fd);
+}
+
+export function changeFilePermissionsAt(fd) {
+  console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
+}
+
+export function changeDirectoryPermissionsAt(fd) {
+  console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
+}
+
+export function lockShared(fd) {
+  console.log(`[filesystem] LOCK SHARED`, fd);
+}
+
+export function lockExclusive(fd) {
+  console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
+}
+
+export function tryLockShared(fd) {
+  console.log(`[filesystem] TRY LOCK SHARED`, fd);
+}
+
+export function tryLockExclusive(fd) {
+  console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
+}
+
+export function unlock(fd) {
+  console.log(`[filesystem] UNLOCK`, fd);
+}
+
+export function dropDescriptor(fd) {
+  console.log(`[filesystem] DROP DESCRIPTOR`, fd);
 }
 
-export function dropDirectoryEntryStream(s) {
-  console.log(`[filesystem] CLOSE DIR ENTRY STREAM ${s}`);
+export function readDirectoryEntry(stream) {
+  console.log(`[filesystem] READ DIRECTRY ENTRY`, stream);
 }
 
-// backwards compat
-export function getPreopens() {
-  return [];
+export function dropDirectoryEntryStream(stream) {
+  console.log(`[filesystem] DROP DIRECTORY ENTRY`, stream);
 }
-export { getFlags as flags, getType as todoType, dropDirectoryEntryStream as dropDirEntryStream }

package/lib/nodejs/index.js

@@ -1,35 +1,33 @@
-import * as console from "./console.js";
-import * as defaultClocks from "./default-clocks.js";
+import * as logging from "./logging.js";
 import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
 import * as environment from "./environment.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
-import * as io from "./io.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 = {
-    "console": console,
-    "default-clocks": defaultClocks,
     "default-outgoing-HTTP": defaultOutgoingHttp,
     "environment": environment,
     "exit": exit,
     "filesystem": filesystem,
     "http": http,
-    "io": io,
+    "logging": logging,
     "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,4 @@
+// TODO: remove
+export function instanceMonotonicClock() {
+  return 0;
+}

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

@@ -0,0 +1,4 @@
+// TODO: remove
+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

@@ -1,18 +1,14 @@
 import { hrtime } from "node:process";
 
-export function resolution(clock) {
-  console.log(`[clocks] Monotonic clock resolution ${clock}`);
+export function resolution() {
+  console.log(`[monotonic-clock] Monotonic clock resolution`);
 }
 
 let hrStart = hrtime.bigint();
-
-export function now(clock) {
-  if (clock === 0) {
-    return hrtime.bigint() - hrStart;
-  }
-  console.log("[clocks] UNKNOWN CLOCK");
+export function now() {
+  return hrtime.bigint() - hrStart;
 }
 
-export function instanceMonotonicClock () {
-  return 0;
+export function subscribe (_when, _absolute) {
+  console.log(`[monotonic-clock] Subscribe`);
 }

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,18 @@
 import { randomBytes } from "node:crypto";
 
 export function getRandomBytes(len) {
-  return randomBytes(len);
+  return randomBytes(Number(len));
+}
+
+export function getRandomU64 () {
+  return new BigUint64Array(randomBytes(8).buffer)[0];
+}
+
+let insecureRandomValue1, insecureRandomValue2;
+export function insecureRandom () {
+  if (insecureRandomValue1 === undefined) {
+    insecureRandomValue1 = getRandomU64();
+    insecureRandomValue2 = getRandomU64();
+  }
+  return [insecureRandomValue1, insecureRandomValue2];
 }

package/lib/nodejs/stderr.js

@@ -1,3 +1,4 @@
+// TODO: remove
 export function print(message) {
   process.stderr.write(message);
 }