api-json-server 1.1.0 → 1.2.0

package/dist/behavior.js

@@ -1,8 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDelay = resolveDelay;
 exports.sleep = sleep;
 exports.shouldFail = shouldFail;
 exports.resolveBehavior = resolveBehavior;
+const faker_1 = require("@faker-js/faker");
+/**
+ * Resolve a delay value from either a number or a range configuration.
+ */
+function resolveDelay(delay) {
+    if (!delay)
+        return 0;
+    if (typeof delay === "number")
+        return delay;
+    return faker_1.faker.number.int({ min: delay.min, max: delay.max });
+}
 /**
  * Pause for the given number of milliseconds.
  */

package/dist/history/historyRecorder.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryRecorder = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * In-memory request history recorder.
+ */
+class HistoryRecorder {
+    entries = [];
+    maxEntries;
+    /**
+     * Create a new history recorder.
+     * @param maxEntries Maximum number of entries to keep (default 1000).
+     */
+    constructor(maxEntries = 1000) {
+        this.maxEntries = maxEntries;
+    }
+    /**
+     * Record a new request.
+     */
+    record(entry) {
+        const fullEntry = {
+            id: (0, node_crypto_1.randomUUID)(),
+            timestamp: new Date().toISOString(),
+            ...entry
+        };
+        this.entries.push(fullEntry);
+        // Keep only the most recent entries
+        if (this.entries.length > this.maxEntries) {
+            this.entries.shift();
+        }
+        return fullEntry;
+    }
+    /**
+     * Get all history entries, optionally filtered.
+     */
+    query(filter) {
+        let results = this.entries;
+        if (filter?.endpoint) {
+            results = results.filter((e) => e.path === filter.endpoint);
+        }
+        if (filter?.method) {
+            results = results.filter((e) => e.method.toUpperCase() === filter.method?.toUpperCase());
+        }
+        if (filter?.statusCode !== undefined) {
+            results = results.filter((e) => e.statusCode === filter.statusCode);
+        }
+        if (filter?.limit && filter.limit > 0) {
+            results = results.slice(-filter.limit);
+        }
+        return results;
+    }
+    /**
+     * Clear all history entries.
+     */
+    clear() {
+        this.entries = [];
+    }
+    /**
+     * Get the total number of recorded entries.
+     */
+    count() {
+        return this.entries.length;
+    }
+}
+exports.HistoryRecorder = HistoryRecorder;

package/dist/history/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const node_fs_1 = require("node:fs");
+const customLogger_js_1 = require("./logger/customLogger.js");
 const program = new commander_1.Command();
 program
     .name("mockserve")
@@ -16,6 +17,8 @@ program
     .option("--watch", "Reload when spec file changes", true)
     .option("--no-watch", "Disable reload when spec file changes")
     .option("--base-url <url>", "Public base URL used in OpenAPI servers[] (e.g. https://example.com)")
+    .option("--log-format <format>", "Log format: pretty or json", "pretty")
+    .option("--log-level <level>", "Log level: trace, debug, info, warn, error, fatal", "info")
     .action(async (opts) => {
     await startCommand(opts);
 });
@@ -29,6 +32,16 @@ async function startCommand(opts) {
         process.exit(1);
     }
     const specPath = opts.spec;
+    // Create logger based on CLI options
+    const logFormat = opts.logFormat === "json" ? "json" : "pretty";
+    const logLevel = ["trace", "debug", "info", "warn", "error", "fatal"].includes(opts.logLevel)
+        ? opts.logLevel
+        : "info";
+    const logger = (0, customLogger_js_1.createLogger)({
+        enabled: true,
+        format: logFormat,
+        level: logLevel
+    });
     const { loadSpecFromFile } = await import("./loadSpec.js");
     const { buildServer } = await import("./server.js");
     let app = null;
