@grest-ts/http 0.0.67 → 0.0.68

package/src/index-browser.bundle.node.test.ts

@@ -0,0 +1,51 @@
+import {describe, it, expect} from 'vitest'
+import {readFileSync, existsSync} from 'node:fs'
+import {dirname, resolve} from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+// Walk the real import graph from the browser entry and assert nothing node-only is reachable:
+// no `node:*` specifier and no `*.node` module. This is what would otherwise leak `node:https`
+// (the pinned-TLS transport) into a browser build.
+const SRC = dirname(fileURLToPath(import.meta.url))
+
+function localImports(file: string): string[] {
+    const code = readFileSync(file, "utf8")
+    const specifiers = [...code.matchAll(/(?:from|import)\s+["']([^"']+)["']/g)].map(m => m[1])
+    return specifiers.filter(s => s.startsWith("."))
+}
+
+function resolveLocal(fromFile: string, spec: string): string | undefined {
+    const base = resolve(dirname(fromFile), spec)
+    for (const candidate of [`${base}.ts`, `${base}/index.ts`]) {
+        if (existsSync(candidate)) return candidate
+    }
+    return undefined
+}
+
+describe('browser bundle safety', () => {
+    it('the browser entry graph references no node:* import and no *.node module', () => {
+        const offenders: string[] = []
+        const seen = new Set<string>()
+        const queue = [resolve(SRC, "index-browser.ts")]
+
+        while (queue.length) {
+            const file = queue.shift()!
+            if (seen.has(file)) continue
+            seen.add(file)
+
+            const code = readFileSync(file, "utf8")
+            if (/(?:from|import)\s+["']node:/.test(code)) offenders.push(`${file} imports a node:* module`)
+
+            for (const spec of localImports(file)) {
+                if (/\.node$/.test(spec)) {
+                    offenders.push(`${file} imports node-only module "${spec}"`)
+                    continue
+                }
+                const target = resolveLocal(file, spec)
+                if (target) queue.push(target)
+            }
+        }
+
+        expect(offenders).toEqual([])
+    })
+})

package/src/index-browser.ts

@@ -4,6 +4,7 @@ export * from "./schema/GGHttpSchema";
 export * from "./schema/GGCookie";
 export * from "./schema/GGWireContextKey";
 export * from "./schema/GGHeader";
+export * from "./schema/GGConnectionSettingsKey";
 export * from "./rpc/GGHttpRouteRPC";
 export * from "./rpc/RpcRequest/GGRpcRequestBuilder";
 export * from "./rpc/RpcResponse/GGRpcResponseParser";

package/src/index-node.ts

@@ -25,6 +25,7 @@ export * from "./schema/GGCookie";
 export * from "./schema/GGWireContextKey";
 export * from "./schema/GGWireContextKey.node";
 export * from "./schema/GGHeader";
+export * from "./schema/GGConnectionSettingsKey";
 export * from "./rpc/GGHttpRouteRPC";
 export * from "./rpc/openApiSuccessResponse";
 export * from "./rpc/openApiHelpers";
@@ -45,6 +46,7 @@ export * from "./schema/GGHttpPermissionsChecker";
 // Client
 export * from "./client/GGContextKeySynchronizer";
 export * from "./client/GGHttpSchema.createClient";
+export * from "./client/nodeConnectionTransport.node";
 export * from "./server/GGHttpSchema.startServer";
 
 

package/src/rpc/RpcRequest/GGRpcRequestBuilder.ts

@@ -1,7 +1,7 @@
 import type {HttpMethod} from "@grest-ts/common";
 import {GGContractMethod} from "@grest-ts/schema";
 import {ClientHttpRouteToRpcTransformClientConfig, GGHttpFetchRequest} from "../../schema/GGHttpSchema";
-import {GGContextKey, type GGTransportMiddleware} from "@grest-ts/context";
+import {GGContextKey, type GGConnectionSettings, type GGTransportMiddleware} from "@grest-ts/context";
 import {GGContextKeySynchronizer} from "../../client/GGContextKeySynchronizer";
 
 export class GGRpcRequestBuilder {
@@ -50,7 +50,15 @@ export class GGRpcRequestBuilder {
                 await GGContextKeySynchronizer.waitFor(mw)
             }
         }
-        this.middlewares?.forEach(mw => mw.update?.(result))
+        let settings: GGConnectionSettings | undefined
+        for (const mw of this.middlewares ?? []) {
+            mw.update?.(result)
+            if (mw.connectionSettings) {
+                settings ??= {}
+                mw.connectionSettings(settings)
+            }
+        }
+        if (settings) result.connectionSettings = settings
         return result
     }
 

package/src/schema/GGConnectionSettingsKey.ts

@@ -0,0 +1,28 @@
+import {GGContextKey, IsConnectionSettings, type GGConnectionSettings, type GGTransportMiddleware} from "@grest-ts/context"
+
+/**
+ * A context key that is also a transport middleware: it holds per-request connection settings
+ * (e.g. a TLS pin) in ambient context and contributes them to the outbound request.
+ *
+ *   export const CONN = new GGConnectionSettingsKey("conn")
+ *   // schema: use: [CONN]
+ *   CONN.set({host, port, tlsPin: {fingerprint256}})   // inside the request scope, then call the client
+ *
+ * Apps create their own instances (one per target class) — there is no framework singleton.
+ * Browser-safe: it only reads ambient context and copies plain data; the node transport
+ * consumes the settings, the browser fetch transport rejects them (settings are node-only).
+ *
+ * Nothing special — just a `GGContextKey<GGConnectionSettings>` whose `connectionSettings()`
+ * hook copies its own value out. The same could be written inline; this is the shortcut.
+ */
+export class GGConnectionSettingsKey extends GGContextKey<GGConnectionSettings> implements GGTransportMiddleware {
+
+    constructor(name: string) {
+        super(name, IsConnectionSettings)
+    }
+
+    public connectionSettings(settings: GGConnectionSettings): void {
+        const value = this.get()
+        if (value) Object.assign(settings, value)
+    }
+}

package/src/schema/GGHttpSchema.ts

@@ -1,7 +1,7 @@
 import {ERROR, ERROR_JSON, GGContractApiDefinition, GGContractClass, GGContractMethod, GGSchema, GGSchemaDescription, OK} from "@grest-ts/schema";
 import type {HttpMethod} from "@grest-ts/common";
 import type http from "http";
-import type {GGContextKey, GGTransportMiddleware} from "@grest-ts/context";
+import type {GGConnectionSettings, GGContextKey, GGTransportMiddleware} from "@grest-ts/context";
 import type {OpenAPIV3_1} from "openapi-types";
 
 export interface GGHttpSchemaConfig<TContract extends GGContractApiDefinition> {
@@ -51,6 +51,7 @@ export interface GGHttpFetchRequest {
     method: HttpMethod;
     headers: Record<string, string>;
     body: string | FormData | undefined;
+    connectionSettings?: GGConnectionSettings;
 }
 
 // --------------------------------------------------------------------------------------------------------