@jskit-ai/http-runtime 0.1.90 → 0.1.91

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   "packageVersion": 1,
   "packageId": "@jskit-ai/http-runtime",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "kind": "runtime",
   "dependsOn": [],
   "capabilities": {
@@ -67,7 +67,7 @@ export default Object.freeze({
   "mutations": {
     "dependencies": {
       "runtime": {
-        "@jskit-ai/kernel": "0.1.91"
+        "@jskit-ai/kernel": "0.1.92"
       },
       "dev": {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/http-runtime",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -18,7 +18,7 @@
     "./shared/validators/operationValidation": "./src/shared/validators/operationValidation.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.91",
+    "@jskit-ai/kernel": "0.1.92",
     "json-rest-schema": "1.x.x"
   }
 }

package/src/shared/clientRuntime/client.js

@@ -33,6 +33,14 @@ function resolveFetch() {
   throw new Error("createHttpClient requires fetchImpl when global fetch is unavailable.");
 }
 
+function normalizeResolvedRequestUrl(value, fallback = "") {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+
+  return String(value);
+}
+
 function isObjectBody(value) {
   return Boolean(value) && typeof value === "object" && !(value instanceof FormData);
 }
@@ -164,6 +172,8 @@ async function readNdjsonStream(response, handlers = {}) {
 
 function createHttpClient(options = {}) {
   const configuredFetchImpl = typeof options.fetchImpl === "function" ? options.fetchImpl : null;
+  const configuredResolveRequestUrl =
+    typeof options.resolveRequestUrl === "function" ? options.resolveRequestUrl : null;
   const unsafeMethods = resolveUnsafeMethods(options.unsafeMethods);
   const hooks = options?.hooks && typeof options.hooks === "object" ? options.hooks : {};
 
@@ -189,9 +199,19 @@ function createHttpClient(options = {}) {
 
   async function fetchSessionForCsrf() {
     const activeFetch = configuredFetchImpl || resolveFetch();
+    const requestUrl = await resolveRequestUrl(csrf.sessionPath, {
+      originalUrl: csrf.sessionPath,
+      method: "GET",
+      requestOptions: {
+        method: "GET"
+      },
+      state: null,
+      stream: false,
+      csrfSession: true
+    });
     let response;
     try {
-      response = await activeFetch(csrf.sessionPath, {
+      response = await activeFetch(requestUrl, {
         method: "GET",
         credentials: String(options?.credentials || "same-origin")
       });
@@ -255,6 +275,19 @@ function createHttpClient(options = {}) {
     }
   }
 
+  async function resolveRequestUrl(url, context = {}) {
+    const normalizedUrl = String(url || "").trim();
+    if (!configuredResolveRequestUrl) {
+      return normalizedUrl;
+    }
+
+    const resolved = await configuredResolveRequestUrl(normalizedUrl, {
+      ...context,
+      url: normalizedUrl
+    });
+    return normalizeResolvedRequestUrl(resolved, normalizedUrl);
+  }
+
   async function maybeRetry({ response, method, state, data, stream }) {
     if (!csrf.enabled) {
       return false;
@@ -321,11 +354,19 @@ function createHttpClient(options = {}) {
       ...forwardedRequestOptions
     } = requestOptions && typeof requestOptions === "object" ? requestOptions : {};
     const requestUrl = appendRequestQueryToUrl(url, requestQuery, transport);
+    const resolvedRequestUrl = await resolveRequestUrl(requestUrl, {
+      originalUrl: url,
+      method,
+      requestOptions,
+      state: resolvedState,
+      stream: Boolean(stream),
+      csrfSession: false
+    });
     const headers =
       requestOptions.headers && typeof requestOptions.headers === "object" ? { ...requestOptions.headers } : {};
 
     const decorateHeadersResult = decorateHeaders({
-      url: requestUrl,
+      url: resolvedRequestUrl,
       method,
       headers,
       requestOptions,
@@ -369,7 +410,7 @@ function createHttpClient(options = {}) {
       config,
       state: resolvedState,
       transport,
-      url: requestUrl
+      url: resolvedRequestUrl
     };
   }
 

package/test/client.test.js

@@ -56,6 +56,67 @@ test("request serializes json body and injects csrf token for unsafe methods", a
   assert.equal(calls[1][1].body, JSON.stringify({ demo: true }));
 });
 
+test("request resolves request urls after query encoding and before fetch", async () => {
+  const calls = [];
+  const contexts = [];
+  const client = createHttpClient({
+    csrf: {
+      enabled: false
+    },
+    resolveRequestUrl(url, context = {}) {
+      contexts.push({ url, context });
+      return url.replace(/^\/api\//u, "/api/app/beepollen/");
+    },
+    fetchImpl: async (url, options) => {
+      calls.push([url, options]);
+      return mockResponse({
+        data: {
+          ok: true
+        }
+      });
+    }
+  });
+
+  const payload = await client.request("/api/vibe64/sessions", {
+    method: "GET",
+    query: {
+      cursor: "next page"
+    }
+  });
+
+  assert.deepEqual(payload, { ok: true });
+  assert.equal(calls[0][0], "/api/app/beepollen/vibe64/sessions?cursor=next+page");
+  assert.equal(contexts[0].url, "/api/vibe64/sessions?cursor=next+page");
+  assert.equal(contexts[0].context.originalUrl, "/api/vibe64/sessions");
+  assert.equal(contexts[0].context.method, "GET");
+  assert.equal(contexts[0].context.stream, false);
+});
+
+test("requestStream resolves request urls before fetch", async () => {
+  const calls = [];
+  const client = createHttpClient({
+    csrf: {
+      enabled: false
+    },
+    resolveRequestUrl(url) {
+      return url.replace(/^\/api\//u, "/api/app/beepollen/");
+    },
+    fetchImpl: async (url, options) => {
+      calls.push([url, options]);
+      return mockResponse({
+        contentType: "text/plain; charset=utf-8",
+        text: ""
+      });
+    }
+  });
+
+  await client.requestStream("/api/vibe64/events", {
+    method: "GET"
+  });
+
+  assert.equal(calls[0][0], "/api/app/beepollen/vibe64/events");
+});
+
 test("request parses json:api responses as json payloads", async () => {
   const fetchImpl = async () =>
     mockResponse({

package/test/transientRetryHttpClient.test.js

@@ -69,6 +69,33 @@ test("createTransientRetryHttpClient retries transient GET request failures", as
   });
 });
 
+test("createTransientRetryHttpClient resolves request urls before fetch", async () => {
+  const calls = [];
+  const client = createTransientRetryHttpClient({
+    csrf: {
+      enabled: false
+    },
+    resolveRequestUrl(url) {
+      return url.replace(/^\/api\//u, "/api/app/beepollen/");
+    },
+    fetchImpl: async (url, options) => {
+      calls.push([url, options]);
+      return mockResponse({
+        data: {
+          ok: true
+        }
+      });
+    }
+  });
+
+  const payload = await client.request("/api/vibe64/sessions", {
+    method: "GET"
+  });
+
+  assert.deepEqual(payload, { ok: true });
+  assert.equal(calls[0][0], "/api/app/beepollen/vibe64/sessions");
+});
+
 test("createTransientRetryHttpClient does not retry unsafe transient failures", async () => {
   await withImmediateTimers(async () => {
     let callCount = 0;