@scalar/oas-utils 0.2.125 → 0.2.127

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @scalar/oas-utils
 
+## 0.2.127
+
+### Patch Changes
+
+- bf961b1: feat: show custom code examples in the API client
+- a176b7e: feat: distinguishes collection and operation servers in import spec
+
+## 0.2.126
+
+### Patch Changes
+
+- a571d36: refactor: use central helper fetchDocument to fetch OpenAPI documents
+- Updated dependencies [3783345]
+  - @scalar/types@0.1.6
+  - @scalar/themes@0.9.84
+
 ## 0.2.125
 
 ### Patch Changes

package/dist/entities/spec/operation.d.ts

@@ -5,7 +5,7 @@
 import { type RequestPayload, type Request as RequestType } from './requests.ts';
 export type Operation = RequestType;
 export type OperationPayload = RequestPayload;
-export declare const operationSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<Omit<{
+export declare const operationSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<Omit<{
     tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
     summary: import("zod").ZodOptional<import("zod").ZodString>;
     description: import("zod").ZodOptional<import("zod").ZodString>;
@@ -161,6 +161,46 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     'x-internal': import("zod").ZodOptional<import("zod").ZodBoolean>;
     'x-scalar-ignore': import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, "x-scalar-examples">, {
+    'x-codeSamples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        source: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-code-samples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        source: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-custom-examples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        source: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+}>, {
     'x-scalar-stability': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodEnum<[import("@scalar/types").XScalarStability.Deprecated, import("@scalar/types").XScalarStability.Experimental, import("@scalar/types").XScalarStability.Stable]>>>;
 }>, {
     type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"request">>>;
@@ -209,6 +249,21 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     }[] | undefined;
     requestBody?: any;
     responses?: Record<string, any> | undefined;
+    'x-codeSamples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-code-samples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-custom-examples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
     'x-scalar-stability'?: import("@scalar/types").XScalarStability | undefined;
 }, {
     uid?: string | undefined;
@@ -247,6 +302,9 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     }[] | undefined;
     requestBody?: any;
     responses?: Record<string, any> | undefined;
+    'x-codeSamples'?: unknown;
+    'x-code-samples'?: unknown;
+    'x-custom-examples'?: unknown;
     'x-scalar-stability'?: unknown;
     method?: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace" | undefined;
 }>;

package/dist/entities/spec/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,IAAI,WAAW,EAAiB,MAAM,eAAe,CAAA;AAE/F,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgB,CAAA"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,IAAI,WAAW,EAAiB,MAAM,eAAe,CAAA;AAE/F,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aACqV,CAAC;YAAkC,CAAC;;;aAAoE,CAAC;YAAuB,CAAC;;;;;;;;aAAqT,CAAC;YAAkC,CAAC;;;aAAoE,CAAC;YAAuB,CAAC;;;;;;;;aAAwT,CAAC;YAAkC,CAAC;;;aAAoE,CAAC;YAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EADrzC,CAAA"}

package/dist/entities/spec/requests.d.ts

@@ -315,7 +315,7 @@ export declare const oasRequestSchema: z.ZodObject<{
     }> | undefined;
 }>;
 /** Unified request schema for client usage */
