@scalar/mock-server 0.3.23 → 0.3.25

package/dist/utils/getOpenAuthTokenUrls.js

@@ -1,54 +1,42 @@
-/**
- * Extract path from URL
- */
 function getPathFromUrl(url) {
-    try {
-        // Handle relative URLs by prepending a base
-        const urlObject = url.startsWith('http') ? new URL(url) : new URL(url, 'http://example.com');
-        // Normalize: remove trailing slash except for root path
-        const path = urlObject.pathname;
-        return path === '/' ? path : path.replace(/\/$/, '');
-    }
-    catch {
-        // If URL is invalid, return the original string
-        return url;
-    }
+  try {
+    const urlObject = url.startsWith("http") ? new URL(url) : new URL(url, "http://example.com");
+    const path = urlObject.pathname;
+    return path === "/" ? path : path.replace(/\/$/, "");
+  } catch {
+    return url;
+  }
 }
-/**
- * Returns all token URLs mentioned in the securitySchemes, without the domain
- */
-// Type guard for OAuth2 security scheme
 function isOAuth2Scheme(scheme) {
-    return scheme.type === 'oauth2';
+  return scheme.type === "oauth2";
 }
-// Validate token URL
 function isValidTokenUrl(url) {
-    return url.trim().length > 0;
+  return url.trim().length > 0;
 }
 function getOpenAuthTokenUrls(schema) {
-    if (!schema?.components?.securitySchemes) {
-        return [];
-    }
-    const securitySchemes = schema.components.securitySchemes;
-    // Use Set from the start for better memory efficiency
-    const tokenUrls = new Set();
-    // Iterate through all security schemes
-    for (const scheme of Object.values(securitySchemes)) {
-        if (!isOAuth2Scheme(scheme)) {
-            continue;
-        }
-        const flows = scheme.flows; // Type assertion no longer needed
-        // Helper to safely add valid token URLs
-        const addTokenUrl = (url) => {
-            if (url && isValidTokenUrl(url)) {
-                tokenUrls.add(getPathFromUrl(url));
-            }
-        };
-        addTokenUrl(flows?.password?.tokenUrl);
-        addTokenUrl(flows?.clientCredentials?.tokenUrl);
-        addTokenUrl(flows?.authorizationCode?.tokenUrl);
+  if (!schema?.components?.securitySchemes) {
+    return [];
+  }
+  const securitySchemes = schema.components.securitySchemes;
+  const tokenUrls = /* @__PURE__ */ new Set();
+  for (const scheme of Object.values(securitySchemes)) {
+    if (!isOAuth2Scheme(scheme)) {
+      continue;
     }
-    return Array.from(tokenUrls);
+    const flows = scheme.flows;
+    const addTokenUrl = (url) => {
+      if (url && isValidTokenUrl(url)) {
+        tokenUrls.add(getPathFromUrl(url));
+      }
+    };
+    addTokenUrl(flows?.password?.tokenUrl);
+    addTokenUrl(flows?.clientCredentials?.tokenUrl);
+    addTokenUrl(flows?.authorizationCode?.tokenUrl);
+  }
+  return Array.from(tokenUrls);
 }
-
-export { getOpenAuthTokenUrls, getPathFromUrl };
+export {
+  getOpenAuthTokenUrls,
+  getPathFromUrl
+};
+//# sourceMappingURL=getOpenAuthTokenUrls.js.map

package/dist/utils/getOpenAuthTokenUrls.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getOpenAuthTokenUrls.ts"],
+  "sourcesContent": ["import type { OpenAPI, OpenAPIV3, OpenAPIV3_1 } from '@scalar/openapi-types'\n\n/**\n * Extract path from URL\n */\nexport function getPathFromUrl(url: string): string {\n  try {\n    // Handle relative URLs by prepending a base\n    const urlObject = url.startsWith('http') ? new URL(url) : new URL(url, 'http://example.com')\n\n    // Normalize: remove trailing slash except for root path\n    const path = urlObject.pathname\n    return path === '/' ? path : path.replace(/\\/$/, '')\n  } catch {\n    // If URL is invalid, return the original string\n    return url\n  }\n}\n\n/**\n * Returns all token URLs mentioned in the securitySchemes, without the domain\n */\n// Type guard for OAuth2 security scheme\nfunction isOAuth2Scheme(\n  scheme: OpenAPIV3.SecuritySchemeObject | OpenAPIV3_1.SecuritySchemeObject,\n): scheme is OpenAPIV3.OAuth2SecurityScheme | OpenAPIV3_1.OAuth2SecurityScheme {\n  return scheme.type === 'oauth2'\n}\n\n// Validate token URL\nfunction isValidTokenUrl(url: string): boolean {\n  return url.trim().length > 0\n}\n\nexport function getOpenAuthTokenUrls(schema?: OpenAPI.Document): string[] {\n  if (!schema?.components?.securitySchemes) {\n    return []\n  }\n\n  const securitySchemes: Record<string, OpenAPIV3.SecuritySchemeObject | OpenAPIV3_1.SecuritySchemeObject> =\n    schema.components.securitySchemes\n\n  // Use Set from the start for better memory efficiency\n  const tokenUrls = new Set<string>()\n\n  // Iterate through all security schemes\n  for (const scheme of Object.values(securitySchemes)) {\n    if (!isOAuth2Scheme(scheme)) {\n      continue\n    }\n\n    const flows = scheme.flows // Type assertion no longer needed\n\n    // Helper to safely add valid token URLs\n    const addTokenUrl = (url?: string) => {\n      if (url && isValidTokenUrl(url)) {\n        tokenUrls.add(getPathFromUrl(url))\n      }\n    }\n\n    addTokenUrl(flows?.password?.tokenUrl)\n    addTokenUrl(flows?.clientCredentials?.tokenUrl)\n    addTokenUrl(flows?.authorizationCode?.tokenUrl)\n  }\n\n  return Array.from(tokenUrls)\n}\n"],
+  "mappings": "AAKO,SAAS,eAAe,KAAqB;AAClD,MAAI;AAEF,UAAM,YAAY,IAAI,WAAW,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,KAAK,oBAAoB;AAG3F,UAAM,OAAO,UAAU;AACvB,WAAO,SAAS,MAAM,OAAO,KAAK,QAAQ,OAAO,EAAE;AAAA,EACrD,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAMA,SAAS,eACP,QAC6E;AAC7E,SAAO,OAAO,SAAS;AACzB;AAGA,SAAS,gBAAgB,KAAsB;AAC7C,SAAO,IAAI,KAAK,EAAE,SAAS;AAC7B;AAEO,SAAS,qBAAqB,QAAqC;AACxE,MAAI,CAAC,QAAQ,YAAY,iBAAiB;AACxC,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,kBACJ,OAAO,WAAW;AAGpB,QAAM,YAAY,oBAAI,IAAY;AAGlC,aAAW,UAAU,OAAO,OAAO,eAAe,GAAG;AACnD,QAAI,CAAC,eAAe,MAAM,GAAG;AAC3B;AAAA,IACF;AAEA,UAAM,QAAQ,OAAO;AAGrB,UAAM,cAAc,CAAC,QAAiB;AACpC,UAAI,OAAO,gBAAgB,GAAG,GAAG;AAC/B,kBAAU,IAAI,eAAe,GAAG,CAAC;AAAA,MACnC;AAAA,IACF;AAEA,gBAAY,OAAO,UAAU,QAAQ;AACrC,gBAAY,OAAO,mBAAmB,QAAQ;AAC9C,gBAAY,OAAO,mBAAmB,QAAQ;AAAA,EAChD;AAEA,SAAO,MAAM,KAAK,SAAS;AAC7B;",
+  "names": []
+}

