goscript 0.1.2 → 0.1.4

package/gs/net/http/httptest/index.test.ts

@@ -2,7 +2,14 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Handler, Header_Get, Header_Set, MethodGet, NewRequest, StatusPartialContent } from '../index.js'
+import {
+  Handler,
+  Header_Get,
+  Header_Set,
+  MethodGet,
+  NewRequest,
+  StatusPartialContent,
+} from '../index.js'
 import { NewServer, NewUnstartedServer, Server_Start } from './index.js'
 
 describe('net/http/httptest override', () => {
@@ -12,12 +19,13 @@ describe('net/http/httptest override', () => {
     }
 
     const srv = NewServer(handler)
-    expect(srv.URL).toBe('http://127.0.0.1')
+    expect(srv.URL).toMatch(/^http:\/\/goscript-httptest-\d+\.invalid$/)
     expect(srv.Client()).toBeTruthy()
     expect(srv.Config().Handler).toBe(handler)
     expect(Server_Start(NewUnstartedServer(handler))?.Error()).toBe(
       'net/http/httptest: Server.Start is not implemented in GoScript',
     )
+    srv.Close()
   })
 
   it('routes Client.Do through the in-memory server handler', async () => {
@@ -49,5 +57,29 @@ describe('net/http/httptest override', () => {
     expect(n).toBe(4)
     expect(Buffer.from(buf).toString('utf8')).toBe('data')
     expect(resp!.Body!.Close()).toBeNull()
+    srv.Close()
+  })
+
+  it('awaits async handlers through Server.Client transport', async () => {
+    const srv = NewServer({
+      async ServeHTTP(w) {
+        await Promise.resolve()
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('async'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/async', null)
+    expect(reqErr).toBeNull()
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    const buf = new Uint8Array(5)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('async')
+    srv.Close()
   })
 })

package/gs/net/http/httptest/index.ts

@@ -58,10 +58,16 @@ export function NewRecorder(): ResponseRecorder {
   return new ResponseRecorder()
 }
 
-export function NewRequest(method: string, target: string, body: io.Reader | null): http.Request {
+export function NewRequest(
+  method: string,
+  target: string,
+  body: io.Reader | null,
+): http.Request {
   const [req, err] = http.NewRequest(method, target, body)
   if (err != null || req == null) {
-    throw err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+    throw (
+      err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+    )
   }
   return req
 }
@@ -71,21 +77,26 @@ export class Server {
   private handler: http.Handler | null
 
   constructor(init?: Partial<Server> & { Handler?: http.Handler | null }) {
-    this.URL = init?.URL ?? 'http://127.0.0.1'
     this.handler = init?.Handler ?? null
+    this.URL = init?.URL ?? http.RegisterInProcessServer(this.handler)
   }
 
   public Client(): http.Client {
     return new http.Client({ Transport: new serverTransport(this) })
   }
 
-  public Close(): void {}
+  public Close(): void {
+    http.UnregisterInProcessServer(this.URL)
+  }
 
   public Config(): http.Server {
     return new http.Server({ Handler: this.handler })
   }
 
-  public ServeHTTP(w: http.ResponseWriter | null, r: http.Request | $.VarRef<http.Request> | null): void | Promise<void> {
+  public ServeHTTP(
+    w: http.ResponseWriter | null,
+    r: http.Request | $.VarRef<http.Request> | null,
+  ): void | Promise<void> {
     return this.handler?.ServeHTTP(w, r)
   }
 }
@@ -93,7 +104,9 @@ export class Server {
 class serverTransport implements http.RoundTripper {
   constructor(private server: Server) {}
 
-  public RoundTrip(req: http.Request | $.VarRef<http.Request> | null): [http.Response | null, $.GoError] {
+  public async RoundTrip(
+    req: http.Request | $.VarRef<http.Request> | null,
+  ): Promise<[http.Response | null, $.GoError]> {
     const request = $.pointerValue<http.Request | null>(req)
     if (request == null) {
       return [null, errors.New('net/http: nil Request')]
@@ -101,7 +114,7 @@ class serverTransport implements http.RoundTripper {
     const recorder = NewRecorder()
     const served = this.server.ServeHTTP(recorder, request)
     if (served instanceof Promise) {
-      return [null, errors.New('net/http/httptest: async handlers are not supported by Client.Do')]
+      await served
     }
     return [recorder.Result(), null]
   }
@@ -116,5 +129,7 @@ export function NewUnstartedServer(handler: http.Handler | null): Server {
 }
 
 export function Server_Start(_s: Server | $.VarRef<Server> | null): $.GoError {
-  return errors.New('net/http/httptest: Server.Start is not implemented in GoScript')
+  return errors.New(
+    'net/http/httptest: Server.Start is not implemented in GoScript',
+  )
 }

package/gs/net/http/index.test.ts

@@ -7,6 +7,9 @@ import {
   File,
   FileSystem,
   Header,
+  Header_Add,
+  Header_Del,
+  Header_Get,
   Header_Set,
   HandlerFunc_ServeHTTP,
   Get,
@@ -19,11 +22,16 @@ import {
   ResponseWriter,
   Server,
   StatusCreated,
+  StatusForbidden,
+  StatusMethodNotAllowed,
   StatusNotFound,
   StatusOK,
   StatusServiceUnavailable,
+  StatusTeapot,
   StatusText,
   StatusTooManyRequests,
+  StatusUnauthorized,
+  StatusUnsupportedMediaType,
 } from './index.js'
 
 describe('net/http override', () => {
@@ -33,6 +41,11 @@ describe('net/http override', () => {
     expect(resp.StatusCode).toBe(200)
     expect(StatusText(resp.StatusCode)).toBe('OK')
     expect(StatusText(StatusNotFound)).toBe('Not Found')
+    expect(StatusText(StatusUnauthorized)).toBe('Unauthorized')
+    expect(StatusText(StatusForbidden)).toBe('Forbidden')
+    expect(StatusText(StatusMethodNotAllowed)).toBe('Method Not Allowed')
+    expect(StatusText(StatusUnsupportedMediaType)).toBe('Unsupported Media Type')
+    expect(StatusText(StatusTeapot)).toBe("I'm a teapot")
     expect(StatusText(StatusTooManyRequests)).toBe('Too Many Requests')
     expect(StatusText(StatusServiceUnavailable)).toBe('Service Unavailable')
     expect(StatusText(599)).toBe('')
@@ -59,6 +72,22 @@ describe('net/http override', () => {
     expect(err?.Error()).toBe('net/http: Client.Do is not implemented in GoScript')
   })
 
+  it('wraps request body readers and keeps response metadata', () => {
+    const reader = {
+      Read: (p: Uint8Array) => [p.length, null] as [number, null],
+    }
+
+    const [req, reqErr] = NewRequest(MethodPost, 'https://example.invalid/upload', reader)
+
+    expect(reqErr).toBeNull()
+    expect(req!.Body).not.toBeNull()
+    expect(req!.Body!.Close()).toBeNull()
+
+    const resp = new Response({ StatusCode: StatusCreated, ContentLength: -1, Request: varRef(req!) })
+    expect(resp.ContentLength).toBe(-1)
+    expect((resp.Request as any).value).toBe(req)
+  })
+
   it('exports the default transport surface', async () => {
     const [req] = NewRequest(MethodPost, 'https://example.invalid', null)
 
@@ -92,6 +121,23 @@ describe('net/http override', () => {
     expect(resp?.StatusCode).toBe(StatusOK)
   })
 
+  it('canonicalizes header keys for case-insensitive lookup', () => {
+    const header = new Header()
+
+    Header_Set(header, 'Content-Type', 'application/json')
+
+    expect(header.has('Content-Type')).toBe(true)
+    expect(header.has('content-type')).toBe(false)
+    expect(Header_Get(header, 'content-type')).toBe('application/json')
+
+    Header_Add(header, 'x-pack-id', 'pack-1')
+    Header_Add(header, 'X-Pack-Id', 'pack-2')
+    expect(Array.from(header.get('X-Pack-Id') ?? [])).toEqual(['pack-1', 'pack-2'])
+
+    Header_Del(header, 'x-pack-id')
+    expect(Header_Get(header, 'X-Pack-ID')).toBe('')
+  })
+
   it('accepts server context and shutdown surfaces', () => {
     const srv = new Server({
       Addr: ':0',

package/gs/net/http/index.ts

@@ -1,4 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
 import * as context from '@goscript/context/index.js'
 import * as errors from '@goscript/errors/index.js'
 import * as fs from '@goscript/io/fs/fs.js'
@@ -10,9 +11,14 @@ export const StatusCreated = 201
 export const StatusPartialContent = 206
 export const StatusMovedPermanently = 301
 export const StatusBadRequest = 400
+export const StatusUnauthorized = 401
+export const StatusForbidden = 403
+export const StatusMethodNotAllowed = 405
 export const StatusRequestTimeout = 408
 export const StatusConflict = 409
 export const StatusNotFound = 404
+export const StatusUnsupportedMediaType = 415
+export const StatusTeapot = 418
 export const StatusTooManyRequests = 429
 export const StatusRequestedRangeNotSatisfiable = 416
 export const StatusInternalServerError = 500
@@ -31,6 +37,12 @@ export function StatusText(code: number): string {
       return 'OK'
     case StatusMovedPermanently:
       return 'Moved Permanently'
+    case StatusUnauthorized:
+      return 'Unauthorized'
+    case StatusForbidden:
+      return 'Forbidden'
+    case StatusMethodNotAllowed:
+      return 'Method Not Allowed'
     case StatusBadRequest:
       return 'Bad Request'
     case StatusRequestTimeout:
@@ -39,12 +51,16 @@ export function StatusText(code: number): string {
       return 'Conflict'
     case StatusNotFound:
       return 'Not Found'
+    case StatusUnsupportedMediaType:
+      return 'Unsupported Media Type'
     case StatusTooManyRequests:
       return 'Too Many Requests'
     case StatusPartialContent:
       return 'Partial Content'
     case StatusRequestedRangeNotSatisfiable:
       return 'Requested Range Not Satisfiable'
+    case StatusTeapot:
+      return "I'm a teapot"
     case StatusInternalServerError:
       return 'Internal Server Error'
     case StatusServiceUnavailable:
@@ -61,22 +77,39 @@ export const Header = Map as {
 }
 
 export function Header_Add(h: Header, key: string, value: string): void {
+  key = canonicalMIMEHeaderKey(key)
   const values = Array.from(h.get(key) ?? [])
   values.push(value)
   h.set(key, $.arrayToSlice(values))
 }
 
 export function Header_Del(h: Header, key: string): void {
-  h.delete(key)
+  h.delete(canonicalMIMEHeaderKey(key))
 }
 
 export function Header_Get(h: Header, key: string): string {
-  const values = h.get(key)
+  const values = h.get(canonicalMIMEHeaderKey(key))
   return values == null || values.length === 0 ? '' : String(values[0])
 }
 
 export function Header_Set(h: Header, key: string, value: string): void {
-  h.set(key, $.arrayToSlice([value]))
+  h.set(canonicalMIMEHeaderKey(key), $.arrayToSlice([value]))
+}
+
+function canonicalMIMEHeaderKey(key: string): string {
+  let upper = true
+  let out = ''
+  for (let i = 0; i < key.length; i++) {
+    const ch = key[i]
+    if (ch === '-') {
+      upper = true
+      out += ch
+      continue
+    }
+    out += upper ? ch.toUpperCase() : ch.toLowerCase()
+    upper = false
+  }
+  return out
 }
 
 class QueryValues extends Map<string, $.Slice<string>> {
@@ -90,13 +123,27 @@ class QueryValues extends Map<string, $.Slice<string>> {
     const values = this.get(key)
     return values == null || values.length === 0 ? '' : String(values[0])
   }
+
+  public Encode(): string {
+    const params = new URLSearchParams()
+    for (const [key, values] of this.entries()) {
+      for (const value of Array.from(values ?? [])) {
+        params.append(key, String(value))
+      }
+    }
+    return params.toString()
+  }
 }
 
 class RequestURL {
+  public Scheme: string
+  public Host: string
   public Path: string
   public RawQuery: string
 
-  constructor(path: string, rawQuery: string) {
+  constructor(path: string, rawQuery: string, scheme = '', host = '') {
+    this.Scheme = scheme
+    this.Host = host
     this.Path = path
     this.RawQuery = rawQuery
   }
@@ -109,19 +156,100 @@ class RequestURL {
   }
 
   public clone(): RequestURL {
-    return new RequestURL(this.Path, this.RawQuery)
+    return new RequestURL(this.Path, this.RawQuery, this.Scheme, this.Host)
+  }
+
+  public String(): string {
+    const query = this.RawQuery === '' ? '' : `?${this.RawQuery}`
+    const path = this.Path === '' ? '/' : this.Path
+    if (this.Scheme === '' || this.Host === '') {
+      return `${path}${query}`
+    }
+    return `${this.Scheme}://${this.Host}${path}${query}`
   }
 }
 
 function parseRequestURL(rawURL: string): RequestURL {
   try {
     const parsed = new URL(rawURL, 'http://goscript.invalid')
-    return new RequestURL(parsed.pathname, parsed.search.startsWith('?') ? parsed.search.slice(1) : parsed.search)
+    const hasHost = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(rawURL)
+    return new RequestURL(
+      parsed.pathname,
+      parsed.search.startsWith('?') ? parsed.search.slice(1) : parsed.search,
+      hasHost ? parsed.protocol.replace(/:$/, '') : '',
+      hasHost ? parsed.host : '',
+    )
   } catch {
     return new RequestURL('', '')
   }
 }
 
+class responseBody implements io.ReadCloser {
+  private reader: bytes.Reader
+
+  constructor(data: $.Bytes) {
+    this.reader = bytes.NewReader(Uint8Array.from(data ?? []))
+  }
+
+  public Read(p: $.Bytes): [number, $.GoError] {
+    return this.reader.Read(p)
+  }
+
+  public Close(): $.GoError {
+    return null
+  }
+}
+
+class memoryResponseWriter implements ResponseWriter {
+  public Code = StatusOK
+  public Body = new bytes.Buffer()
+  private headerMap = new Header()
+  private wroteHeader = false
+
+  public Header(): Header {
+    return this.headerMap
+  }
+
+  public Write(p: $.Slice<number>): [number, $.GoError] {
+    if (!this.wroteHeader) {
+      this.WriteHeader(StatusOK)
+    }
+    return this.Body.Write(p)
+  }
+
+  public WriteHeader(statusCode: number): void {
+    if (this.wroteHeader) {
+      return
+    }
+    this.wroteHeader = true
+    this.Code = statusCode
+  }
+
+  public Result(): Response {
+    return new Response({
+      Body: new responseBody(this.Body.Bytes()),
+      Header: this.headerMap,
+      StatusCode: this.Code,
+    })
+  }
+}
+
+const inProcessServers = new Map<string, Handler>()
+let nextInProcessServerID = 1
+
+export function RegisterInProcessServer(handler: Handler | null): string {
+  const host = `goscript-httptest-${nextInProcessServerID++}.invalid`
+  inProcessServers.set(host, handler ?? { ServeHTTP: NotFound })
+  return `http://${host}`
+}
+
+export function UnregisterInProcessServer(rawURL: string): void {
+  const parsed = parseRequestURL(rawURL)
+  if (parsed.Host !== '') {
+    inProcessServers.delete(parsed.Host)
+  }
+}
+
 export interface ResponseWriter {
   Header(): Header
   Write(p: $.Slice<number>): [number, $.GoError]
@@ -131,7 +259,7 @@ export interface ResponseWriter {
 export class Request {
   public Method: string
   public URL: any
-  public Body: io.Reader | null
+  public Body: io.ReadCloser | null
   public Header: Header
   public ContentLength: number
   public RequestURI: string
@@ -181,21 +309,34 @@ export class Request {
 }
 
 export class Response {
+  public Status: string
   public StatusCode: number
   public Body: io.ReadCloser | null
   public Header: Header
+  public ContentLength: number
+  public Request: Request | $.VarRef<Request> | null
 
   constructor(init?: Partial<Response>) {
+    this.Status = init?.Status ?? ''
     this.StatusCode = init?.StatusCode ?? 0
     this.Body = init?.Body ?? null
     this.Header = init?.Header ?? new Header()
+    this.ContentLength = init?.ContentLength ?? 0
+    this.Request = init?.Request ?? null
+    if (this.Status === '' && this.StatusCode !== 0) {
+      const text = StatusText(this.StatusCode)
+      this.Status = text === '' ? String(this.StatusCode) : `${this.StatusCode} ${text}`
+    }
   }
 
   public clone(): Response {
     return new Response({
       Body: this.Body,
       Header: this.Header,
+      Status: this.Status,
       StatusCode: this.StatusCode,
+      ContentLength: this.ContentLength,
+      Request: this.Request,
     })
   }
 }
@@ -220,13 +361,27 @@ export interface RoundTripper {
   RoundTrip(req: Request | $.VarRef<Request> | null): [Response | null, $.GoError] | Promise<[Response | null, $.GoError]>
 }
 
-class unsupportedTransport implements RoundTripper {
-  public async RoundTrip(_req: Request | $.VarRef<Request> | null): Promise<[Response | null, $.GoError]> {
-    return [null, errors.New('net/http: Client.Do is not implemented in GoScript')]
+class defaultTransport implements RoundTripper {
+  public async RoundTrip(req: Request | $.VarRef<Request> | null): Promise<[Response | null, $.GoError]> {
+    const request = $.pointerValue<Request | null>(req)
+    if (request == null) {
+      return [null, errors.New('net/http: nil Request')]
+    }
+    const host = request.URL?.Host ?? ''
+    const handler = host === '' ? null : inProcessServers.get(host)
+    if (handler == null) {
+      return [null, errors.New('net/http: Client.Do is not implemented in GoScript')]
+    }
+    const recorder = new memoryResponseWriter()
+    const served = handler.ServeHTTP(recorder, request)
+    if (served instanceof Promise) {
+      await served
+    }
+    return [recorder.Result(), null]
   }
 }
 
-export const DefaultTransport: RoundTripper = new unsupportedTransport()
+export const DefaultTransport: RoundTripper = new defaultTransport()
 
 export interface FileSystem {
   Open(name: string): [File | null, $.GoError]
@@ -424,9 +579,20 @@ export function NewRequestWithContext(
     method = MethodGet
   }
   const parsedURL = parseRequestURL(url)
-  return [new Request({ Method: method, URL: parsedURL, Body: body, RequestURI: parsedURL.Path, ctx: _ctx }), null]
+  return [new Request({ Method: method, URL: parsedURL, Body: readCloserForBody(body), RequestURI: parsedURL.Path, ctx: _ctx }), null]
 }
 
 export function Get(_url: string): [Response | null, $.GoError] {
   return [null, errors.New('net/http: Get is not implemented in GoScript')]
 }
+
+function readCloserForBody(body: io.Reader | null): io.ReadCloser | null {
+  if (body == null) {
+    return null
+  }
+  const closer = body as io.Reader & Partial<io.Closer>
+  if (typeof closer.Close === 'function') {
+    return closer as io.ReadCloser
+  }
+  return io.NopCloser(body)
+}

package/gs/os/file_unix_js.test.ts

@@ -286,4 +286,56 @@ describe('os stdio', () => {
     expect(readSync).toHaveBeenCalledTimes(1)
     expect(writeSync).toHaveBeenCalledTimes(1)
   })
+
+  it('copies from File without recursing through io.Copy', async () => {
+    const readSync = vi
+      .fn<(buffer: Uint8Array) => number>()
+      .mockImplementationOnce((buffer) => {
+        buffer.set([65, 66, 67], 0)
+        return 3
+      })
+      .mockImplementationOnce(() => 0)
+
+    const file = createHostFile('descriptor-file', 7, { readSync })
+    const chunks: number[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(...Array.from(p))
+        return [p.length, null]
+      },
+    }
+
+    const [n, err] = await io.Copy(writer, file)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('ABC')
+  })
+
+  it('copies into File without recursing through io.Copy', async () => {
+    const writes: number[] = []
+    const writeSync = vi.fn((buffer: Uint8Array) => {
+      writes.push(...Array.from(buffer))
+      return buffer.length
+    })
+
+    let sent = false
+    const reader = {
+      Read(p: Uint8Array): [number, typeof io.EOF | null] {
+        if (sent) {
+          return [0, io.EOF]
+        }
+        sent = true
+        p.set([88, 89, 90], 0)
+        return [3, null]
+      },
+    }
+    const file = createHostFile('descriptor-file', 7, { writeSync })
+
+    const [n, err] = await io.Copy(file, reader)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(writes).toString('utf8')).toBe('XYZ')
+  })
 })

package/gs/os/meta.json

@@ -1,4 +1,8 @@
 {
+  "asyncMethods": {
+    "File.ReadFrom": true,
+    "File.WriteTo": true
+  },
   "dependencies": [
     "errors",
     "internal/byteorder",

package/gs/os/readdir.test.ts

@@ -0,0 +1,56 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import * as io from '@goscript/io/index.js'
+
+import { Open } from './file_js.gs.js'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-readdir-'))
+  tempRoots.push(root)
+  return root
+}
+
+describe('os file directory reads', () => {
+  it('reads host directory entries through os.File', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+    writeFileSync(join(root, 'b.txt'), 'b')
+
+    const [dir, openErr] = Open(root)
+    expect(openErr).toBeNull()
+    expect(dir).not.toBeNull()
+    const [entries, readErr] = dir!.ReadDir(-1)
+    expect(readErr).toBeNull()
+    expect(entries?.map((entry) => entry!.Name()).sort()).toEqual([
+      'a.txt',
+      'b.txt',
+    ])
+    expect(dir!.Close()).toBeNull()
+  })
+
+  it('returns EOF after positive-count directory reads are exhausted', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+
+    const [dir] = Open(root)
+    const [first, firstErr] = dir!.Readdirnames(1)
+    expect(firstErr).toBeNull()
+    expect(first).toHaveLength(1)
+
+    const [second, secondErr] = dir!.Readdirnames(1)
+    expect(second).toBeNull()
+    expect(secondErr).toBe(io.EOF)
+    expect(dir!.Close()).toBeNull()
+  })
+})