@route-forge/core 1.3.0 → 1.4.0

package/dist/route-forge.global.js

@@ -281,30 +281,29 @@ var RouteForge = (function (exports) {
   function createBuiltinHttp(forgeInterceptors) {
     const requestMgr = forgeInterceptors?.request ?? createInterceptorManager();
     const responseMgr = forgeInterceptors?.response ?? createInterceptorManager();
-    async function request(config) {
-      const finalConfig = await runRequestInterceptors(requestMgr, config);
+    async function requestRaw(config) {
       const signal = combineSignals(
-        finalConfig.signal,
-        finalConfig.timeout && finalConfig.timeout > 0 ? AbortSignal.timeout(finalConfig.timeout) : void 0
+        config.signal,
+        config.timeout && config.timeout > 0 ? AbortSignal.timeout(config.timeout) : void 0
       );
-      let url = finalConfig.url;
-      if (finalConfig.paramsSerializer && finalConfig.params) {
-        const qs = finalConfig.paramsSerializer(finalConfig.params);
+      let url = config.url;
+      if (config.paramsSerializer && config.params) {
+        const qs = config.paramsSerializer(config.params);
         if (qs) {
           url = url.includes("?") ? `${url}&${qs}` : `${url}?${qs}`;
         }
       }
-      const headers = new Headers(finalConfig.headers);
+      const headers = new Headers(config.headers);
       const fetchInit = {
-        method: finalConfig.method,
+        method: config.method,
         headers
       };
       if (signal) fetchInit.signal = signal;
-      if (finalConfig.body !== void 0 && !["GET", "HEAD"].includes(finalConfig.method.toUpperCase())) {
-        if (typeof finalConfig.body === "string" || isPassthroughBody(finalConfig.body)) {
-          fetchInit.body = finalConfig.body;
+      if (config.body !== void 0 && !["GET", "HEAD"].includes(config.method.toUpperCase())) {
+        if (typeof config.body === "string" || isPassthroughBody(config.body)) {
+          fetchInit.body = config.body;
         } else {
-          fetchInit.body = JSON.stringify(finalConfig.body);
+          fetchInit.body = JSON.stringify(config.body);
           if (!headers.has("Content-Type")) {
             headers.set("Content-Type", "application/json");
           }
@@ -317,8 +316,8 @@ var RouteForge = (function (exports) {
         if (isAbortError(e)) throw e;
         throw new NetworkError(
           e instanceof Error ? e.message : String(e),
-          finalConfig.route,
-          finalConfig.level,
+          config.route,
+          config.level,
           e
         );
       }
@@ -332,27 +331,32 @@ var RouteForge = (function (exports) {
         }
       }
       const responseData = {
-        route: finalConfig.route,
-        level: finalConfig.level,
-        method: finalConfig.method,
+        route: config.route,
+        level: config.level,
+        method: config.method,
         url,
         status: res.status,
         headers: res.headers,
         data,
-        config: finalConfig
+        config
       };
-      const source = res.status >= 200 && res.status < 300 ? Promise.resolve(responseData) : Promise.reject(
-        new HTTPError(
-          `HTTP ${res.status} for route "${finalConfig.route}" (${finalConfig.method} ${url})`,
-          {
-            route: finalConfig.route,
-            level: finalConfig.level,
-            status: res.status,
-            url,
-            method: finalConfig.method
-          }
-        )
+      if (res.status >= 200 && res.status < 300) {
+        return responseData;
+      }
+      throw new HTTPError(
+        `HTTP ${res.status} for route "${config.route}" (${config.method} ${url})`,
+        {
+          route: config.route,
+          level: config.level,
+          status: res.status,
+          url,
+          method: config.method
+        }
       );
+    }
+    async function request(config) {
+      const finalConfig = await runRequestInterceptors(requestMgr, config);
+      const source = Promise.resolve(finalConfig).then(requestRaw);
       return runResponseInterceptors(
         responseMgr,
         source
@@ -365,6 +369,7 @@ var RouteForge = (function (exports) {
     const del = (url, config) => request({ ...config, url, method: "DELETE" });
     return {
       request,
+      requestRaw,
       interceptors: {
         request: requestMgr,
         response: responseMgr
@@ -576,7 +581,6 @@ var RouteForge = (function (exports) {
     const loadingTracker = new LoadingTracker();
     const explicitLevels = options.levels;
     const explicitEager = options.eager;
-    const explicitStrict = options.strict ?? false;
     const explicitEndpoint = options.endpoint;
     let effectiveLevels = explicitLevels ?? [];
     let effectiveEager = explicitEager ?? [];
@@ -624,11 +628,6 @@ var RouteForge = (function (exports) {
       if (summary.config.url_prefix) {
         effectiveUrlPrefix = summary.config.url_prefix.endsWith("/") ? summary.config.url_prefix.slice(0, -1) : summary.config.url_prefix;
       }
-      if (summary.config.strict_mode && !explicitStrict) {
-        console.warn(
-          "[route-forge] backend strict_mode=true overrides frontend strict=false; forcing strict=true"
-        );
-      }
       const backendLevels = Object.keys(summary.levels);
       backendHasUnassignedLevel = backendLevels.includes(UNASSIGNED_LEVEL);
       if (Array.isArray(summary.unassigned) && summary.unassigned.length > 0 && !backendHasUnassignedLevel) {
@@ -702,7 +701,10 @@ var RouteForge = (function (exports) {
       if (!adapterResolved) {
         adapterObj = await adapterPromise.catch((e) => {
           if (e instanceof AdapterNotFoundError) throw e;
-          return resolveAdapter({ adapter: "builtin" });
+          return resolveAdapter({
+            adapter: "builtin",
+            forgeInterceptors: { request: requestInterceptors, response: responseInterceptors }
+          });
         });
         adapterResolved = true;
       }
@@ -746,7 +748,8 @@ var RouteForge = (function (exports) {
           level
         }
       };
-      const resp = await adp.request(config);
+      const doRawRequest = adp.requestRaw ?? adp.request;
+      const resp = await doRawRequest(config);
       if (!resp || resp.status < 200 || resp.status >= 300) {
         throw new HTTPError(
           `Failed to load level "${level}": HTTP ${resp?.status}`,
@@ -849,23 +852,40 @@ var RouteForge = (function (exports) {
       }
       return void 0;
     }
-    async function api(level, name, params = {}) {
-      await autoDiscoveryPromise;
-      await load(level);
-      const meta = findRouteMeta(level, name);
-      if (!meta) {
-        throw new UnknownRouteError(name, level);
-      }
-      return doApiCall(meta, params);
+    function api(level, name, params = {}) {
+      let ctrl;
+      let abortedBeforeInit = false;
+      let abortReason;
+      const work = (async () => {
+        ctrl = new AbortController();
+        if (abortedBeforeInit) {
+          ctrl.abort(abortReason);
+        }
+        await autoDiscoveryPromise;
+        await load(level);
+        const meta = findRouteMeta(level, name);
+        if (!meta) {
+          throw new UnknownRouteError(name, level);
+        }
+        return doApiCall(meta, params, ctrl.signal);
+      })();
+      const request = work;
+      request.abort = () => {
+        if (ctrl) {
+          ctrl.abort();
+        } else {
+          abortedBeforeInit = true;
+        }
+      };
+      return request;
     }
-    async function doApiCall(meta, params) {
+    async function doApiCall(meta, params, signal) {
       const {
         pathParams,
         query,
         body,
         headers,
-        timeout: perCallTimeout,
-        signal
+        timeout: perCallTimeout
       } = resolveApiParams(params);
       if (signal?.aborted) {
         throw new RequestAbortedError(meta.name, meta.level, signal.reason);
@@ -909,7 +929,7 @@ var RouteForge = (function (exports) {
           },
           (err) => {
             if (err instanceof ForgeError) throw err;
-            if (isAbortError2(err, finalConfig.signal)) {
+            if (isAbortError2(err, signal)) {
               throw new RequestAbortedError(meta.name, meta.level, err);
             }
             throw new NetworkError(
@@ -997,7 +1017,8 @@ var RouteForge = (function (exports) {
     }
     const forgeResolver = { load, hasRoute };
     function createBoundForge(level, prefix) {
-      const levelLoadedPromise = load(level).catch(() => {
+      const levelLoadedPromise = load(level);
+      levelLoadedPromise.catch(() => {
       });
       const apiFn = prefix ? (name, params) => resolveRouteName(forgeResolver, level, prefix, name).then(
         (resolved) => api(level, resolved, params)
@@ -1097,7 +1118,6 @@ var RouteForge = (function (exports) {
       body: rawBody,
       headers: rawHeaders,
       timeout: perCallTimeout,
-      signal,
       ...flatRest
     } = input;
     const pathParams = explicitParams ? { ...explicitParams } : {};
@@ -1130,7 +1150,7 @@ var RouteForge = (function (exports) {
         pathParams.headers = rawHeaders;
       }
     }
-    return { pathParams, query, body, headers, timeout: perCallTimeout, signal };
+    return { pathParams, query, body, headers, timeout: perCallTimeout };
   }
   function isAbortError2(err, signal) {
     if (signal?.aborted) return true;