@abide/abide 0.28.0

package/src/lib/shared/buildRpcRequest.ts

@@ -0,0 +1,70 @@
+import { carriesBodyArgs } from './carriesBodyArgs.ts'
+import { queryStringFromArgs } from './queryStringFromArgs.ts'
+import type { HttpVerb } from './types/HttpVerb.ts'
+
+/*
+Builds the Request a verb helper uses to invoke its handler. Same shape on
+both sides (server defineVerb + client remoteProxy) so the cache key
+derivation and SSR snapshot round-trip identically. $rpc URLs are flat
+(no `:name` segments): GET/DELETE/HEAD serialise args onto the query
+string; POST/PUT/PATCH send them as application/json.
+
+`baseUrl` provides the origin needed by the Request constructor — on the
+server it's the inbound request's URL (so handlers reading `request.url` see
+the caller's host), in the browser it's window.location. `headers` lets the
+server pre-populate the synthetic Request with forwarded session headers;
+the client passes nothing.
+*/
+export function buildRpcRequest({
+    method,
+    url,
+    args,
+    baseUrl,
+    headers,
+}: {
+    method: HttpVerb
+    url: string
+    args: unknown
+    baseUrl: string
+    headers?: Headers
+}): Request {
+    const requestHeaders = headers ?? new Headers()
+    if (!carriesBodyArgs(method)) {
+        const target = appendQuery(method, url, args)
+        return new Request(new URL(target, baseUrl).href, { method, headers: requestHeaders })
+    }
+    if (args === undefined) {
+        return new Request(new URL(url, baseUrl).href, { method, headers: requestHeaders })
+    }
+    /*
+    A FormData body ships as-is: the Request constructor sets its own
+    `multipart/form-data` content-type with a boundary, so the server's
+    parseArgs splits text fields into args and File parts into files().
+    Setting the header by hand would omit the boundary and break parsing.
+    */
+    if (args instanceof FormData) {
+        return new Request(new URL(url, baseUrl).href, {
+            method,
+            headers: requestHeaders,
+            body: args,
+        })
+    }
+    requestHeaders.set('content-type', 'application/json')
+    return new Request(new URL(url, baseUrl).href, {
+        method,
+        headers: requestHeaders,
+        body: JSON.stringify(args),
+    })
+}
+
+function appendQuery(method: HttpVerb, url: string, args: unknown): string {
+    if (args === undefined) {
+        return url
+    }
+    if (typeof args !== 'object' || args === null || Array.isArray(args)) {
+        const got = Array.isArray(args) ? 'array' : typeof args
+        throw new Error(`[abide] ${method} ${url} args must be a plain object — got ${got}`)
+    }
+    const suffix = queryStringFromArgs(args as Record<string, unknown>, false)
+    return suffix === '' ? url : `${url}?${suffix}`
+}

package/src/lib/shared/buildSocketOverChannel.ts

@@ -0,0 +1,58 @@
+import type { Socket } from '../server/sockets/types/Socket.ts'
+import { browserClientFlags } from './browserClientFlags.ts'
+import { createPushIterator } from './createPushIterator.ts'
+import type { SocketChannel } from './types/SocketChannel.ts'
+import type { TailHooks } from './types/TailHooks.ts'
+
+/* Per-channel-agnostic sub id counter; uniqueness within a channel is all the
+   lifecycle routing needs, so one monotonic source across every socket is fine. */
+let nextId = 0
+
+/*
+Builds a Socket<T> over a SocketChannel — the one Socket surface every consumer
+side shares, so the browser proxy and the test harness can't drift on the
+Socket contract or the iterator wiring. `resolveChannel` is a thunk, called on
+first subscribe/publish rather than at construction, so the bundler's one
+socketProxy() per socket doesn't open a ws until the socket is actually read.
+
+Bare iteration is the live stream (replay 0); `.tail(n)` seeds from the
+retained tail (no-arg = the whole tail). Each iterator mints its own sub id for
+lifecycle routing (end/err), and `hooks.replayed` fires in-band after the
+replay batch so a window reader commits its seed strictly before any live frame.
+*/
+export function buildSocketOverChannel<T>(
+    name: string,
+    resolveChannel: () => SocketChannel,
+): Socket<T> {
+    function iterate(replay: number | undefined, hooks?: TailHooks): AsyncIterable<T> {
+        return {
+            [Symbol.asyncIterator](): AsyncIterator<T, void, undefined> {
+                const id = `s${++nextId}`
+                const channel = resolveChannel()
+                const iterator = createPushIterator<T>(() => channel.unsubscribe(id))
+                channel.subscribe(id, name, replay, {
+                    onMessage: (value) => iterator.push(value as T),
+                    onReplay: (messages) => {
+                        for (const value of messages) {
+                            iterator.push(value as T)
+                        }
+                        if (hooks?.replayed) {
+                            iterator.control(hooks.replayed)
+                        }
+                    },
+                    onEnd: () => iterator.end(),
+                    onError: (message) => iterator.error(message),
+                    onDisconnect: () => iterator.disconnect(),
+                })
+                return iterator
+            },
+        }
+    }
+    return {
+        name,
+        clients: browserClientFlags,
+        publish: (message: T) => resolveChannel().publish(name, message),
+        tail: (count?: number, hooks?: TailHooks) => iterate(count, hooks),
+        [Symbol.asyncIterator]: () => iterate(0)[Symbol.asyncIterator](),
+    }
+}

package/src/lib/shared/bundleLayout.ts

@@ -0,0 +1,36 @@
+import { basename, dirname, join } from 'node:path'
+
+/*
+Where a bundle's files live relative to its binary directory (the dir holding the
+launcher + server — `dirname(process.execPath)` at runtime). A macOS `.app` nests
+binaries under `Contents/MacOS`, the webview lib under `Contents/Frameworks`, and
+data under `Contents/Resources` — the only one `codesign` seals as a *resource*,
+so the shipped `.env` survives signing. Every other platform keeps everything
+flat beside the binaries. The single source the bundler writes against and the
+boot readers resolve from, so build and runtime can't disagree. Pure: computes
+paths, never touches disk.
+*/
+export function bundleLayout(binaryDir: string): {
+    binDir: string
+    libDir: string
+    resourcesDir: string
+    envPath: string
+} {
+    const isMacApp = basename(binaryDir) === 'MacOS' && basename(dirname(binaryDir)) === 'Contents'
+    if (isMacApp) {
+        const contents = dirname(binaryDir)
+        const resourcesDir = join(contents, 'Resources')
+        return {
+            binDir: binaryDir,
+            libDir: join(contents, 'Frameworks'),
+            resourcesDir,
+            envPath: join(resourcesDir, '.env'),
+        }
+    }
+    return {
+        binDir: binaryDir,
+        libDir: binaryDir,
+        resourcesDir: binaryDir,
+        envPath: join(binaryDir, '.env'),
+    }
+}