@@ -40,8 +53,8 @@ async function startCommand(opts) {
     async function startWithSpec() {
         const loadedAt = new Date().toISOString();
         const spec = await loadSpecFromFile(specPath);
-        console.log(`Loaded spec v${spec.version} with ${spec.endpoints.length} endpoint(s).`);
-        const nextApp = buildServer(spec, { specPath, loadedAt, baseUrl: opts.baseUrl });
+        logger.info(`Loaded spec v${spec.version} with ${spec.endpoints.length} endpoint(s).`);
+        const nextApp = buildServer(spec, { specPath, loadedAt, baseUrl: opts.baseUrl, logger: true });
         try {
             await nextApp.listen({ port, host: "0.0.0.0" });
         }
@@ -49,8 +62,7 @@ async function startCommand(opts) {
             nextApp.log.error(err);
             throw err;
         }
-        nextApp.log.info(`Mock server running on http://localhost:${port}`);
-        nextApp.log.info(`Spec: ${specPath} (loadedAt=${loadedAt})`);
+        (0, customLogger_js_1.logServerStart)(nextApp.log, port, specPath);
         return nextApp;
     }
     /**
@@ -61,33 +73,32 @@ async function startCommand(opts) {
             return;
         isReloading = true;
         try {
-            console.log("Reloading spec...");
+            logger.info("Reloading spec...");
             // 1) Stop accepting requests on the old server FIRST
             if (app) {
-                console.log("Closing current server...");
+                logger.debug("Closing current server...");
                 await app.close();
-                console.log("Current server closed.");
+                logger.debug("Current server closed.");
                 app = null;
             }
             // 2) Start a new server on the same port with the updated spec
             app = await startWithSpec();
-            console.log("Reload complete.");
+            (0, customLogger_js_1.logServerReload)(logger, true);
         }
         catch (err) {
-            console.error("Reload failed.");
-            // At this point the old server may already be closed. We want visibility.
-            console.error(String(err));
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            (0, customLogger_js_1.logServerReload)(logger, false, errorMsg);
             // Optional: try to start again to avoid being down
             try {
                 if (!app) {
-                    console.log("Attempting to start server again after reload failure...");
+                    logger.info("Attempting to start server again after reload failure...");
                     app = await startWithSpec();
-                    console.log("Recovery start succeeded.");
+                    logger.info("Recovery start succeeded.");
                 }
             }
             catch (err2) {
-                console.error("Recovery start failed. Server is down until next successful reload.");
-                console.error(String(err2));
+                logger.error("Recovery start failed. Server is down until next successful reload.");
+                logger.error(err2);
             }
         }
         finally {
@@ -99,7 +110,7 @@ async function startCommand(opts) {
         app = await startWithSpec();
     }
     catch (err) {
-        console.error(String(err));
+        logger.error(err);
         process.exit(1);
     }
     // Watch spec for changes
@@ -110,12 +121,12 @@ async function startCommand(opts) {
         debounceTimer = scheduleReload(reload, debounceTimer);
     }
     if (opts.watch) {
-        console.log(`Watching spec file for changes: ${specPath}`);
+        logger.info(`Watching spec file for changes: ${specPath}`);
         // fs.watch emits multiple events; debounce to avoid rapid reload loops
         (0, node_fs_1.watch)(specPath, onSpecChange);
     }
     else {
-        console.log("Watch disabled (--no-watch).");
+        logger.info("Watch disabled (--no-watch).");
     }
 }
 /**

package/dist/logger/customLogger.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+exports.logRequest = logRequest;
+exports.logServerStart = logServerStart;
+exports.logServerReload = logServerReload;
+exports.logEndpointRegistered = logEndpointRegistered;
+const pino_1 = __importDefault(require("pino"));
+const formatters_js_1 = require("./formatters.js");
+/**
+ * Create a custom logger for the mock server.
+ */
+function createLogger(options) {
+    if (!options.enabled) {
+        return (0, pino_1.default)({ level: "silent" });
+    }
+    if (options.format === "json") {
+        return (0, pino_1.default)({
+            level: options.level,
+            timestamp: pino_1.default.stdTimeFunctions.isoTime
+        });
+    }
+    // Pretty format with custom output (simplified to avoid serialization issues in tests)
+    return (0, pino_1.default)({
+        level: options.level,
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true,
+                translateTime: "HH:MM:ss",
+                ignore: "pid,hostname",
+                messageFormat: "{msg}"
+            }
+        }
+    });
+}
+/**
+ * Format and log a request/response pair.
+ */
+function logRequest(logger, method, url, statusCode, responseTime) {
+    const formattedMethod = (0, formatters_js_1.formatMethod)(method);
+    const formattedStatus = (0, formatters_js_1.formatStatusCode)(statusCode);
+    const formattedTime = (0, formatters_js_1.formatResponseTime)(responseTime);
+    logger.info(`${formattedMethod} ${url} ${formattedStatus} ${formattedTime}`);
+}
+/**
+ * Log server startup.
+ */
+function logServerStart(logger, port, specPath) {
+    logger.info(`🚀 Mock server running on http://localhost:${port}`);
+    logger.info(`📄 Spec: ${specPath}`);
+    logger.info(`📖 Docs: http://localhost:${port}/docs`);
+}
+/**
+ * Log server reload.
+ */
+function logServerReload(logger, success, error) {
+    if (success) {
+        logger.info("✅ Spec reloaded successfully");
+    }
+    else {
+        logger.error(`❌ Reload failed: ${error}`);
+    }
+}
+/**
+ * Log endpoint registration.
+ */
+function logEndpointRegistered(logger, method, path, status) {
+    const formattedMethod = (0, formatters_js_1.formatMethod)(method);
+    const statusInfo = status ? ` → ${status}` : "";
+    logger.debug(`Registered ${formattedMethod} ${path}${statusInfo}`);
+}