package/dist/utils/getOpenAuthTokenUrls.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import { createOpenApiDefinition } from "./createOpenApiDefinition.js";
+import { getOpenAuthTokenUrls, getPathFromUrl } from "./getOpenAuthTokenUrls.js";
+describe("getOpenAuthTokenUrls", () => {
+  it("returns an empty array for schema without securitySchemes", () => {
+    const schema = createOpenApiDefinition({});
+    expect(getOpenAuthTokenUrls(schema)).toEqual([]);
+  });
+  it("returns token URLs from OAuth2 password flow", () => {
+    const schema = createOpenApiDefinition({
+      oauth2Password: {
+        type: "oauth2",
+        flows: {
+          password: {
+            tokenUrl: "https://api.example.com/oauth/token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/token"]);
+  });
+  it("returns token URLs from OAuth2 clientCredentials flow", () => {
+    const schema = createOpenApiDefinition({
+      oauth2ClientCredentials: {
+        type: "oauth2",
+        flows: {
+          clientCredentials: {
+            tokenUrl: "https://api.example.com/oauth/client_token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/client_token"]);
+  });
+  it("returns token URLs from OAuth2 authorizationCode flow", () => {
+    const schema = createOpenApiDefinition({
+      oauth2AuthCode: {
+        type: "oauth2",
+        flows: {
+          authorizationCode: {
+            authorizationUrl: "https://api.example.com/oauth/authorize",
+            tokenUrl: "https://api.example.com/oauth/token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/token"]);
+  });
+  it("returns multiple token URLs from different OAuth2 flows", () => {
+    const schema = createOpenApiDefinition({
+      oauth2Password: {
+        type: "oauth2",
+        flows: {
+          password: {
+            tokenUrl: "https://api.example.com/oauth/password_token"
+          }
+        }
+      },
+      oauth2ClientCredentials: {
+        type: "oauth2",
+        flows: {
+          clientCredentials: {
+            tokenUrl: "https://api.example.com/oauth/client_token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/password_token", "/oauth/client_token"]);
+  });
+  it("ignores non-OAuth2 security schemes", () => {
+    const schema = createOpenApiDefinition({
+      basicAuth: {
+        type: "http",
+        scheme: "basic"
+      },
+      oauth2Password: {
+        type: "oauth2",
+        flows: {
+          password: {
+            tokenUrl: "https://api.example.com/oauth/token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/token"]);
+  });
+  it("returns unique token URLs", () => {
+    const schema = createOpenApiDefinition({
+      oauth2Password: {
+        type: "oauth2",
+        flows: {
+          password: {
+            tokenUrl: "https://api.example.com/oauth/token"
+          }
+        }
+      },
+      oauth2ClientCredentials: {
+        type: "oauth2",
+        flows: {
+          clientCredentials: {
+            tokenUrl: "https://api.example.com/oauth/token"
+          }
+        }
+      }
+    });
+    expect(getOpenAuthTokenUrls(schema)).toEqual(["/oauth/token"]);
+  });
+});
+describe("getPathFromUrl", () => {
+  it("returns the path from a valid URL", () => {
+    const url = "https://api.example.com/oauth/token";
+    expect(getPathFromUrl(url)).toBe("/oauth/token");
+  });
+  it("handles URLs with query parameters", () => {
+    const url = "https://api.example.com/oauth/token?param=value";
+    expect(getPathFromUrl(url)).toBe("/oauth/token");
+  });
+  it("handles URLs with fragments", () => {
+    const url = "https://api.example.com/oauth/token#fragment";
+    expect(getPathFromUrl(url)).toBe("/oauth/token");
+  });
+  it("handles URLs without paths", () => {
+    const url = "https://api.example.com";
+    expect(getPathFromUrl(url)).toBe("/");
+  });
+});
+//# sourceMappingURL=getOpenAuthTokenUrls.test.js.map

package/dist/utils/getOpenAuthTokenUrls.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getOpenAuthTokenUrls.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from 'vitest'\n\nimport { createOpenApiDefinition } from './createOpenApiDefinition'\nimport { getOpenAuthTokenUrls, getPathFromUrl } from './getOpenAuthTokenUrls'\n\ndescribe('getOpenAuthTokenUrls', () => {\n  it('returns an empty array for schema without securitySchemes', () => {\n    const schema = createOpenApiDefinition({})\n    expect(getOpenAuthTokenUrls(schema)).toEqual([])\n  })\n\n  it('returns token URLs from OAuth2 password flow', () => {\n    const schema = createOpenApiDefinition({\n      oauth2Password: {\n        type: 'oauth2',\n        flows: {\n          password: {\n            tokenUrl: 'https://api.example.com/oauth/token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/token'])\n  })\n\n  it('returns token URLs from OAuth2 clientCredentials flow', () => {\n    const schema = createOpenApiDefinition({\n      oauth2ClientCredentials: {\n        type: 'oauth2',\n        flows: {\n          clientCredentials: {\n            tokenUrl: 'https://api.example.com/oauth/client_token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/client_token'])\n  })\n\n  it('returns token URLs from OAuth2 authorizationCode flow', () => {\n    const schema = createOpenApiDefinition({\n      oauth2AuthCode: {\n        type: 'oauth2',\n        flows: {\n          authorizationCode: {\n            authorizationUrl: 'https://api.example.com/oauth/authorize',\n            tokenUrl: 'https://api.example.com/oauth/token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/token'])\n  })\n\n  it('returns multiple token URLs from different OAuth2 flows', () => {\n    const schema = createOpenApiDefinition({\n      oauth2Password: {\n        type: 'oauth2',\n        flows: {\n          password: {\n            tokenUrl: 'https://api.example.com/oauth/password_token',\n          },\n        },\n      },\n      oauth2ClientCredentials: {\n        type: 'oauth2',\n        flows: {\n          clientCredentials: {\n            tokenUrl: 'https://api.example.com/oauth/client_token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/password_token', '/oauth/client_token'])\n  })\n\n  it('ignores non-OAuth2 security schemes', () => {\n    const schema = createOpenApiDefinition({\n      basicAuth: {\n        type: 'http',\n        scheme: 'basic',\n      },\n      oauth2Password: {\n        type: 'oauth2',\n        flows: {\n          password: {\n            tokenUrl: 'https://api.example.com/oauth/token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/token'])\n  })\n\n  it('returns unique token URLs', () => {\n    const schema = createOpenApiDefinition({\n      oauth2Password: {\n        type: 'oauth2',\n        flows: {\n          password: {\n            tokenUrl: 'https://api.example.com/oauth/token',\n          },\n        },\n      },\n      oauth2ClientCredentials: {\n        type: 'oauth2',\n        flows: {\n          clientCredentials: {\n            tokenUrl: 'https://api.example.com/oauth/token',\n          },\n        },\n      },\n    })\n    expect(getOpenAuthTokenUrls(schema)).toEqual(['/oauth/token'])\n  })\n})\n\ndescribe('getPathFromUrl', () => {\n  it('returns the path from a valid URL', () => {\n    const url = 'https://api.example.com/oauth/token'\n    expect(getPathFromUrl(url)).toBe('/oauth/token')\n  })\n\n  it('handles URLs with query parameters', () => {\n    const url = 'https://api.example.com/oauth/token?param=value'\n    expect(getPathFromUrl(url)).toBe('/oauth/token')\n  })\n\n  it('handles URLs with fragments', () => {\n    const url = 'https://api.example.com/oauth/token#fragment'\n    expect(getPathFromUrl(url)).toBe('/oauth/token')\n  })\n\n  it('handles URLs without paths', () => {\n    const url = 'https://api.example.com'\n    expect(getPathFromUrl(url)).toBe('/')\n  })\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/utils/getOperations.d.ts

@@ -1,5 +1,5 @@
 import type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from '@scalar/openapi-types';
-import { type HttpMethod } from '../types.ts';
+import { type HttpMethod } from '../types.js';
 /**
  * Takes a dereferenced OpenAPI document and returns all operations.
  * Ignores other attributes, like summary, parameters, etc.

package/dist/utils/getOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOperations.d.ts","sourceRoot":"","sources":["../../src/utils/getOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEvF,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,YAAY,CAAA;AAEzD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,CAAC,EAAE,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,GAAG,WAAW,CAAC,cAAc,GACtF,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CAUvC"}
+{"version":3,"file":"getOperations.d.ts","sourceRoot":"","sources":["../../src/utils/getOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEvF,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,SAAS,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,CAAC,EAAE,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,GAAG,WAAW,CAAC,cAAc,GACtF,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CAUvC"}

package/dist/utils/getOperations.js

@@ -1,17 +1,14 @@
-import { httpMethods } from '../types.js';
-
-/**
- * Takes a dereferenced OpenAPI document and returns all operations.
- * Ignores other attributes, like summary, parameters, etc.
- */
+import { httpMethods } from "../types.js";
 function getOperations(path) {
-    const operations = {};
-    for (const method of httpMethods) {
-        if (path?.[method]) {
-            operations[method] = path?.[method];
-        }
+  const operations = {};
+  for (const method of httpMethods) {
+    if (path?.[method]) {
+      operations[method] = path?.[method];
     }
-    return operations;
+  }
+  return operations;
 }
-
-export { getOperations };
+export {
+  getOperations
+};
+//# sourceMappingURL=getOperations.js.map

package/dist/utils/getOperations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getOperations.ts"],
+  "sourcesContent": ["import type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from '@scalar/openapi-types'\n\nimport { type HttpMethod, httpMethods } from '@/types'\n\n/**\n * Takes a dereferenced OpenAPI document and returns all operations.\n * Ignores other attributes, like summary, parameters, etc.\n */\nexport function getOperations(\n  path?: OpenAPIV2.PathItemObject | OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject,\n): Record<HttpMethod, OpenAPI.Operation> {\n  const operations = {} as Record<HttpMethod, OpenAPI.Operation>\n\n  for (const method of httpMethods) {\n    if (path?.[method]) {\n      operations[method] = path?.[method]\n    }\n  }\n\n  return operations\n}\n"],
+  "mappings": "AAEA,SAA0B,mBAAmB;AAMtC,SAAS,cACd,MACuC;AACvC,QAAM,aAAa,CAAC;AAEpB,aAAW,UAAU,aAAa;AAChC,QAAI,OAAO,MAAM,GAAG;AAClB,iBAAW,MAAM,IAAI,OAAO,MAAM;AAAA,IACpC;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/utils/handleAuthentication.js

@@ -1,109 +1,103 @@
-import { getCookie } from 'hono/cookie';
-
-/**
- * Handles authentication for incoming requests based on the OpenAPI specification.
- */
+import { getCookie } from "hono/cookie";
 function handleAuthentication(schema, operation) {
-    return async (c, next) => {
-        const operationSecuritySchemes = operation?.security || schema?.security;
-        if (operationSecuritySchemes && operationSecuritySchemes.length > 0) {
-            let isAuthenticated = false;
-            let authScheme = '';
-            for (const securityRequirement of operationSecuritySchemes) {
-                let securitySchemeAuthenticated = true;
-                for (const [schemeName] of Object.entries(securityRequirement)) {
-                    const scheme = schema?.components?.securitySchemes?.[schemeName];
-                    if (scheme) {
-                        switch (scheme.type) {
-                            case 'http':
-                                if (scheme.scheme === 'basic') {
-                                    authScheme = 'Basic';
-                                    const authHeader = c.req.header('Authorization');
-                                    if (authHeader?.startsWith('Basic ')) {
-                                        isAuthenticated = true;
-                                    }
-                                }
-                                else if (scheme.scheme === 'bearer') {
-                                    authScheme = 'Bearer';
-                                    const authHeader = c.req.header('Authorization');
-                                    if (authHeader?.startsWith('Bearer ')) {
-                                        isAuthenticated = true;
-                                    }
-                                }
-                                break;
-                            case 'apiKey':
-                                authScheme = `ApiKey ${scheme.name}`;
-                                if (scheme.in === 'header') {
-                                    const apiKey = c.req.header(scheme.name);
-                                    if (apiKey) {
-                                        isAuthenticated = true;
-                                    }
-                                }
-                                else if (scheme.in === 'query') {
-                                    const apiKey = c.req.query(scheme.name);
-                                    if (apiKey) {
-                                        isAuthenticated = true;
-                                    }
-                                }
-                                else if (scheme.in === 'cookie') {
-                                    const apiKey = getCookie(c, scheme.name);
-                                    if (apiKey) {
-                                        isAuthenticated = true;
-                                    }
-                                }
-                                break;
-                            case 'oauth2':
-                                authScheme = 'Bearer';
-                                // Handle OAuth 2.0 flows, including password grant
-                                if (c.req.header('Authorization')?.startsWith('Bearer ')) {
-                                    isAuthenticated = true;
-                                }
-                                break;
-                            case 'openIdConnect':
-                                authScheme = 'Bearer';
-                                // Handle OpenID Connect similar to OAuth2
-                                if (c.req.header('Authorization')?.startsWith('Bearer ')) {
-                                    isAuthenticated = true;
-                                }
-                                break;
-                        }
-                    }
-                    if (!isAuthenticated) {
-                        securitySchemeAuthenticated = false;
-                        break;
-                    }
+  return async (c, next) => {
+    const operationSecuritySchemes = operation?.security || schema?.security;
+    if (operationSecuritySchemes && operationSecuritySchemes.length > 0) {
+      let isAuthenticated = false;
+      let authScheme = "";
+      for (const securityRequirement of operationSecuritySchemes) {
+        let securitySchemeAuthenticated = true;
+        for (const [schemeName] of Object.entries(securityRequirement)) {
+          const scheme = schema?.components?.securitySchemes?.[schemeName];
+          if (scheme) {
+            switch (scheme.type) {
+              case "http":
+                if (scheme.scheme === "basic") {
+                  authScheme = "Basic";
+                  const authHeader = c.req.header("Authorization");
+                  if (authHeader?.startsWith("Basic ")) {
+                    isAuthenticated = true;
+                  }
+                } else if (scheme.scheme === "bearer") {
+                  authScheme = "Bearer";
+                  const authHeader = c.req.header("Authorization");
+                  if (authHeader?.startsWith("Bearer ")) {
+                    isAuthenticated = true;
+                  }
                 }
-                if (securitySchemeAuthenticated) {
+                break;
+              case "apiKey":
+                authScheme = `ApiKey ${scheme.name}`;
+                if (scheme.in === "header") {
+                  const apiKey = c.req.header(scheme.name);
+                  if (apiKey) {
+                    isAuthenticated = true;
+                  }
+                } else if (scheme.in === "query") {
+                  const apiKey = c.req.query(scheme.name);
+                  if (apiKey) {
+                    isAuthenticated = true;
+                  }
+                } else if (scheme.in === "cookie") {
+                  const apiKey = getCookie(c, scheme.name);
+                  if (apiKey) {
                     isAuthenticated = true;
-                    break;
+                  }
                 }
-            }
-            if (!isAuthenticated) {
-                let wwwAuthenticateValue = authScheme;
-                switch (authScheme) {
-                    case 'Basic':
-                        wwwAuthenticateValue += ' realm="Scalar Mock Server", charset="UTF-8"';
-                        break;
-                    case 'Bearer':
-                        wwwAuthenticateValue +=
-                            ' realm="Scalar Mock Server", error="invalid_token", error_description="The access token is invalid or has expired"';
-                        break;
-                    case 'ApiKey':
-                        wwwAuthenticateValue += ` realm="Scalar Mock Server", error="invalid_token", error_description="Invalid or missing API key"`;
-                        break;
-                    default:
-                        wwwAuthenticateValue = 'Bearer realm="Scalar Mock Server"';
+                break;
+              case "oauth2":
+                authScheme = "Bearer";
+                if (c.req.header("Authorization")?.startsWith("Bearer ")) {
+                  isAuthenticated = true;
+                }
+                break;
+              case "openIdConnect":
+                authScheme = "Bearer";
+                if (c.req.header("Authorization")?.startsWith("Bearer ")) {
+                  isAuthenticated = true;
                 }
-                c.header('WWW-Authenticate', wwwAuthenticateValue);
-                return c.json({
-                    error: 'Unauthorized',
-                    message: 'Authentication is required to access this resource.',
-                }, 401);
+                break;
             }
+          }
+          if (!isAuthenticated) {
+            securitySchemeAuthenticated = false;
+            break;
+          }
+        }
+        if (securitySchemeAuthenticated) {
+          isAuthenticated = true;
+          break;
+        }
+      }
+      if (!isAuthenticated) {
+        let wwwAuthenticateValue = authScheme;
+        switch (authScheme) {
+          case "Basic":
+            wwwAuthenticateValue += ' realm="Scalar Mock Server", charset="UTF-8"';
+            break;
+          case "Bearer":
+            wwwAuthenticateValue += ' realm="Scalar Mock Server", error="invalid_token", error_description="The access token is invalid or has expired"';
+            break;
+          case "ApiKey":
+            wwwAuthenticateValue += ` realm="Scalar Mock Server", error="invalid_token", error_description="Invalid or missing API key"`;
+            break;
+          default:
+            wwwAuthenticateValue = 'Bearer realm="Scalar Mock Server"';
         }
-        // If all checks pass, continue to the next middleware
-        await next();
-    };
+        c.header("WWW-Authenticate", wwwAuthenticateValue);
+        return c.json(
+          {
+            error: "Unauthorized",
+            message: "Authentication is required to access this resource."
+          },
+          401
+        );
+      }
+    }
+    await next();
+  };
 }
-
-export { handleAuthentication };
+export {
+  handleAuthentication
+};
+//# sourceMappingURL=handleAuthentication.js.map

package/dist/utils/handleAuthentication.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/handleAuthentication.ts"],
+  "sourcesContent": ["import type { OpenAPI } from '@scalar/openapi-types'\nimport type { Context } from 'hono'\nimport { getCookie } from 'hono/cookie'\n\n/**\n * Handles authentication for incoming requests based on the OpenAPI specification.\n */\nexport function handleAuthentication(schema?: OpenAPI.Document, operation?: OpenAPI.Operation) {\n  return async (c: Context, next: () => Promise<void>): Promise<Response | void> => {\n    const operationSecuritySchemes = operation?.security || schema?.security\n\n    if (operationSecuritySchemes && operationSecuritySchemes.length > 0) {\n      let isAuthenticated = false\n      let authScheme = ''\n\n      for (const securityRequirement of operationSecuritySchemes) {\n        let securitySchemeAuthenticated = true\n\n        for (const [schemeName] of Object.entries(securityRequirement)) {\n          const scheme = schema?.components?.securitySchemes?.[schemeName]\n\n          if (scheme) {\n            switch (scheme.type) {\n              case 'http':\n                if (scheme.scheme === 'basic') {\n                  authScheme = 'Basic'\n                  const authHeader = c.req.header('Authorization')\n\n                  if (authHeader?.startsWith('Basic ')) {\n                    isAuthenticated = true\n                  }\n                } else if (scheme.scheme === 'bearer') {\n                  authScheme = 'Bearer'\n                  const authHeader = c.req.header('Authorization')\n\n                  if (authHeader?.startsWith('Bearer ')) {\n                    isAuthenticated = true\n                  }\n                }\n                break\n              case 'apiKey':\n                authScheme = `ApiKey ${scheme.name}`\n\n                if (scheme.in === 'header') {\n                  const apiKey = c.req.header(scheme.name)\n                  if (apiKey) {\n                    isAuthenticated = true\n                  }\n                } else if (scheme.in === 'query') {\n                  const apiKey = c.req.query(scheme.name)\n\n                  if (apiKey) {\n                    isAuthenticated = true\n                  }\n                } else if (scheme.in === 'cookie') {\n                  const apiKey = getCookie(c, scheme.name)\n\n                  if (apiKey) {\n                    isAuthenticated = true\n                  }\n                }\n                break\n              case 'oauth2':\n                authScheme = 'Bearer'\n                // Handle OAuth 2.0 flows, including password grant\n                if (c.req.header('Authorization')?.startsWith('Bearer ')) {\n                  isAuthenticated = true\n                }\n                break\n              case 'openIdConnect':\n                authScheme = 'Bearer'\n                // Handle OpenID Connect similar to OAuth2\n                if (c.req.header('Authorization')?.startsWith('Bearer ')) {\n                  isAuthenticated = true\n                }\n                break\n            }\n          }\n\n          if (!isAuthenticated) {\n            securitySchemeAuthenticated = false\n            break\n          }\n        }\n\n        if (securitySchemeAuthenticated) {\n          isAuthenticated = true\n          break\n        }\n      }\n\n      if (!isAuthenticated) {\n        let wwwAuthenticateValue = authScheme\n\n        switch (authScheme) {\n          case 'Basic':\n            wwwAuthenticateValue += ' realm=\"Scalar Mock Server\", charset=\"UTF-8\"'\n            break\n          case 'Bearer':\n            wwwAuthenticateValue +=\n              ' realm=\"Scalar Mock Server\", error=\"invalid_token\", error_description=\"The access token is invalid or has expired\"'\n            break\n          case 'ApiKey':\n            wwwAuthenticateValue += ` realm=\"Scalar Mock Server\", error=\"invalid_token\", error_description=\"Invalid or missing API key\"`\n            break\n          default:\n            wwwAuthenticateValue = 'Bearer realm=\"Scalar Mock Server\"'\n        }\n\n        c.header('WWW-Authenticate', wwwAuthenticateValue)\n        return c.json(\n          {\n            error: 'Unauthorized',\n            message: 'Authentication is required to access this resource.',\n          },\n          401,\n        )\n      }\n    }\n\n    // If all checks pass, continue to the next middleware\n    await next()\n  }\n}\n"],
+  "mappings": "AAEA,SAAS,iBAAiB;AAKnB,SAAS,qBAAqB,QAA2B,WAA+B;AAC7F,SAAO,OAAO,GAAY,SAAwD;AAChF,UAAM,2BAA2B,WAAW,YAAY,QAAQ;AAEhE,QAAI,4BAA4B,yBAAyB,SAAS,GAAG;AACnE,UAAI,kBAAkB;AACtB,UAAI,aAAa;AAEjB,iBAAW,uBAAuB,0BAA0B;AAC1D,YAAI,8BAA8B;AAElC,mBAAW,CAAC,UAAU,KAAK,OAAO,QAAQ,mBAAmB,GAAG;AAC9D,gBAAM,SAAS,QAAQ,YAAY,kBAAkB,UAAU;AAE/D,cAAI,QAAQ;AACV,oBAAQ,OAAO,MAAM;AAAA,cACnB,KAAK;AACH,oBAAI,OAAO,WAAW,SAAS;AAC7B,+BAAa;AACb,wBAAM,aAAa,EAAE,IAAI,OAAO,eAAe;AAE/C,sBAAI,YAAY,WAAW,QAAQ,GAAG;AACpC,sCAAkB;AAAA,kBACpB;AAAA,gBACF,WAAW,OAAO,WAAW,UAAU;AACrC,+BAAa;AACb,wBAAM,aAAa,EAAE,IAAI,OAAO,eAAe;AAE/C,sBAAI,YAAY,WAAW,SAAS,GAAG;AACrC,sCAAkB;AAAA,kBACpB;AAAA,gBACF;AACA;AAAA,cACF,KAAK;AACH,6BAAa,UAAU,OAAO,IAAI;AAElC,oBAAI,OAAO,OAAO,UAAU;AAC1B,wBAAM,SAAS,EAAE,IAAI,OAAO,OAAO,IAAI;AACvC,sBAAI,QAAQ;AACV,sCAAkB;AAAA,kBACpB;AAAA,gBACF,WAAW,OAAO,OAAO,SAAS;AAChC,wBAAM,SAAS,EAAE,IAAI,MAAM,OAAO,IAAI;AAEtC,sBAAI,QAAQ;AACV,sCAAkB;AAAA,kBACpB;AAAA,gBACF,WAAW,OAAO,OAAO,UAAU;AACjC,wBAAM,SAAS,UAAU,GAAG,OAAO,IAAI;AAEvC,sBAAI,QAAQ;AACV,sCAAkB;AAAA,kBACpB;AAAA,gBACF;AACA;AAAA,cACF,KAAK;AACH,6BAAa;AAEb,oBAAI,EAAE,IAAI,OAAO,eAAe,GAAG,WAAW,SAAS,GAAG;AACxD,oCAAkB;AAAA,gBACpB;AACA;AAAA,cACF,KAAK;AACH,6BAAa;AAEb,oBAAI,EAAE,IAAI,OAAO,eAAe,GAAG,WAAW,SAAS,GAAG;AACxD,oCAAkB;AAAA,gBACpB;AACA;AAAA,YACJ;AAAA,UACF;AAEA,cAAI,CAAC,iBAAiB;AACpB,0CAA8B;AAC9B;AAAA,UACF;AAAA,QACF;AAEA,YAAI,6BAA6B;AAC/B,4BAAkB;AAClB;AAAA,QACF;AAAA,MACF;AAEA,UAAI,CAAC,iBAAiB;AACpB,YAAI,uBAAuB;AAE3B,gBAAQ,YAAY;AAAA,UAClB,KAAK;AACH,oCAAwB;AACxB;AAAA,UACF,KAAK;AACH,oCACE;AACF;AAAA,UACF,KAAK;AACH,oCAAwB;AACxB;AAAA,UACF;AACE,mCAAuB;AAAA,QAC3B;AAEA,UAAE,OAAO,oBAAoB,oBAAoB;AACjD,eAAO,EAAE;AAAA,UACP;AAAA,YACE,OAAO;AAAA,YACP,SAAS;AAAA,UACX;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAGA,UAAM,KAAK;AAAA,EACb;AACF;",
+  "names": []
+}

package/dist/utils/honoRouteFromPath.js

@@ -1,9 +1,7 @@
-/**
- * Convert path to route
- * Example: /posts/{id} -> /posts/:id
- */
 function honoRouteFromPath(path) {
-    return path.replace(/{/g, ':').replace(/}/g, '');
+  return path.replace(/{/g, ":").replace(/}/g, "");
 }
-
-export { honoRouteFromPath };
+export {
+  honoRouteFromPath
+};
+//# sourceMappingURL=honoRouteFromPath.js.map

package/dist/utils/honoRouteFromPath.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/honoRouteFromPath.ts"],
+  "sourcesContent": ["/**\n * Convert path to route\n * Example: /posts/{id} -> /posts/:id\n */\nexport function honoRouteFromPath(path: string) {\n  return path.replace(/{/g, ':').replace(/}/g, '')\n}\n"],
+  "mappings": "AAIO,SAAS,kBAAkB,MAAc;AAC9C,SAAO,KAAK,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,EAAE;AACjD;",
+  "names": []
+}

package/dist/utils/honoRouteFromPath.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { honoRouteFromPath } from "./honoRouteFromPath.js";
+describe("honoRouteFromPath", () => {
+  it("returns correct route for a simple path", () => {
+    expect(honoRouteFromPath("/foobar")).toBe("/foobar");
+  });
+  it("returns correct route for a path with an ID", () => {
+    expect(honoRouteFromPath("/foobar/{id}")).toBe("/foobar/:id");
+  });
+  it("returns correct route for a path with multiple parameters", () => {
+    expect(honoRouteFromPath("/users/{userId}/posts/{postId}")).toBe("/users/:userId/posts/:postId");
+  });
+  it("returns correct route for a path with a parameter in the middle", () => {
+    expect(honoRouteFromPath("/api/{version}/users")).toBe("/api/:version/users");
+  });
+  it("returns correct route for a path with special characters", () => {
+    expect(honoRouteFromPath("/items/{item-id}")).toBe("/items/:item-id");
+  });
+  it("returns correct route for a path with numbers", () => {
+    expect(honoRouteFromPath("/v1/products/{productId}")).toBe("/v1/products/:productId");
+  });
+  it.skip("handles invalid parameter syntax gracefully", () => {
+    expect(() => honoRouteFromPath("/{invalid{}param}")).toThrow();
+  });
+  it("handles multiple consecutive parameters", () => {
+    expect(honoRouteFromPath("/users/{userId}{postId}")).toBe("/users/:userId:postId");
+  });
+  it("handles parameters with special naming patterns", () => {
+    expect(honoRouteFromPath("/api/{api.version}/{user_id}")).toBe("/api/:api.version/:user_id");
+  });
+});
+//# sourceMappingURL=honoRouteFromPath.test.js.map

package/dist/utils/honoRouteFromPath.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/honoRouteFromPath.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from 'vitest'\n\nimport { honoRouteFromPath } from './honoRouteFromPath'\n\ndescribe('honoRouteFromPath', () => {\n  it('returns correct route for a simple path', () => {\n    expect(honoRouteFromPath('/foobar')).toBe('/foobar')\n  })\n\n  it('returns correct route for a path with an ID', () => {\n    expect(honoRouteFromPath('/foobar/{id}')).toBe('/foobar/:id')\n  })\n\n  it('returns correct route for a path with multiple parameters', () => {\n    expect(honoRouteFromPath('/users/{userId}/posts/{postId}')).toBe('/users/:userId/posts/:postId')\n  })\n\n  it('returns correct route for a path with a parameter in the middle', () => {\n    expect(honoRouteFromPath('/api/{version}/users')).toBe('/api/:version/users')\n  })\n\n  it('returns correct route for a path with special characters', () => {\n    expect(honoRouteFromPath('/items/{item-id}')).toBe('/items/:item-id')\n  })\n\n  it('returns correct route for a path with numbers', () => {\n    expect(honoRouteFromPath('/v1/products/{productId}')).toBe('/v1/products/:productId')\n  })\n\n  it.skip('handles invalid parameter syntax gracefully', () => {\n    expect(() => honoRouteFromPath('/{invalid{}param}')).toThrow()\n  })\n\n  it('handles multiple consecutive parameters', () => {\n    expect(honoRouteFromPath('/users/{userId}{postId}')).toBe('/users/:userId:postId')\n  })\n\n  it('handles parameters with special naming patterns', () => {\n    expect(honoRouteFromPath('/api/{api.version}/{user_id}')).toBe('/api/:api.version/:user_id')\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,UAAU,QAAQ,UAAU;AAErC,SAAS,yBAAyB;AAElC,SAAS,qBAAqB,MAAM;AAClC,KAAG,2CAA2C,MAAM;AAClD,WAAO,kBAAkB,SAAS,CAAC,EAAE,KAAK,SAAS;AAAA,EACrD,CAAC;AAED,KAAG,+CAA+C,MAAM;AACtD,WAAO,kBAAkB,cAAc,CAAC,EAAE,KAAK,aAAa;AAAA,EAC9D,CAAC;AAED,KAAG,6DAA6D,MAAM;AACpE,WAAO,kBAAkB,gCAAgC,CAAC,EAAE,KAAK,8BAA8B;AAAA,EACjG,CAAC;AAED,KAAG,mEAAmE,MAAM;AAC1E,WAAO,kBAAkB,sBAAsB,CAAC,EAAE,KAAK,qBAAqB;AAAA,EAC9E,CAAC;AAED,KAAG,4DAA4D,MAAM;AACnE,WAAO,kBAAkB,kBAAkB,CAAC,EAAE,KAAK,iBAAiB;AAAA,EACtE,CAAC;AAED,KAAG,iDAAiD,MAAM;AACxD,WAAO,kBAAkB,0BAA0B,CAAC,EAAE,KAAK,yBAAyB;AAAA,EACtF,CAAC;AAED,KAAG,KAAK,+CAA+C,MAAM;AAC3D,WAAO,MAAM,kBAAkB,mBAAmB,CAAC,EAAE,QAAQ;AAAA,EAC/D,CAAC;AAED,KAAG,2CAA2C,MAAM;AAClD,WAAO,kBAAkB,yBAAyB,CAAC,EAAE,KAAK,uBAAuB;AAAA,EACnF,CAAC;AAED,KAAG,mDAAmD,MAAM;AAC1D,WAAO,kBAAkB,8BAA8B,CAAC,EAAE,KAAK,4BAA4B;AAAA,EAC7F,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/utils/isAuthenticationRequired.js

@@ -1,20 +1,16 @@
-/**
- * Check whether the given security scheme key is in the `security` configuration for this operation.
- */
 function isAuthenticationRequired(security) {
-    // If security is not defined, auth is not required.
-    if (!security) {
-        return false;
-    }
-    // Don’t require auth if security is just an empty array []
-    if (Array.isArray(security) && !security.length) {
-        return false;
-    }
-    // Includes empty object = auth is not required
-    if ((security ?? []).some((securityRequirement) => !Object.keys(securityRequirement).length)) {
-        return false;
-    }
-    return true;
+  if (!security) {
+    return false;
+  }
+  if (Array.isArray(security) && !security.length) {
+    return false;
+  }
+  if ((security ?? []).some((securityRequirement) => !Object.keys(securityRequirement).length)) {
+    return false;
+  }
+  return true;
 }
-
-export { isAuthenticationRequired };
+export {
+  isAuthenticationRequired
+};
+//# sourceMappingURL=isAuthenticationRequired.js.map