-export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<Omit<{
+export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<Omit<{
     /**
      * A list of tags for API documentation control. Tags can be used for logical
      * grouping of operations by resources or any other qualifier.
@@ -506,6 +506,46 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<z.objec
     'x-internal': z.ZodOptional<z.ZodBoolean>;
     'x-scalar-ignore': z.ZodOptional<z.ZodBoolean>;
 }, "x-scalar-examples">, {
+    'x-codeSamples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-code-samples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+    'x-custom-examples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }, {
+        source: string;
+        label?: unknown;
+        lang?: unknown;
+    }>, "many">>>;
+}>, {
     'x-scalar-stability': z.ZodCatch<z.ZodOptional<z.ZodEnum<[XScalarStability.Deprecated, XScalarStability.Experimental, XScalarStability.Stable]>>>;
 }>, {
     type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"request">>>;
@@ -560,6 +600,21 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<z.objec
     }[] | undefined;
     requestBody?: any;
     responses?: Record<string, any> | undefined;
+    'x-codeSamples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-code-samples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
+    'x-custom-examples'?: {
+        source: string;
+        label?: string | undefined;
+        lang?: string | undefined;
+    }[] | undefined;
     'x-scalar-stability'?: XScalarStability | undefined;
 }, {
     uid?: string | undefined;
@@ -598,6 +653,9 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<z.objec
     }[] | undefined;
     requestBody?: any;
     responses?: Record<string, any> | undefined;
+    'x-codeSamples'?: unknown;
+    'x-code-samples'?: unknown;
+    'x-custom-examples'?: unknown;
     'x-scalar-stability'?: unknown;
     method?: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace" | undefined;
 }>;

package/dist/entities/spec/requests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAGhD,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,uBAAuB,CAAA;AAGjF,eAAO,MAAM,cAAc,2FAA4F,CAAA;AAEvH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,0BAA0B;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtB,CAAA;AAyCF,8CAA8C;AAC9C,eAAO,MAAM,aAAa;IA1FxB;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;;;IA8BtB,eAAe;;IAEf,qBAAqB;;IAErB,kDAAkD;;IAElD,oCAAoC;;IAEpC,uDAAuD;;IAEvD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQlC,CAAA;AAE/B,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"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"}

package/dist/entities/spec/requests.js

@@ -1,6 +1,7 @@
 import { selectedSecuritySchemeUidSchema } from '../shared/utility.js';
 import { nanoidSchema } from '@scalar/types/utils';
 import { z } from 'zod';
+import { XCodeSamplesSchema } from '@scalar/openapi-types/schemas/extensions';
 import { XScalarStability } from '@scalar/types';
 import { oasSecurityRequirementSchema } from '@scalar/types/entities';
 import { oasParameterSchema } from './parameters.js';
@@ -100,6 +101,7 @@ const extendedRequestSchema = z.object({
 /** Unified request schema for client usage */
 const requestSchema = oasRequestSchema
     .omit({ 'x-scalar-examples': true })
+    .merge(XCodeSamplesSchema)
     .merge(ScalarStabilitySchema)
     .merge(extendedRequestSchema);
 

package/dist/helpers/fetch-document.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fetches an OpenAPI/Swagger document from a given URL
+ *
+ * @throws an error if the fetch fails
+ */
+export declare function fetchDocument(url: string, proxyUrl?: string, prettyPrint?: boolean): Promise<string>;
+//# sourceMappingURL=fetch-document.d.ts.map

package/dist/helpers/fetch-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-document.d.ts","sourceRoot":"","sources":["../../src/helpers/fetch-document.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,WAAW,UAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BvG"}

package/dist/helpers/fetch-document.js

@@ -0,0 +1,35 @@
+import { formatJsonOrYamlString } from './parse.js';
+import { redirectToProxy } from './redirect-to-proxy.js';
+
+// Doesn’t work
+const OLD_PROXY_URL = 'https://api.scalar.com/request-proxy';
+// Does work
+const NEW_PROXY_URL = 'https://proxy.scalar.com';
+/**
+ * Fetches an OpenAPI/Swagger document from a given URL
+ *
+ * @throws an error if the fetch fails
+ */
+async function fetchDocument(url, proxyUrl, prettyPrint = true) {
+    // This replaces the OLD_PROXY_URL with the NEW_PROXY_URL on the fly.
+    if (proxyUrl === OLD_PROXY_URL) {
+        // biome-ignore lint/style/noParameterAssign: It’s ok, let’s make an exception here.
+        proxyUrl = NEW_PROXY_URL;
+    }
+    const response = await fetch(redirectToProxy(proxyUrl, url));
+    // Looks like the request failed
+    if (response.status !== 200) {
+        console.error(`[fetchDocument] Failed to fetch the OpenAPI document from ${url} (Status: ${response.status})`);
+        if (!proxyUrl) {
+            console.warn(`[fetchDocument] Tried to fetch the OpenAPI document from ${url} without a proxy. Are the CORS headers configured to allow cross-domain requests? https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS`);
+        }
+        throw new Error(`Failed to fetch the OpenAPI document from ${url} (Status: ${response.status})`);
+    }
+    // If it’s JSON, make it pretty
+    if (prettyPrint) {
+        return formatJsonOrYamlString(await response.text());
+    }
+    return await response.text();
+}
+
+export { fetchDocument };

package/dist/helpers/fetch-with-proxy-fallback.d.ts

@@ -1,15 +1,15 @@
 export type FetchWithProxyFallbackOptions = {
-    proxy: string | undefined;
+    proxyUrl: string | undefined;
     /**
      * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
      */
     cache?: RequestInit['cache'];
 };
 /**
- * Fetches an OpenAPI document with a proxy fallback mechanism.
+ * Fetches an OpenAPI document with a proxyUrl fallback mechanism.
  *
  * If a proxy is provided and the URL requires it, it will first attempt to fetch using the proxy.
  * If the proxy fetch fails or is not used, it will fall back to a direct fetch.
  */
-export declare function fetchWithProxyFallback(url: string, { proxy, cache }: FetchWithProxyFallbackOptions): Promise<Response>;
+export declare function fetchWithProxyFallback(url: string, { proxyUrl, cache }: FetchWithProxyFallbackOptions): Promise<Response>;
 //# sourceMappingURL=fetch-with-proxy-fallback.d.ts.map

package/dist/helpers/fetch-with-proxy-fallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-with-proxy-fallback.d.ts","sourceRoot":"","sources":["../../src/helpers/fetch-with-proxy-fallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAC7B,CAAA;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,6BAA6B,qBAuBxG"}
+{"version":3,"file":"fetch-with-proxy-fallback.d.ts","sourceRoot":"","sources":["../../src/helpers/fetch-with-proxy-fallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B;;OAEG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAC7B,CAAA;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,6BAA6B,qBAuB3G"}

package/dist/helpers/fetch-with-proxy-fallback.js

@@ -1,28 +1,28 @@
 import { shouldUseProxy, redirectToProxy } from './redirect-to-proxy.js';
 
 /**
- * Fetches an OpenAPI document with a proxy fallback mechanism.
+ * Fetches an OpenAPI document with a proxyUrl fallback mechanism.
  *
  * If a proxy is provided and the URL requires it, it will first attempt to fetch using the proxy.
  * If the proxy fetch fails or is not used, it will fall back to a direct fetch.
  */
-async function fetchWithProxyFallback(url, { proxy, cache }) {
+async function fetchWithProxyFallback(url, { proxyUrl, cache }) {
     const fetchOptions = {
         cache: cache || 'default',
     };
-    const shouldTryProxy = shouldUseProxy(proxy, url);
-    const initialUrl = shouldTryProxy ? redirectToProxy(proxy, url) : url;
+    const shouldTryProxy = shouldUseProxy(proxyUrl, url);
+    const initialUrl = shouldTryProxy ? redirectToProxy(proxyUrl, url) : url;
     try {
         const result = await fetch(initialUrl, fetchOptions);
         if (result.ok || !shouldTryProxy) {
             return result;
         }
-        // Retry without proxy if the initial request failed
+        // Retry without proxyUrl if the initial request failed
         return await fetch(url, fetchOptions);
     }
     catch (error) {
         if (shouldTryProxy) {
-            // If proxy failed, try without it
+            // If proxyUrl failed, try without it
             return await fetch(url, fetchOptions);
         }
         throw error;

package/dist/helpers/index.d.ts

@@ -1,6 +1,6 @@
 export { createHash } from './create-hash.ts';
 export { ensureProtocol } from './ensure-protocol.ts';
-export { fetchSpecFromUrl } from './fetch-spec-from-url.ts';
+export { fetchDocument } from './fetch-document.ts';
 export { type FetchWithProxyFallbackOptions, fetchWithProxyFallback } from './fetch-with-proxy-fallback.ts';
 export { findVariables } from './find-variables.ts';
 export { canMethodHaveBody, getHttpMethodInfo, isHttpMethod, REQUEST_METHODS } from './http-methods.ts';

package/dist/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,KAAK,6BAA6B,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AAC3G,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACvG,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACnG,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACzE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/G,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACxF,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,KAAK,6BAA6B,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AAC3G,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACvG,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACnG,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACzE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/G,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACxF,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA"}

package/dist/helpers/index.js

@@ -1,6 +1,6 @@
 export { createHash } from './create-hash.js';
 export { ensureProtocol } from './ensure-protocol.js';
-export { fetchSpecFromUrl } from './fetch-spec-from-url.js';
+export { fetchDocument } from './fetch-document.js';
 export { fetchWithProxyFallback } from './fetch-with-proxy-fallback.js';
 export { findVariables } from './find-variables.js';
 export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo, isHttpMethod } from './http-methods.js';

package/dist/helpers/redirect-to-proxy.d.ts

@@ -1,7 +1,17 @@
-/** Redirects the request to a proxy server with a given URL. */
-export declare function redirectToProxy(proxy?: string, url?: string): string;
-/** Check if the URL is relative or if it's a domain without protocol */
+/**
+ * Redirects the request to a proxy server with a given URL. But not for:
+ *
+ * - Relative URLs
+ * - URLs that seem to point to a local IP (except the proxy is on the same domain)
+ * - URLs that don’t look like a domain
+ **/
+export declare function redirectToProxy(proxyUrl?: string, url?: string): string;
+/**
+ * Check if the URL is relative or if it's a domain without protocol
+ **/
 export declare const isRelativePath: (url: string) => boolean;
-/** Returns false for requests to localhost, relative URLs, if no proxy is defined … */
-export declare function shouldUseProxy(proxy?: string, url?: string): boolean;
+/**
+ * Returns false for requests to localhost, relative URLs, if no proxy is defined …
+ **/
+export declare function shouldUseProxy(proxyUrl?: string, url?: string): url is string;
 //# sourceMappingURL=redirect-to-proxy.d.ts.map

package/dist/helpers/redirect-to-proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redirect-to-proxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirect-to-proxy.ts"],"names":[],"mappings":"AAGA,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAepE;AAED,wEAAwE;AACxE,eAAO,MAAM,cAAc,QAAS,MAAM,YAazC,CAAA;AAED,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAiBpE"}
+{"version":3,"file":"redirect-to-proxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirect-to-proxy.ts"],"names":[],"mappings":"AAGA;;;;;;IAMI;AACJ,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAmCvE;AAED;;IAEI;AACJ,eAAO,MAAM,cAAc,QAAS,MAAM,YAazC,CAAA;AAED;;IAEI;AACJ,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,IAAI,MAAM,CAkC7E"}

package/dist/helpers/redirect-to-proxy.js

@@ -1,20 +1,47 @@
 import { isLocalUrl } from './is-local-url.js';
 import { REGEX } from './regex-helpers.js';
 
-/** Redirects the request to a proxy server with a given URL. */
-function redirectToProxy(proxy, url) {
-    if (!shouldUseProxy(proxy, url)) {
+/**
+ * Redirects the request to a proxy server with a given URL. But not for:
+ *
+ * - Relative URLs
+ * - URLs that seem to point to a local IP (except the proxy is on the same domain)
+ * - URLs that don’t look like a domain
+ **/
+function redirectToProxy(proxyUrl, url) {
+    try {
+        if (!shouldUseProxy(proxyUrl, url)) {
+            console.log('should not use proxy', proxyUrl, url);
+            return url ?? '';
+        }
+        // Create new URL object from url
+        const newUrl = new URL(url);
+        // Add temporary domain for relative proxy URLs
+        //
+        // Q: Why isn’t proxyUrl type guarded?
+        // A: Type guarding works for one parameter only (as of now).
+        //
+        // Q: Why do we need to add http://localhost to relative proxy URLs?
+        // A: Because the `new URL()` would otherwise fail.
+        //
+        const temporaryProxyUrl = isRelativePath(proxyUrl) ? `http://localhost${proxyUrl}` : proxyUrl;
+        // Rewrite the URL with the proxy
+        newUrl.href = temporaryProxyUrl;
+        // Add the original URL as a query parameter
+        newUrl.searchParams.append('scalar_url', url);
+        // Remove the temporary domain if we added it, but only from the start of the URL
+        const result = isRelativePath(proxyUrl)
+            ? newUrl.toString().replace(/^http:\/\/localhost/, '')
+            : newUrl.toString();
+        return result;
+    }
+    catch {
         return url ?? '';
     }
-    // Create new URL object from url
-    const newUrl = new URL(url);
-    // Rewrite the URL with the proxy
-    newUrl.href = proxy;
-    // Add the original URL as a query parameter
-    newUrl.searchParams.append('scalar_url', url);
-    return newUrl.toString();
 }
-/** Check if the URL is relative or if it's a domain without protocol */
+/**
+ * Check if the URL is relative or if it's a domain without protocol
+ **/
 const isRelativePath = (url) => {
     // Allow http:// https:// and other protocols such as file://
     if (REGEX.PROTOCOL.test(url)) {
@@ -27,21 +54,39 @@ const isRelativePath = (url) => {
     }
     return true;
 };
-/** Returns false for requests to localhost, relative URLs, if no proxy is defined … */
-function shouldUseProxy(proxy, url) {
-    // No proxy or url
-    if (!proxy || !url) {
-        return false;
+/**
+ * Returns false for requests to localhost, relative URLs, if no proxy is defined …
+ **/
+function shouldUseProxy(proxyUrl, url) {
+    try {
+        // ❌ We don’t have a proxy URL or the URL
+        if (!proxyUrl || !url) {
+            return false;
+        }
+        // ❌ Request to relative URLs (won’t be blocked by CORS anyway)
+        if (isRelativePath(url)) {
+            return false;
+        }
+        // ✅ Proxy URL is on the same domain (e.g. /proxy)
+        // It’s more likely (not guaranteed, though) that the proxy has access to local domains.
+        if (isRelativePath(proxyUrl)) {
+            return true;
+        }
+        // ✅ Proxy URL is local
+        if (isLocalUrl(proxyUrl)) {
+            return true;
+        }
+        // ❌ Requests to localhost
+        // We won’t reach them from a (likely remote) proxy.
+        if (isLocalUrl(url)) {
+            return false;
+        }
+        // ✅ Seems fine (e.g. remote proxy + remote URL)
+        return true;
     }
-    // Relative URLs
-    if (isRelativePath(url)) {
+    catch {
         return false;
     }
-    // Requests to localhost
-    if (isLocalUrl(url)) {
-        return false;
-    }
-    return true;
 }
 
 export { isRelativePath, redirectToProxy, shouldUseProxy };

package/dist/transforms/import-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAC9E,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAoB,MAAM,+BAA+B,CAAA;AAEzG,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,qCAAqC,CAAA;AACnG,OAAO,EAAE,KAAK,OAAO,EAAsC,MAAM,6BAA6B,CAAA;AAC9F,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,2BAA2B,CAAA;AACrE,OAAO,EAAE,KAAK,GAAG,EAAa,MAAM,iCAAiC,CAAA;AAKrE,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,wBAAwB,CAAA;AAE/B,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAAgB,MAAM,GAAG,aAAa;;;IAoC1D;;;OAGG;YAC8C,WAAW,CAAC,QAAQ;;EAGxE,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,6BAA6B,yBAClB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,0BACnB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,iCAC1B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,KACvD,0BAaF,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,UAAU,SAAU,MAAM,KAA2B,UAAU,CAAC,KAAK,CAAC,CAAA;AAEnF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,WAAW,CAAC,GAC1F,IAAI,CAAC,yBAAyB,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC,GAAG;IACzF,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,yCAAyC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,aAAa,EACb,WAAW,EACX,OAAO,EAAE,iBAAiB,EAC1B,qBAA6B,EAC7B,IAAI,EACJ,UAAU,EACV,SAAiB,GAClB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC5B,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAA;CAAE,CACnE,CAyWA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,GAAG,SAAS,EAC/C,EAAE,aAAa,EAAE,GAAE,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAM,GACvE,MAAM,EAAE,CA0CV"}
+{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAC9E,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAoB,MAAM,+BAA+B,CAAA;AAEzG,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,qCAAqC,CAAA;AACnG,OAAO,EAAE,KAAK,OAAO,EAAsC,MAAM,6BAA6B,CAAA;AAC9F,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,2BAA2B,CAAA;AACrE,OAAO,EAAE,KAAK,GAAG,EAAa,MAAM,iCAAiC,CAAA;AAKrE,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,wBAAwB,CAAA;AAE/B,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAAgB,MAAM,GAAG,aAAa;;;IAoC1D;;;OAGG;YAC8C,WAAW,CAAC,QAAQ;;EAGxE,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,6BAA6B,yBAClB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,0BACnB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,iCAC1B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,KACvD,0BAaF,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,UAAU,SAAU,MAAM,KAA2B,UAAU,CAAC,KAAK,CAAC,CAAA;AAEnF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,WAAW,CAAC,GAC1F,IAAI,CAAC,yBAAyB,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC,GAAG;IACzF,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,yCAAyC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,aAAa,EACb,WAAW,EACX,OAAO,EAAE,iBAAiB,EAC1B,qBAA6B,EAC7B,IAAI,EACJ,UAAU,EACV,SAAiB,GAClB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC5B,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAA;CAAE,CACnE,CAiXA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,GAAG,SAAS,EAC/C,EAAE,aAAa,EAAE,GAAE,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAM,GACvE,MAAM,EAAE,CA0CV"}

package/dist/transforms/import-spec.js

@@ -86,15 +86,17 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
     // Some entities will be broken out as individual lists for modification in the workspace
     const start = performance.now();
     const requests = [];
-    // Add the base server url to any relative servers
-    const servers = getServersFromOpenApiDocument(configuredServers || schema.servers, {
+    // Add the base server url to collection servers
+    const collectionServers = getServersFromOpenApiDocument(configuredServers || schema.servers, {
         baseServerURL,
     });
+    // Store operation servers
+    const operationServers = [];
     // Fallback to the current window.location.origin if no servers are provided
-    if (!servers.length) {
+    if (!collectionServers.length) {
         const fallbackUrl = getFallbackUrl();
         if (fallbackUrl) {
-            servers.push(serverSchema.parse({ url: fallbackUrl }));
+            collectionServers.push(serverSchema.parse({ url: fallbackUrl }));
         }
     }
     /**
@@ -198,13 +200,17 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
         }
         // Path level servers must be saved
         const pathServers = serverSchema.array().parse(path.servers ?? []);
-        servers.push(...pathServers);
+        for (const server of pathServers) {
+            collectionServers.push(server);
+        }
         // Creates a sorted array of methods based on the path object.
         const methods = Object.keys(path).filter(isHttpMethod);
         methods.forEach((method) => {
             const operation = path[method];
-            const operationServers = serverSchema.array().parse(operation.servers ?? []);
-            servers.push(...operationServers);
+            const operationLevelServers = serverSchema.array().parse(operation.servers ?? []);
+            for (const server of operationLevelServers) {
+                operationServers.push(server);
+            }
             // We will save a list of all tags to ensure they exists at the top level
             // TODO: make sure we add any loose requests with no tags to the collection children
             operation.tags?.forEach((t) => tagNames.add(t));
@@ -234,10 +240,11 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
                 method,
                 path: pathString,
                 security: operationSecurity,
+                selectedServerUid: operationLevelServers?.[0]?.uid,
                 selectedSecuritySchemeUids,
                 // Merge path and operation level parameters
                 parameters: [...(path?.parameters ?? []), ...(operation.parameters ?? [])],
-                servers: [...pathServers, ...operationServers].map((s) => s.uid),
+                servers: [...pathServers, ...operationLevelServers].map((s) => s.uid),
             };
             // Remove any examples from the request payload as they conflict with our examples property and are not valid
             if (requestPayload.examples) {
@@ -344,11 +351,11 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
         documentUrl,
         useCollectionSecurity,
         requests: requests.map((r) => r.uid),
-        servers: servers.map((s) => s.uid),
+        servers: collectionServers.map((s) => s.uid),
         tags: tags.map((t) => t.uid),
         children: [...collectionChildren],
         security: schema.security ?? [{}],
-        selectedServerUid: servers?.[0]?.uid,
+        selectedServerUid: collectionServers?.[0]?.uid,
         selectedSecuritySchemeUids,
         components: {
             ...schema.components,
@@ -363,7 +370,7 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
      */
     return {
         error: false,
-        servers,
+        servers: [...collectionServers, ...operationServers],
         schema,
         requests,
         examples,

package/package.json

@@ -16,7 +16,7 @@
     "specification",
     "yaml"
   ],
-  "version": "0.2.125",
+  "version": "0.2.127",
   "engines": {
     "node": ">=18"
   },
@@ -89,8 +89,8 @@
     "zod": "^3.23.8",
     "@scalar/object-utils": "1.1.13",
     "@scalar/openapi-types": "0.2.0",
-    "@scalar/themes": "0.9.83",
-    "@scalar/types": "0.1.5"
+    "@scalar/themes": "0.9.84",
+    "@scalar/types": "0.1.6"
   },
   "devDependencies": {
     "@types/node": "^20.17.10",
@@ -99,8 +99,8 @@
     "vitest": "^1.6.0",
     "zod-to-ts": "github:amritk/zod-to-ts#build",
     "@scalar/build-tooling": "0.1.17",
-    "@scalar/openapi-types": "0.2.0",
-    "@scalar/openapi-parser": "0.10.13"
+    "@scalar/openapi-parser": "0.10.14",
+    "@scalar/openapi-types": "0.2.0"
   },
   "scripts": {
     "build": "scalar-build-rollup",

package/dist/helpers/fetch-spec-from-url.d.ts

@@ -1,7 +0,0 @@
-/**
- * Fetches an OpenAPI/Swagger specification from a given URL.
- *
- * @throws an error if the fetch fails
- */
-export declare function fetchSpecFromUrl(url: string, proxy?: string, beautify?: boolean): Promise<string>;
-//# sourceMappingURL=fetch-spec-from-url.d.ts.map

package/dist/helpers/fetch-spec-from-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch-spec-from-url.d.ts","sourceRoot":"","sources":["../../src/helpers/fetch-spec-from-url.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BpG"}

package/dist/helpers/fetch-spec-from-url.js

@@ -1,36 +0,0 @@
-import { formatJsonOrYamlString } from './parse.js';
-import { redirectToProxy } from './redirect-to-proxy.js';
-
-// Doesn’t work
-const OLD_PROXY_URL = 'https://api.scalar.com/request-proxy';
-// Does work
-const NEW_PROXY_URL = 'https://proxy.scalar.com';
-/**
- * Fetches an OpenAPI/Swagger specification from a given URL.
- *
- * @throws an error if the fetch fails
- */
-async function fetchSpecFromUrl(url, proxy, beautify = true) {
-    // This replaces the OLD_PROXY_URL with the NEW_PROXY_URL on the fly.
-    if (proxy === OLD_PROXY_URL) {
-        // biome-ignore lint/style/noParameterAssign: It’s ok, let’s make an exception here.
-        proxy = NEW_PROXY_URL;
-    }
-    // To use a proxy or not to use a proxy
-    const response = await fetch(proxy ? redirectToProxy(proxy, url) : url);
-    // Looks like the request failed
-    if (response.status !== 200) {
-        console.error(`[fetchSpecFromUrl] Failed to fetch the specification at ${url} (Status: ${response.status})`);
-        if (!proxy) {
-            console.warn(`[fetchSpecFromUrl] Tried to fetch the specification (url: ${url}) without a proxy. Are the CORS headers configured to allow cross-domain requests? https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS`);
-        }
-        throw new Error(`Failed to fetch the specification (Status: ${response.status})`);
-    }
-    // If it’s JSON, make it pretty
-    if (beautify) {
-        return formatJsonOrYamlString(await response.text());
-    }
-    return await response.text();
-}
-
-export { fetchSpecFromUrl };