@scalar/mock-server 0.9.8 → 0.9.10

package/dist/utils/build-handler-context.js

@@ -1,75 +1,88 @@
-import { faker } from "@faker-js/faker";
-import { getExampleFromSchema } from "@scalar/oas-utils/spec-getters";
-import { accepts } from "hono/accepts";
-import { store } from "../libs/store.js";
-import { createStoreWrapper } from "./store-wrapper.js";
+import { faker } from '@faker-js/faker';
+import { getExampleFromSchema } from '@scalar/oas-utils/spec-getters';
+import { accepts } from 'hono/accepts';
+import { store } from '../libs/store.js';
+import { createStoreWrapper } from './store-wrapper.js';
+/**
+ * Get example response from OpenAPI spec for a given status code.
+ * Returns the example value if found, or null if not available.
+ */
 function getExampleFromResponse(c, statusCode, responses) {
-  if (!responses) {
-    return null;
-  }
-  const response = responses[statusCode] || responses.default;
-  if (!response) {
-    return null;
-  }
-  const supportedContentTypes = Object.keys(response.content ?? {});
-  if (supportedContentTypes.length === 0) {
-    return null;
-  }
-  const acceptedContentType = accepts(c, {
-    header: "Accept",
-    supports: supportedContentTypes,
-    default: supportedContentTypes.includes("application/json") ? "application/json" : supportedContentTypes[0] ?? "text/plain;charset=UTF-8"
-  });
-  const acceptedResponse = response.content?.[acceptedContentType];
-  if (!acceptedResponse) {
-    return null;
-  }
-  return acceptedResponse.example !== void 0 ? acceptedResponse.example : acceptedResponse.schema ? getExampleFromSchema(acceptedResponse.schema, {
-    emptyString: "string",
-    variables: c.req.param(),
-    mode: "read"
-  }) : null;
+    if (!responses) {
+        return null;
+    }
+    const response = responses[statusCode] || responses.default;
+    if (!response) {
+        return null;
+    }
+    const supportedContentTypes = Object.keys(response.content ?? {});
+    // If no content types are defined, return null
+    if (supportedContentTypes.length === 0) {
+        return null;
+    }
+    // Content-Type negotiation - prefer application/json
+    const acceptedContentType = accepts(c, {
+        header: 'Accept',
+        supports: supportedContentTypes,
+        default: supportedContentTypes.includes('application/json')
+            ? 'application/json'
+            : (supportedContentTypes[0] ?? 'text/plain;charset=UTF-8'),
+    });
+    const acceptedResponse = response.content?.[acceptedContentType];
+    if (!acceptedResponse) {
+        return null;
+    }
+    // Extract example from example property or generate from schema
+    return acceptedResponse.example !== undefined
+        ? acceptedResponse.example
+        : acceptedResponse.schema
+            ? getExampleFromSchema(acceptedResponse.schema, {
+                emptyString: 'string',
+                variables: c.req.param(),
+                mode: 'read',
+            })
+            : null;
 }
