[PoC] feat: introduce Moddable adapter

build/build.ts

@@ -17,6 +17,10 @@ import path from 'path'
 import { cleanupWorkers, removePrivateFields } from './remove-private-fields'
 import { validateExports } from './validate-exports'
 
+const PACKAGES_NOT_PUBLISHED_TO_JSR = [
+  './moddable', // because the code depends on runtime-specific APIs can't be published to JSR
+]
+
 const args = arg({
   '--watch': Boolean,
 })
@@ -28,7 +32,7 @@ const readJsonExports = (path: string) => JSON.parse(fs.readFileSync(path, 'utf-
 const [packageJsonExports, jsrJsonExports] = ['./package.json', './jsr.json'].map(readJsonExports)
 
 // Validate exports of package.json and jsr.json
-validateExports(packageJsonExports, jsrJsonExports, 'jsr.json')
+validateExports(packageJsonExports, jsrJsonExports, 'jsr.json', PACKAGES_NOT_PUBLISHED_TO_JSR)
 validateExports(jsrJsonExports, packageJsonExports, 'package.json')
 
 const entryPoints = glob.sync('./src/**/*.ts', {

build/validate-exports.ts

@@ -1,7 +1,8 @@
 export const validateExports = (
   source: Record<string, unknown>,
   target: Record<string, unknown>,
-  fileName: string
+  fileName: string,
+  ignore: string[] = []
 ) => {
   const isEntryInTarget = (entry: string): boolean => {
     if (entry in target) {
@@ -31,6 +32,9 @@ export const validateExports = (
 
   Object.keys(source).forEach((sourceEntry) => {
     if (!isEntryInTarget(sourceEntry)) {
+      if (ignore.includes(sourceEntry)) {
+        return
+      }
       throw new Error(`Missing "${sourceEntry}" in '${fileName}'`)
     }
   })

package.json

@@ -19,7 +19,8 @@
     "test:workerd": "vitest --run --config ./runtime-tests/workerd/vitest.config.ts",
     "test:lambda": "vitest --run --config ./runtime-tests/lambda/vitest.config.ts",
     "test:lambda-edge": "vitest --run --config ./runtime-tests/lambda-edge/vitest.config.ts",
-    "test:all": "bun run test && bun test:deno && bun test:bun && bun test:fastly && bun test:node && bun test:workerd && bun test:lambda && bun test:lambda-edge",
+    "test:moddable": "vitest --run --config ./runtime-tests/moddable/vitest.config.ts",
+    "test:all": "bun run test && bun test:deno && bun test:bun && bun test:fastly && bun test:node && bun test:workerd && bun test:lambda && bun test:lambda-edge && bun test:moddable",
     "lint": "eslint src runtime-tests build perf-measures",
     "lint:fix": "eslint src runtime-tests build perf-measures --fix",
     "format": "prettier --check --cache \"src/**/*.{js,ts,tsx}\" \"runtime-tests/**/*.{js,ts,tsx}\" \"build/**/*.{js,ts,tsx}\" \"perf-measures/**/*.{js,ts,tsx}\"",
@@ -384,6 +385,11 @@
       "import": "./dist/adapter/service-worker/index.js",
       "require": "./dist/cjs/adapter/service-worker/index.js"
     },
+    "./moddable": {
+      "types": "./dist/types/adapter/moddable/index.d.ts",
+      "import": "./dist/adapter/moddable/index.js",
+      "require": "./dist/cjs/adapter/moddable/index.js"
+    },
     "./testing": {
       "types": "./dist/types/helper/testing/index.d.ts",
       "import": "./dist/helper/testing/index.js",
@@ -610,6 +616,9 @@
       "service-worker": [
         "./dist/types/adapter/service-worker"
       ],
+      "moddable": [
+        "./dist/types/adapter/moddable"
+      ],
       "testing": [
         "./dist/types/helper/testing"
       ],

runtime-tests/moddable/index.test.ts

@@ -0,0 +1,67 @@
+import { execSync, spawn } from 'node:child_process'
+
+function isCommandAvailable(command: string): boolean {
+  try {
+    const checkCommand = process.platform === 'win32' ? `where ${command}` : `command -v ${command}`
+    execSync(checkCommand, { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const isModdableInstalled = isCommandAvailable('mcconfig')
+let moddableEnvironment: 'win' | 'mac' | 'lin' | undefined = undefined
+if (process.platform === 'win32') {
+  moddableEnvironment = 'win'
+} else if (process.platform === 'darwin') {
+  moddableEnvironment = 'mac'
+} else if (process.platform === 'linux') {
+  moddableEnvironment = 'lin'
+} else {
+  throw new Error(`Unsupported platform: ${process.platform}`)
+}
+if (!moddableEnvironment) {
+  console.warn('Moddable environment not set, skipping tests.')
+}
+
+const skip = !isModdableInstalled || !moddableEnvironment
+
+describe('moddable', { skip }, () => {
+  beforeAll(() => {
+    execSync(
+      'bun build runtime-tests/moddable/tests/main.ts --external socket --external streams --external text/decoder --external text/encoder --external headers --outdir runtime-tests/moddable/dist'
+    )
+    execSync('bunx kill-port 5002')
+  })
+  it(
+    'dist',
+    {
+      timeout: 1000 * 60 * 5, // 5 minutes
+    },
+    async () => {
+      const mcconfigProc = spawn('mcconfig', ['-m', '-dl', '-p', moddableEnvironment], {
+        cwd: 'runtime-tests/moddable',
+      })
+      await new Promise<void>((resolve, reject) => {
+        mcconfigProc.on('error', (err) => {
+          reject(err)
+        })
+        let output = ''
+        mcconfigProc.stdout.on('data', (data) => {
+          output += data.toString()
+          if (output.includes('connected to "moddable"')) {
+            resolve()
+          }
+        })
+      })
+      expect(await fetch('http://localhost:3000').then((res) => res.text())).toEqual(
+        '{"hono":"moddable"}'
+      )
+      mcconfigProc.kill('SIGSTOP')
+    }
+  )
+  afterAll(() => {
+    console.log('Stopping Moddable environment...')
+  })
+})

runtime-tests/moddable/manifest.json

@@ -0,0 +1,22 @@
+{
+    "include": [
+        "$(MODDABLE)/examples/manifest_base.json",
+        "$(MODDABLE)/examples/manifest_net.json",
+        "$(MODULES)/network/http/manifest.json",
+        "$(MODDABLE)/modules/data/headers/manifest.json",
+        "$(MODDABLE)/modules/data/url/manifest.json",
+        "$(MODDABLE)/modules/data/text/encoder/manifest.json",
+        "$(MODDABLE)/modules/data/text/decoder/manifest.json",
+        "$(MODDABLE)/modules/data/headers/manifest.json",
+        "$(MODDABLE)/modules/network/websocket/manifest.json"
+    ],
+    "modules": {
+        "*": [
+            "$(MODDABLE)/examples/io/streams/modules/streams.js",
+            "./dist/main.js"
+        ]
+    },
+    "creation": {
+        "stack": 512
+    }
+}

runtime-tests/moddable/tests/main.ts

@@ -0,0 +1,14 @@
+// @ts-expect-error Internal API
+import { Listener } from 'socket'
+import { Hono } from '../../../src'
+import { handle } from '../../../src/adapter/moddable'
+import { cors } from '../../../src/middleware/cors'
+
+const app = new Hono().use(cors()).get('/', (c) =>
+  c.json({
+    hono: 'moddable',
+  })
+)
+
+const listener = new Listener({ port: 3000 })
+listener.callback = handle(app)

runtime-tests/moddable/vitest.config.ts

@@ -0,0 +1,19 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vitest/config'
+import config from '../../vitest.config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['**/runtime-tests/moddable/**/*.+(ts|tsx|js)'],
+    exclude: [
+      '**/runtime-tests/moddable/vitest.config.ts',
+      '**/runtime-tests/moddable/tests/**',
+      '**/runtime-tests/moddable/dist/**',
+    ],
+    coverage: {
+      ...config.test?.coverage,
+      reportsDirectory: './coverage/raw/moddable',
+    },
+  },
+})

src/adapter/moddable/conninfo.test.ts

@@ -0,0 +1,38 @@
+import type { Context } from '../../context'
+import { getConnInfo } from './conninfo'
+
+describe('getConnInfo', () => {
+  it('Should throw an error if socket is not available', () => {
+    const c: Context = {
+      env: {},
+    } as unknown as Context
+    expect(() => getConnInfo(c)).toThrow(TypeError)
+  })
+  it('Should return empty remote address if REMOTE_IP is not available', () => {
+    const c: Context = {
+      env: {
+        socket: {
+          get: () => undefined,
+        },
+      },
+    } as unknown as Context
+    expect(getConnInfo(c)).toEqual({
+      remote: {},
+    })
+  })
+  it('Should return remote address and transport type', () => {
+    const c: Context = {
+      env: {
+        socket: {
+          get: () => '1.1.1.1',
+        },
+      },
+    } as unknown as Context
+    expect(getConnInfo(c)).toEqual({
+      remote: {
+        address: '1.1.1.1',
+        transport: 'tcp',
+      },
+    })
+  })
+})

src/adapter/moddable/conninfo.ts

@@ -0,0 +1,32 @@
+import type { Context } from '../..'
+import type { GetConnInfo } from '../../helper/conninfo'
+
+/**
+ * Get ConnInfo with Moddable
+ * @param c Context
+ * @returns ConnInfo
+ */
+export const getConnInfo: GetConnInfo = (c: Context) => {
+  const socket = c.env.socket as
+    | {
+        get: (type: 'REMOTE_IP') => string | undefined
+      }
+    | undefined
+
+  if (!socket) {
+    throw new TypeError('env has to include the socket object.')
+  }
+
+  const addr = socket.get('REMOTE_IP')
+  if (!addr) {
+    return {
+      remote: {},
+    }
+  }
+  return {
+    remote: {
+      address: addr,
+      transport: 'tcp',
+    },
+  }
+}

src/adapter/moddable/handler.test.ts

@@ -0,0 +1,90 @@
+import type { Socket, SocketConstructor } from './handler'
+import { createHandleFunction } from './handler'
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+describe('handler', () => {
+  it('Should create a HTTP response', async () => {
+    let MockSocket!: SocketConstructor
+    let socket!: Socket
+    const responsePromise = new Promise((resolve) => {
+      let response: string = ''
+      MockSocket = class implements Socket {
+        constructor() {
+          // eslint-disable-next-line @typescript-eslint/no-this-alias
+          socket = this
+        }
+        callback: (
+          this: { read(type: typeof ArrayBuffer): ArrayBuffer },
+          message: number,
+          value?: unknown
+        ) => void = () => null
+        write(chunk: ArrayBuffer): void {
+          response += decoder.decode(chunk)
+        }
+        close(): void {
+          resolve(response)
+        }
+      }
+    })
+    const handle = createHandleFunction(MockSocket)
+    const callback = handle({
+      fetch: () => new Response('Hello World'),
+    })
+    callback.call({
+      callback: () => {},
+    })
+    socket.callback.call(
+      {
+        read() {
+          return encoder.encode('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n').buffer
+        },
+      },
+      2
+    )
+    expect(await responsePromise).toEqual(
+      'HTTP/1.1 200 \r\ncontent-type: text/plain;charset=UTF-8\r\n\r\nHello World'
+    )
+  })
+  it('Should close the socket on invalid request', async () => {
+    let MockSocket!: SocketConstructor
+    let socket!: Socket
+    const responsePromise = new Promise((resolve) => {
+      let response: string = ''
+      MockSocket = class implements Socket {
+        constructor() {
+          // eslint-disable-next-line @typescript-eslint/no-this-alias
+          socket = this
+        }
+        callback: (
+          this: { read(type: typeof ArrayBuffer): ArrayBuffer },
+          message: number,
+          value?: unknown
+        ) => void = () => null
+        write(chunk: ArrayBuffer): void {
+          response += decoder.decode(chunk)
+        }
+        close(): void {
+          resolve(response)
+        }
+      }
+    })
+    const handle = createHandleFunction(MockSocket)
+    const callback = handle({
+      fetch: () => new Response('Hello World'),
+    })
+    callback.call({
+      callback: () => {},
+    })
+    socket.callback.call(
+      {
+        read() {
+          return encoder.encode('aa\r\n\r\n').buffer
+        },
+      },
+      2
+    )
+    expect(await responsePromise).toEqual('')
+  })
+})