package/dist/logger/formatters.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatStatusCode = formatStatusCode;
+exports.formatMethod = formatMethod;
+exports.formatResponseTime = formatResponseTime;
+exports.formatTimestamp = formatTimestamp;
+exports.formatLogLevel = formatLogLevel;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Format HTTP status code with color based on status range.
+ */
+function formatStatusCode(statusCode) {
+    if (statusCode >= 500) {
+        return chalk_1.default.red(statusCode.toString());
+    }
+    if (statusCode >= 400) {
+        return chalk_1.default.yellow(statusCode.toString());
+    }
+    if (statusCode >= 300) {
+        return chalk_1.default.cyan(statusCode.toString());
+    }
+    if (statusCode >= 200) {
+        return chalk_1.default.green(statusCode.toString());
+    }
+    return chalk_1.default.white(statusCode.toString());
+}
+/**
+ * Format HTTP method with color.
+ */
+function formatMethod(method) {
+    const colors = {
+        GET: chalk_1.default.green,
+        POST: chalk_1.default.blue,
+        PUT: chalk_1.default.yellow,
+        PATCH: chalk_1.default.magenta,
+        DELETE: chalk_1.default.red,
+        HEAD: chalk_1.default.gray,
+        OPTIONS: chalk_1.default.cyan
+    };
+    const formatter = colors[method.toUpperCase()] || chalk_1.default.white;
+    return formatter(method.toUpperCase().padEnd(7));
+}
+/**
+ * Format response time with color based on duration.
+ */
+function formatResponseTime(ms) {
+    const formatted = `${ms.toFixed(2)}ms`;
+    if (ms > 1000)
+        return chalk_1.default.red(formatted);
+    if (ms > 500)
+        return chalk_1.default.yellow(formatted);
+    if (ms > 100)
+        return chalk_1.default.cyan(formatted);
+    return chalk_1.default.green(formatted);
+}
+/**
+ * Format timestamp in readable format.
+ */
+function formatTimestamp(date) {
+    const hours = date.getHours().toString().padStart(2, "0");
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    const seconds = date.getSeconds().toString().padStart(2, "0");
+    return chalk_1.default.gray(`[${hours}:${minutes}:${seconds}]`);
+}
+/**
+ * Format a log level with appropriate color.
+ */
+function formatLogLevel(level) {
+    const colors = {
+        trace: chalk_1.default.gray,
+        debug: chalk_1.default.cyan,
+        info: chalk_1.default.blue,
+        warn: chalk_1.default.yellow,
+        error: chalk_1.default.red,
+        fatal: chalk_1.default.bgRed.white
+    };
+    const formatter = colors[level.toLowerCase()] || chalk_1.default.white;
+    return formatter(level.toUpperCase().padEnd(5));
+}