-async function buildHandlerContext(c, operation) {
-  let body = void 0;
-  try {
-    const contentType = c.req.header("content-type") ?? "";
-    if (contentType.includes("application/json")) {
-      body = await c.req.json().catch(() => void 0);
-    } else if (contentType.includes("application/x-www-form-urlencoded")) {
-      body = await c.req.parseBody().catch(() => void 0);
-    } else if (contentType.includes("text/")) {
-      body = await c.req.text().catch(() => void 0);
+/**
+ * Build the handler context from a Hono context.
+ */
+export async function buildHandlerContext(c, operation) {
+    let body = undefined;
+    try {
+        const contentType = c.req.header('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            body = await c.req.json().catch(() => undefined);
+        }
+        else if (contentType.includes('application/x-www-form-urlencoded')) {
+            body = await c.req.parseBody().catch(() => undefined);
+        }
+        else if (contentType.includes('text/')) {
+            body = await c.req.text().catch(() => undefined);
+        }
+    }
+    catch {
+        // Ignore parsing errors, body remains undefined
     }
-  } catch {
-  }
-  const { wrappedStore, tracking } = createStoreWrapper(store);
-  const res = {};
-  if (operation?.responses) {
-    for (const statusCode of Object.keys(operation.responses)) {
-      res[statusCode] = getExampleFromResponse(
-        c,
-        statusCode,
-        operation.responses
-      );
+    const { wrappedStore, tracking } = createStoreWrapper(store);
+    // Build res object with examples for all response status codes
+    const res = {};
+    if (operation?.responses) {
+        for (const statusCode of Object.keys(operation.responses)) {
+            res[statusCode] = getExampleFromResponse(c, statusCode, operation.responses);
+        }
     }
-  }
-  return {
-    context: {
-      store: wrappedStore,
-      faker,
-      req: {
-        body,
-        params: c.req.param(),
-        query: Object.fromEntries(new URL(c.req.url).searchParams.entries()),
-        headers: Object.fromEntries(Object.entries(c.req.header()).map(([key, value]) => [key, value ?? ""]))
-      },
-      res
-    },
-    tracking
-  };
+    return {
+        context: {
+            store: wrappedStore,
+            faker,
+            req: {
+                body,
+                params: c.req.param(),
+                query: Object.fromEntries(new URL(c.req.url).searchParams.entries()),
+                headers: Object.fromEntries(Object.entries(c.req.header()).map(([key, value]) => [key, value ?? ''])),
+            },
+            res,
+        },
+        tracking,
+    };
 }
-export {
-  buildHandlerContext
-};
-//# sourceMappingURL=build-handler-context.js.map

package/dist/utils/build-seed-context.js

@@ -1,53 +1,60 @@
-import { faker } from "@faker-js/faker";
-import { store } from "../libs/store.js";
-import { createStoreWrapper } from "./store-wrapper.js";
-function buildSeedContext(schemaKey) {
-  const { wrappedStore } = createStoreWrapper(store);
-  const seedHelper = (arg1, arg2) => {
-    if (typeof arg1 === "number" && typeof arg2 === "function") {
-      const count = arg1;
-      const factory = arg2;
-      const items = [];
-      for (let i = 0; i < count; i++) {
-        const item = factory();
-        const created = wrappedStore.create(schemaKey, item);
-        items.push(created);
-      }
-      return items;
-    }
-    if (Array.isArray(arg1)) {
-      const items = [];
-      for (const item of arg1) {
-        const created = wrappedStore.create(schemaKey, item);
-        items.push(created);
-      }
-      return items;
-    }
-    if (typeof arg1 === "function") {
-      const factory = arg1;
-      const item = factory();
-      const created = wrappedStore.create(schemaKey, item);
-      return created;
-    }
-    throw new Error("Invalid seed() usage. Use seed.count(n, factory), seed(array), or seed(factory)");
-  };
-  seedHelper.count = (n, factory) => {
-    const items = [];
-    for (let i = 0; i < n; i++) {
-      const item = factory();
-      const created = wrappedStore.create(schemaKey, item);
-      items.push(created);
-    }
-    return items;
-  };
-  return {
-    store: wrappedStore,
-    faker,
-    seed: seedHelper,
-    schema: schemaKey
-  };
+import { faker } from '@faker-js/faker';
+import { store } from '../libs/store.js';
+import { createStoreWrapper } from './store-wrapper.js';
+/**
+ * Build the seed context with a seed helper function.
+ * The seed helper automatically uses the schema key as the collection name.
+ */
+export function buildSeedContext(schemaKey) {
+    const { wrappedStore } = createStoreWrapper(store);
+    /**
+     * Seed helper function that provides a Laravel-inspired API.
+     */
+    const seedHelper = ((arg1, arg2) => {
+        // Case 1: seed.count(n, factory)
+        if (typeof arg1 === 'number' && typeof arg2 === 'function') {
+            const count = arg1;
+            const factory = arg2;
+            const items = [];
+            for (let i = 0; i < count; i++) {
+                const item = factory();
+                const created = wrappedStore.create(schemaKey, item);
+                items.push(created);
+            }
+            return items;
+        }
+        // Case 2: seed(array)
+        if (Array.isArray(arg1)) {
+            const items = [];
+            for (const item of arg1) {
+                const created = wrappedStore.create(schemaKey, item);
+                items.push(created);
+            }
+            return items;
+        }
+        // Case 3: seed(factory) - single item
+        if (typeof arg1 === 'function') {
+            const factory = arg1;
+            const item = factory();
+            const created = wrappedStore.create(schemaKey, item);
+            return created;
+        }
+        throw new Error('Invalid seed() usage. Use seed.count(n, factory), seed(array), or seed(factory)');
+    });
+    // Add count method to the function
+    seedHelper.count = (n, factory) => {
+        const items = [];
+        for (let i = 0; i < n; i++) {
+            const item = factory();
+            const created = wrappedStore.create(schemaKey, item);
+            items.push(created);
+        }
+        return items;
+    };
+    return {
+        store: wrappedStore,
+        faker,
+        seed: seedHelper,
+        schema: schemaKey,
+    };
 }
-export {
-  buildSeedContext
-};
-//# sourceMappingURL=build-seed-context.js.map

package/dist/utils/create-openapi-definition.js

@@ -1,11 +1,8 @@
-function createOpenApiDefinition(securitySchemes) {
-  return {
-    openapi: "3.1.1",
-    info: { title: "Test API", version: "1.0.0" },
-    components: { securitySchemes }
-  };
+/** Helper function create an OpenAPI document with security schemss */
+export function createOpenApiDefinition(securitySchemes) {
+    return {
+        openapi: '3.1.1',
+        info: { title: 'Test API', version: '1.0.0' },
+        components: { securitySchemes },
+    };
 }
-export {
-  createOpenApiDefinition
-};
-//# sourceMappingURL=create-openapi-definition.js.map

package/dist/utils/execute-handler.js

@@ -1,20 +1,18 @@
-async function executeHandler(code, context) {
-  const handlerFunction = new Function(
-    "store",
-    "faker",
-    "req",
-    "res",
-    `
+/**
+ * Execute handler code in a sandboxed environment.
+ * The code has access only to the provided context (store, faker, req, res).
+ */
+export async function executeHandler(code, context) {
+    // Create a function that executes the handler code with the context
+    // Using Function constructor to create a sandboxed environment
+    // The code is wrapped in a function body that returns the result
+    const handlerFunction = new Function('store', 'faker', 'req', 'res', `
     ${code}
-  `
-  );
-  const result = handlerFunction(context.store, context.faker, context.req, context.res);
-  if (result instanceof Promise) {
-    return { result: await result };
-  }
-  return { result };
+  `);
+    const result = handlerFunction(context.store, context.faker, context.req, context.res);
+    // If the result is a Promise, await it
+    if (result instanceof Promise) {
+        return { result: await result };
+    }
+    return { result };
 }
-export {
-  executeHandler
-};
-//# sourceMappingURL=execute-handler.js.map

package/dist/utils/execute-seed.js

@@ -1,24 +1,25 @@
-async function executeSeed(code, context) {
-  const seedFunction = new Function(
-    "store",
-    "faker",
-    "seed",
-    "schema",
-    `
+/**
+ * Execute seed code in a sandboxed environment.
+ * The code has access only to the provided context (store, faker, seed, schema).
+ */
+export async function executeSeed(code, context) {
+    // Create a function that executes the seed code with the context
+    // Using Function constructor to create a sandboxed environment
+    // The code is wrapped in a function body that returns the result
+    const seedFunction = new Function('store', 'faker', 'seed', 'schema', `
     ${code}
-  `
-  );
-  try {
-    const result = seedFunction(context.store, context.faker, context.seed, context.schema);
-    if (result instanceof Promise) {
-      return { result: await result };
+  `);
+    // Execute the seed function with the context
+    try {
+        const result = seedFunction(context.store, context.faker, context.seed, context.schema);
+        // If the result is a Promise, await it
+        if (result instanceof Promise) {
+            return { result: await result };
+        }
+        return { result };
+    }
+    catch (error) {
+        // Re-throw to be caught by the caller
+        throw error;
     }
-    return { result };
-  } catch (error) {
-    throw error;
-  }
 }
-export {
-  executeSeed
-};
-//# sourceMappingURL=execute-seed.js.map

package/dist/utils/find-preferred-response-key.js

@@ -1,11 +1,11 @@
-function findPreferredResponseKey(responses) {
-  return (
+/**
+ * Find the preferred response key: default, 200, 201 …
+ */
+export function findPreferredResponseKey(responses) {
+    return (
     // Regular status codes
-    ["default", "200", "201", "204", "404", "500"].find((key) => responses?.includes(key) ?? false) ?? // Lowest status code
-    responses?.sort()[0] ?? void 0
-  );
+    ['default', '200', '201', '204', '404', '500'].find((key) => responses?.includes(key) ?? false) ??
+        // Lowest status code
+        responses?.sort()[0] ??
+        undefined);
 }
-export {
-  findPreferredResponseKey
-};
-//# sourceMappingURL=find-preferred-response-key.js.map

package/dist/utils/get-open-auth-token-urls.js

@@ -1,42 +1,52 @@
-function getPathFromUrl(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;
-  }
+/**
+ * Extract path from URL
+ */
+export 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;
+    }
 }
+/**
+ * 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;
-  const tokenUrls = /* @__PURE__ */ new Set();
-  for (const scheme of Object.values(securitySchemes)) {
-    if (!isOAuth2Scheme(scheme)) {
-      continue;
+export 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);
     }
-    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);
+    return Array.from(tokenUrls);
 }
-export {
-  getOpenAuthTokenUrls,
-  getPathFromUrl
-};
-//# sourceMappingURL=get-open-auth-token-urls.js.map

package/dist/utils/get-operation.js

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