package/dist/logger/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/registerEndpoints.js

@@ -4,6 +4,7 @@ exports.registerEndpoints = registerEndpoints;
 const requestMatch_js_1 = require("./requestMatch.js");
 const responseRenderer_js_1 = require("./responseRenderer.js");
 const behavior_js_1 = require("./behavior.js");
+const customLogger_js_1 = require("./logger/customLogger.js");
 /**
  * Select a response source from the first matching variant.
  */
@@ -15,6 +16,8 @@ function selectVariant(req, endpoint) {
             return {
                 status: variant.status,
                 response: variant.response,
+                headers: variant.headers,
+                delay: variant.delay,
                 delayMs: variant.delayMs,
                 errorRate: variant.errorRate,
                 errorStatus: variant.errorStatus,
@@ -31,6 +34,8 @@ function selectEndpointSource(endpoint) {
     return {
         status: endpoint.status,
         response: endpoint.response,
+        headers: endpoint.headers,
+        delay: endpoint.delay,
         delayMs: endpoint.delayMs,
         errorRate: endpoint.errorRate,
         errorStatus: endpoint.errorStatus,
@@ -47,7 +52,7 @@ function registerEndpoints(app, spec) {
             url: endpoint.path,
             handler: buildEndpointHandler(spec, endpoint)
         });
-        app.log.info(`Registered ${endpoint.method} ${endpoint.path} -> ${endpoint.status} (delay=${endpoint.delayMs ?? spec.settings.delayMs}ms, errorRate=${endpoint.errorRate ?? spec.settings.errorRate})`);
+        (0, customLogger_js_1.logEndpointRegistered)(app.log, endpoint.method, endpoint.path, endpoint.status);
     }
 }
 /**
@@ -62,8 +67,10 @@ function buildEndpointHandler(spec, endpoint) {
         }
         const source = variant ?? selectEndpointSource(endpoint);
         const behavior = (0, behavior_js_1.resolveBehavior)(spec.settings, endpoint, source);
-        if (behavior.delayMs > 0) {
-            await (0, behavior_js_1.sleep)(behavior.delayMs);
+        // Resolve delay (supports both delay and delayMs, with delay taking precedence)
+        const delayValue = source.delay ? (0, behavior_js_1.resolveDelay)(source.delay) : behavior.delayMs;
+        if (delayValue > 0) {
+            await (0, behavior_js_1.sleep)(delayValue);
         }
         const params = (0, requestMatch_js_1.toRecord)(req.params);
         const query = (0, requestMatch_js_1.toRecord)(req.query);
@@ -73,6 +80,16 @@ function buildEndpointHandler(spec, endpoint) {
             reply.code(behavior.errorStatus);
             return (0, responseRenderer_js_1.renderTemplateValue)(behavior.errorResponse, renderContext);
         }
+        // Apply custom headers (with template support)
+        const headers = source.headers ?? endpoint.headers;
+        if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+                const renderedValue = typeof value === "string"
+                    ? String((0, responseRenderer_js_1.renderTemplateValue)(value, renderContext))
+                    : String(value);
+                reply.header(key, renderedValue);
+            }
+        }
         const rendered = (0, responseRenderer_js_1.renderTemplateValue)(source.response, renderContext);
         reply.code(source.status ?? endpoint.status ?? 200);
         return rendered;

package/dist/requestMatch.js

@@ -47,7 +47,42 @@ function bodyMatches(req, expected) {
     return true;
 }
 /**
- * Check if a request matches query/body rules.
+ * Check if the request headers match the expected values (case-insensitive).
+ */
+function headersMatch(req, expected) {
+    if (!expected)
+        return true;
+    // Normalize header keys to lowercase for case-insensitive matching
+    const headers = new Map();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === "string") {
+            headers.set(key.toLowerCase(), value);
+        }
+    }
+    for (const [key, exp] of Object.entries(expected)) {
+        const actual = headers.get(key.toLowerCase());
+        if (actual !== exp)
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if the request cookies match the expected values.
+ */
+function cookiesMatch(req, expected) {
+    if (!expected)
+        return true;
+    const cookies = req.cookies;
+    if (!cookies)
+        return false;
+    for (const [key, exp] of Object.entries(expected)) {
+        if (cookies[key] !== exp)
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if a request matches query/body/headers/cookies rules.
  */
 function matchRequest(req, match) {
     if (!match)
@@ -56,5 +91,9 @@ function matchRequest(req, match) {
         return false;
     if (!bodyMatches(req, match.body))
         return false;
+    if (!headersMatch(req, match.headers))
+        return false;
+    if (!cookiesMatch(req, match.cookies))
+        return false;
     return true;
 }

package/dist/server.js

@@ -9,7 +9,10 @@ const registerEndpoints_js_1 = require("./registerEndpoints.js");
 const swagger_ui_dist_1 = __importDefault(require("swagger-ui-dist"));
 const openapi_js_1 = require("./openapi.js");
 const static_1 = __importDefault(require("@fastify/static"));
+const cookie_1 = __importDefault(require("@fastify/cookie"));
+const cors_1 = __importDefault(require("@fastify/cors"));
 const yaml_1 = __importDefault(require("yaml"));
+const historyRecorder_js_1 = require("./history/historyRecorder.js");
 /**
  * Resolve the path to swagger-ui-dist assets.
  */
@@ -40,8 +43,50 @@ function resolveServerUrl(req, baseUrl) {
  */
 function buildServer(spec, meta) {
     const app = (0, fastify_1.default)({
-        logger: true,
-        trustProxy: true
+        logger: meta?.logger ?? true,
+        trustProxy: true,
+        disableRequestLogging: false
+    });
+    // Register CORS if configured
+    if (spec.settings.cors) {
+        app.register(cors_1.default, {
+            origin: spec.settings.cors.origin ?? true,
+            credentials: spec.settings.cors.credentials ?? false,
+            methods: spec.settings.cors.methods,
+            allowedHeaders: spec.settings.cors.allowedHeaders,
+            exposedHeaders: spec.settings.cors.exposedHeaders,
+            maxAge: spec.settings.cors.maxAge
+        });
+    }
+    // Register cookie parser plugin
+    app.register(cookie_1.default);
+    // Create history recorder
+    const history = new historyRecorder_js_1.HistoryRecorder(1000);
+    // Record all requests in onRequest hook (after body parsing)
+    app.addHook("preHandler", async (req, reply) => {
+        const startTime = Date.now();
+        // Store start time for response hook
+        req.startTime = startTime;
+        history.record({
+            method: req.method,
+            url: req.url,
+            path: req.routeOptions?.url ?? req.url.split("?")[0],
+            query: req.query,
+            headers: req.headers,
+            body: req.body
+        });
+    });
+    // Update history with response details in onResponse hook
+    app.addHook("onResponse", async (req, reply) => {
+        const startTime = req.startTime ?? Date.now();
+        const responseTime = Date.now() - startTime;
+        // Find and update the last entry (just added in onRequest)
+        const entries = history.query({ limit: 1 });
+        if (entries.length > 0) {
+            const lastEntry = entries[entries.length - 1];
+            lastEntry.statusCode = reply.statusCode;
+            lastEntry.responseTime = responseTime;
+        }
     });
     /**
      * Handler for the /__spec route with bound metadata.
@@ -79,6 +124,21 @@ function buildServer(spec, meta) {
         decorateReply: false
     });
     app.get("/docs", docsRouteHandler);
+    // History endpoints
+    app.get("/__history", async (req) => {
+        const query = req.query;
+        const filter = {
+            endpoint: query.endpoint,
+            method: query.method,
+            statusCode: query.statusCode ? Number(query.statusCode) : undefined,
+            limit: query.limit ? Number(query.limit) : undefined
+        };
+        return { entries: history.query(filter), total: history.count() };
+    });
+    app.delete("/__history", async () => {
+        history.clear();
+        return { ok: true, message: "History cleared" };
+    });
     (0, registerEndpoints_js_1.registerEndpoints)(app, spec);
     return app;
 }

package/dist/spec.js

@@ -68,15 +68,28 @@ const TemplateValueSchema = z.lazy(() => z.union([
 exports.MatchSchema = z.object({
     query: z.record(z.string(), PrimitiveSchema).optional(),
     // Exact match for top-level body fields only (keeps v1 simple)
-    body: z.record(z.string(), PrimitiveSchema).optional()
+    body: z.record(z.string(), PrimitiveSchema).optional(),
+    // Header matching (case-insensitive keys)
+    headers: z.record(z.string(), z.string()).optional(),
+    // Cookie matching
+    cookies: z.record(z.string(), z.string()).optional()
 });
+const DelaySchema = z.union([
+    z.number().int().min(0),
+    z.object({
+        min: z.number().int().min(0),
+        max: z.number().int().min(0)
+    })
+]);
 exports.VariantSchema = z.object({
     name: z.string().min(1).optional(),
     match: exports.MatchSchema.optional(),
     status: z.number().int().min(100).max(599).optional(),
     response: TemplateValueSchema,
+    headers: z.record(z.string(), z.string()).optional(),
     // Simulation overrides per variant (optional)
     delayMs: z.number().int().min(0).optional(),
+    delay: DelaySchema.optional(),
     errorRate: z.number().min(0).max(1).optional(),
     errorStatus: z.number().int().min(100).max(599).optional(),
     errorResponse: TemplateValueSchema.optional()
@@ -89,8 +102,21 @@ exports.EndpointSchema = z.object({
     // Response behavior:
     status: z.number().int().min(200).max(599).default(200),
     response: TemplateValueSchema,
+    headers: z.record(z.string(), z.string()).optional(),
+    // Per-endpoint CORS override
+    cors: z
+        .object({
+        origin: z.union([z.string(), z.array(z.string()), z.boolean()]).optional(),
+        credentials: z.boolean().optional(),
+        methods: z.array(z.string()).optional(),
+        allowedHeaders: z.array(z.string()).optional(),
+        exposedHeaders: z.array(z.string()).optional(),
+        maxAge: z.number().int().optional()
+    })
+        .optional(),
     // Simulation (optional overrides)
     delayMs: z.number().int().min(0).optional(),
+    delay: DelaySchema.optional(),
     errorRate: z.number().min(0).max(1).optional(),
     errorStatus: z.number().int().min(100).max(599).optional(),
     errorResponse: TemplateValueSchema.optional()
@@ -103,7 +129,17 @@ exports.MockSpecSchema = z.object({
         errorRate: z.number().min(0).max(1).default(0),
         errorStatus: z.number().int().min(100).max(599).default(500),
         errorResponse: TemplateValueSchema.default({ error: "Mock error" }),
-        fakerSeed: z.number().int().min(0).optional()
+        fakerSeed: z.number().int().min(0).optional(),
+        cors: z
+            .object({
+            origin: z.union([z.string(), z.array(z.string()), z.boolean()]).optional(),
+            credentials: z.boolean().optional(),
+            methods: z.array(z.string()).optional(),
+            allowedHeaders: z.array(z.string()).optional(),
+            exposedHeaders: z.array(z.string()).optional(),
+            maxAge: z.number().int().optional()
+        })
+            .optional()
     })
         .default({ delayMs: 0, errorRate: 0, errorStatus: 500, errorResponse: { error: "Mock error" } }),
     endpoints: z.array(exports.EndpointSchema).min(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-json-server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -30,9 +30,14 @@
   },
   "dependencies": {
     "@faker-js/faker": "^10.2.0",
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/cors": "^11.2.0",
+    "@fastify/http-proxy": "^11.4.1",
     "@fastify/static": "^9.0.0",
+    "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "fastify": "^5.7.1",
+    "pino-pretty": "^13.1.3",
     "swagger-ui-dist": "^5.31.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.5"