rest_api_faker 0.0.0

package/dist/cli.js

@@ -0,0 +1,1838 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_chokidar = require("chokidar");
+
+// src/database.ts
+var import_lowdb = require("lowdb");
+var import_node = require("lowdb/node");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_url = require("url");
+var Database = class {
+  db;
+  filePath;
+  options;
+  /**
+   * Creates a new Database instance
+   *
+   * @param source - Path to JSON file or object with data
+   * @param options - Database configuration options
+   *
+   * @example
+   * ```typescript
+   * const db = new Database('db.json', { idField: 'id' });
+   * await db.init();
+   * ```
+   */
+  constructor(source, options = {}) {
+    this.options = {
+      idField: options.idField || "id",
+      foreignKeySuffix: options.foreignKeySuffix || "Id"
+    };
+    if (typeof source === "string") {
+      this.filePath = (0, import_path.resolve)(source);
+      const adapter = new import_node.JSONFile(this.filePath);
+      this.db = new import_lowdb.Low(adapter, {});
+    } else {
+      this.filePath = "";
+      const adapter = new import_node.JSONFile(":memory:");
+      this.db = new import_lowdb.Low(adapter, source);
+    }
+  }
+  /**
+   * Initialize the database by reading from file or using provided data
+   * Supports .json, .js, .ts, and .mjs files
+   *
+   * @throws Error if file doesn't exist or contains invalid data
+   */
+  async init() {
+    if (this.filePath && !(0, import_fs.existsSync)(this.filePath)) {
+      const ext = this.filePath.endsWith(".js") ? ".js" : ".json";
+      throw new Error(
+        `Database file not found: ${this.filePath}
+
+Make sure the file exists and the path is correct.
+Expected format: ${ext === ".js" ? "JavaScript module exporting data" : "JSON file with data structure"}`
+      );
+    }
+    if (this.filePath) {
+      const ext = (0, import_path.extname)(this.filePath).toLowerCase();
+      if (ext === ".js" || ext === ".mjs" || ext === ".cjs" || ext === ".ts") {
+        try {
+          const fileUrl = (0, import_url.pathToFileURL)(this.filePath).href;
+          const module2 = await import(fileUrl);
+          const data = module2.default ?? module2;
+          if (typeof data === "function") {
+            const result = await Promise.resolve(data());
+            if (typeof result !== "object" || result === null) {
+              throw new Error("JavaScript module function must return an object");
+            }
+            this.db.data = result;
+          } else if (typeof data === "object" && data !== null) {
+            this.db.data = data;
+          } else {
+            throw new Error("JavaScript module must export an object or function");
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to load JavaScript module: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      } else {
+        await this.db.read();
+      }
+    } else {
+      await this.db.read();
+    }
+    if (typeof this.db.data !== "object") {
+      this.db.data = {};
+    }
+    for (const key in this.db.data) {
+      const value = this.db.data[key];
+      if (value !== null && typeof value !== "object") {
+        throw new Error(`Invalid data structure: ${key} must be an array or object`);
+      }
+    }
+  }
+  /**
+   * Get all data from the database
+   *
+   * @returns Complete database data
+   */
+  getData() {
+    return this.db.data;
+  }
+  /**
+   * Get a specific collection (array) or resource (object)
+   *
+   * @param name - Name of the collection/resource
+   * @returns Collection array, resource object, or undefined
+   */
+  getCollection(name) {
+    return this.db.data[name];
+  }
+  /**
+   * Get a single item from a collection by ID
+   *
+   * @param collectionName - Name of the collection
+   * @param id - ID of the item
+   * @returns The item or undefined
+   */
+  getById(collectionName, id) {
+    const collection = this.db.data[collectionName];
+    if (!Array.isArray(collection)) {
+      return void 0;
+    }
+    return collection.find((item) => {
+      if (typeof item !== "object" || item === null) {
+        return false;
+      }
+      const record = item;
+      return record[this.options.idField] === id || record[this.options.idField] === Number(id);
+    });
+  }
+  /**
+   * Generate next ID for a collection
+   *
+   * @param collectionName - Name of the collection
+   * @returns Next available ID
+   */
+  generateId(collectionName) {
+    const collection = this.db.data[collectionName];
+    if (!Array.isArray(collection)) {
+      return 1;
+    }
+    let maxId = 0;
+    for (const item of collection) {
+      if (typeof item === "object" && item !== null) {
+        const record = item;
+        const idValue = record[this.options.idField];
+        if (typeof idValue === "number" && idValue > maxId) {
+          maxId = idValue;
+        }
+      }
+    }
+    return maxId + 1;
+  }
+  /**
+   * Create a new item in a collection
+   *
+   * @param collectionName - Name of the collection
+   * @param data - Data to insert
+   * @returns Created item with ID
+   * @throws Error if collection is not an array
+   */
+  async create(collectionName, data) {
+    let collection = this.db.data[collectionName];
+    if (!collection) {
+      collection = [];
+      this.db.data[collectionName] = collection;
+    }
+    if (!Array.isArray(collection)) {
+      throw new Error(`Cannot create in ${collectionName}: not a collection`);
+    }
+    const idValue = data[this.options.idField] !== void 0 ? data[this.options.idField] : this.generateId(collectionName);
+    const existingItem = this.getById(collectionName, idValue);
+    if (existingItem) {
+      throw new Error(`Item with ${this.options.idField}=${String(idValue)} already exists`);
+    }
+    const newItem = { ...data, [this.options.idField]: idValue };
+    collection.push(newItem);
+    await this.save();
+    return newItem;
+  }
+  /**
+   * Update an item in a collection (full replacement)
+   *
+   * @param collectionName - Name of the collection
+   * @param id - ID of the item
+   * @param data - New data (ID field will be preserved)
+   * @returns Updated item or undefined if not found
+   */
+  async update(collectionName, id, data) {
+    const collection = this.db.data[collectionName];
+    if (!Array.isArray(collection)) {
+      return void 0;
+    }
+    const index = collection.findIndex((item) => {
+      if (typeof item !== "object" || item === null) {
+        return false;
+      }
+      const record = item;
+      return record[this.options.idField] === id || record[this.options.idField] === Number(id);
+    });
+    if (index === -1) {
+      return void 0;
+    }
+    const originalItem = collection[index];
+    const originalId = originalItem[this.options.idField];
+    const updatedItem = { ...data, [this.options.idField]: originalId };
+    collection[index] = updatedItem;
+    await this.save();
+    return updatedItem;
+  }
+  /**
+   * Patch an item in a collection (partial update)
+   *
+   * @param collectionName - Name of the collection
+   * @param id - ID of the item
+   * @param data - Partial data to merge (ID field will be ignored)
+   * @returns Updated item or undefined if not found
+   */
+  async patch(collectionName, id, data) {
+    const collection = this.db.data[collectionName];
+    if (!Array.isArray(collection)) {
+      return void 0;
+    }
+    const index = collection.findIndex((item) => {
+      if (typeof item !== "object" || item === null) {
+        return false;
+      }
+      const record = item;
+      return record[this.options.idField] === id || record[this.options.idField] === Number(id);
+    });
+    if (index === -1) {
+      return void 0;
+    }
+    const currentItem = collection[index];
+    const { [this.options.idField]: _ignoredId, ...patchData } = data;
+    const patchedItem = { ...currentItem, ...patchData };
+    collection[index] = patchedItem;
+    await this.save();
+    return patchedItem;
+  }
+  /**
+   * Delete an item from a collection
+   *
+   * @param collectionName - Name of the collection
+   * @param id - ID of the item
+   * @returns true if deleted, false if not found
+   */
+  async delete(collectionName, id) {
+    const collection = this.db.data[collectionName];
+    if (!Array.isArray(collection)) {
+      return false;
+    }
+    const index = collection.findIndex((item) => {
+      if (typeof item !== "object" || item === null) {
+        return false;
+      }
+      const record = item;
+      return record[this.options.idField] === id || record[this.options.idField] === Number(id);
+    });
+    if (index === -1) {
+      return false;
+    }
+    collection.splice(index, 1);
+    await this.save();
+    return true;
+  }
+  /**
+   * Update or create a singular resource
+   *
+   * @param resourceName - Name of the resource
+   * @param data - Resource data
+   * @returns Updated resource
+   */
+  async updateSingular(resourceName, data) {
+    this.db.data[resourceName] = data;
+    await this.save();
+    return data;
+  }
+  /**
+   * Save the database to file
+   */
+  async save() {
+    await this.db.write();
+  }
+  /**
+   * Check if a resource is a collection (array) or singular (object)
+   *
+   * @param name - Name of the resource
+   * @returns true if collection, false if singular or doesn't exist
+   */
+  isCollection(name) {
+    return Array.isArray(this.db.data[name]);
+  }
+  /**
+   * Get ID field name
+   */
+  getIdField() {
+    return this.options.idField;
+  }
+  /**
+   * Get foreign key suffix
+   */
+  getForeignKeySuffix() {
+    return this.options.foreignKeySuffix;
+  }
+};
+
+// src/server.ts
+var import_express3 = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+var import_compression = __toESM(require("compression"));
+
+// src/router.ts
+var import_express = require("express");
+
+// src/logger.ts
+var import_picocolors = __toESM(require("picocolors"));
+var logger = {
+  /**
+   * Log success message in green
+   *
+   * @param message - Success message
+   *
+   * @example
+   * ```typescript
+   * logger.success('Server started successfully');
+   * // Output: ✓ Server started successfully (in green)
+   * ```
+   */
+  success(message) {
+    console.log(import_picocolors.default.green(`\u2713 ${message}`));
+  },
+  /**
+   * Log error message in red
+   *
+   * @param message - Error message
+   *
+   * @example
+   * ```typescript
+   * logger.error('Failed to load file');
+   * // Output: ✗ Failed to load file (in red)
+   * ```
+   */
+  error(message) {
+    console.error(import_picocolors.default.red(`\u2717 ${message}`));
+  },
+  /**
+   * Log warning message in yellow
+   *
+   * @param message - Warning message
+   *
+   * @example
+   * ```typescript
+   * logger.warn('Using default port');
+   * // Output: ⚠ Using default port (in yellow)
+   * ```
+   */
+  warn(message) {
+    console.warn(import_picocolors.default.yellow(`\u26A0 ${message}`));
+  },
+  /**
+   * Log info message in cyan
+   *
+   * @param message - Info message
+   *
+   * @example
+   * ```typescript
+   * logger.info('Watching for changes...');
+   * // Output: ℹ Watching for changes... (in cyan)
+   * ```
+   */
+  info(message) {
+    console.log(import_picocolors.default.cyan(`\u2139 ${message}`));
+  },
+  /**
+   * Log plain message without color
+   *
+   * @param message - Message to log
+   *
+   * @example
+   * ```typescript
+   * logger.log('http://localhost:3000');
+   * // Output: http://localhost:3000
+   * ```
+   */
+  log(message) {
+    console.log(message);
+  },
+  /**
+   * Log request in gray (for non-quiet mode)
+   *
+   * @param method - HTTP method
+   * @param url - Request URL
+   *
+   * @example
+   * ```typescript
+   * logger.request('GET', '/api/users');
+   * // Output: [timestamp] GET /api/users (in gray)
+   * ```
+   */
+  request(method, url) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    console.log(import_picocolors.default.gray(`[${timestamp}] ${method} ${url}`));
+  },
+  /**
+   * Log formatted banner
+   *
+   * @param lines - Array of lines to display
+   *
+   * @example
+   * ```typescript
+   * logger.banner([
+   *   '🚀 API Faker is running!',
+   *   '',
+   *   '  Resources:',
+   *   '  http://localhost:3000/'
+   * ]);
+   * ```
+   */
+  banner(lines) {
+    console.log();
+    for (const line of lines) {
+      if (line.includes("http://") || line.includes("https://")) {
+        const colored = line.replace(/(https?:\/\/[^\s]+)/g, (url) => import_picocolors.default.cyan(url));
+        console.log(colored);
+      } else if (line.startsWith("\u{1F680}")) {
+        console.log(import_picocolors.default.bold(line));
+      } else {
+        console.log(line);
+      }
+    }
+    console.log();
+  }
+};
+
+// src/query.ts
+function parseQuery(req) {
+  const query = req.query;
+  const filters = {};
+  const operators = {};
+  const sort = [];
+  const order = [];
+  let page;
+  let limit;
+  let start;
+  let end;
+  let q;
+  for (const [key, value] of Object.entries(query)) {
+    const stringValue = typeof value === "string" ? value : Array.isArray(value) && value.length > 0 && typeof value[0] === "string" ? value[0] : null;
+    if (stringValue === null && !Array.isArray(value)) {
+      continue;
+    }
+    if (key === "_sort") {
+      if (typeof value === "string") {
+        sort.push(...value.split(","));
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          if (typeof v === "string") {
+            sort.push(v);
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "_order") {
+      if (typeof value === "string") {
+        order.push(...value.split(","));
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          if (typeof v === "string") {
+            order.push(v);
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "_page" && stringValue) {
+      const parsed = parseInt(stringValue, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        page = parsed;
+      }
+      continue;
+    }
+    if (key === "_limit" && stringValue) {
+      const parsed = parseInt(stringValue, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        limit = parsed;
+      }
+      continue;
+    }
+    if (key === "_start" && stringValue) {
+      const parsed = parseInt(stringValue, 10);
+      if (!isNaN(parsed) && parsed >= 0) {
+        start = parsed;
+      }
+      continue;
+    }
+    if (key === "_end" && stringValue) {
+      const parsed = parseInt(stringValue, 10);
+      if (!isNaN(parsed) && parsed >= 0) {
+        end = parsed;
+      }
+      continue;
+    }
+    if (key === "q" && stringValue) {
+      q = stringValue;
+      continue;
+    }
+    const operatorMatch = key.match(/^(.+)_(gte|lte|ne|like)$/);
+    if (operatorMatch && stringValue) {
+      const field = operatorMatch[1];
+      const operator = operatorMatch[2];
+      if (field && operator) {
+        if (!operators[field]) {
+          operators[field] = {};
+        }
+        operators[field][operator] = stringValue;
+      }
+      continue;
+    }
+    if (typeof value === "string") {
+      filters[key] = value;
+    } else if (Array.isArray(value)) {
+      const stringValues = value.filter((v) => typeof v === "string");
+      if (stringValues.length > 0) {
+        filters[key] = stringValues;
+      }
+    }
+  }
+  const result = {
+    filters,
+    operators,
+    sort,
+    order
+  };
+  if (page !== void 0) result.page = page;
+  if (limit !== void 0) result.limit = limit;
+  if (start !== void 0) result.start = start;
+  if (end !== void 0) result.end = end;
+  if (q !== void 0) result.q = q;
+  return result;
+}
+function getNestedValue(obj, path) {
+  if (typeof obj !== "object" || obj === null) {
+    return void 0;
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null || !(key in current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function matchesFilters(item, filters) {
+  if (typeof item !== "object" || item === null) {
+    return false;
+  }
+  for (const [key, filterValue] of Object.entries(filters)) {
+    const itemValue = getNestedValue(item, key);
+    if (Array.isArray(filterValue)) {
+      const matched = filterValue.some((val) => String(itemValue) === val);
+      if (!matched) {
+        return false;
+      }
+    } else {
+      if (String(itemValue) !== filterValue) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function matchesOperators(item, operators) {
+  if (typeof item !== "object" || item === null) {
+    return false;
+  }
+  for (const [key, ops] of Object.entries(operators)) {
+    const itemValue = getNestedValue(item, key);
+    for (const [operator, filterValue] of Object.entries(ops)) {
+      if (operator === "gte") {
+        if (Number(itemValue) < Number(filterValue)) {
+          return false;
+        }
+      } else if (operator === "lte") {
+        if (Number(itemValue) > Number(filterValue)) {
+          return false;
+        }
+      } else if (operator === "ne") {
+        if (String(itemValue) === filterValue) {
+          return false;
+        }
+      } else if (operator === "like") {
+        const itemStr = String(itemValue).toLowerCase();
+        const filterStr = filterValue.toLowerCase();
+        if (!itemStr.includes(filterStr)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function matchesSearch(item, searchText) {
+  if (typeof item !== "object" || item === null) {
+    return false;
+  }
+  const lowerSearch = searchText.toLowerCase();
+  function searchObject(obj) {
+    if (typeof obj === "string") {
+      return obj.toLowerCase().includes(lowerSearch);
+    }
+    if (typeof obj === "object" && obj !== null) {
+      return Object.values(obj).some(searchObject);
+    }
+    return false;
+  }
+  return searchObject(item);
+}
+function applyQuery(data, options) {
+  let result = [...data];
+  if (options.q) {
+    const searchText = options.q;
+    result = result.filter((item) => matchesSearch(item, searchText));
+  }
+  if (Object.keys(options.filters).length > 0) {
+    result = result.filter((item) => matchesFilters(item, options.filters));
+  }
+  if (Object.keys(options.operators).length > 0) {
+    result = result.filter((item) => matchesOperators(item, options.operators));
+  }
+  const total = result.length;
+  if (options.sort.length > 0) {
+    const sortFields = options.sort;
+    const sortOrders = options.order;
+    result.sort((a, b) => {
+      for (let i = 0; i < sortFields.length; i++) {
+        const field = sortFields[i];
+        if (!field) continue;
+        const order = sortOrders[i] === "desc" ? -1 : 1;
+        const aVal = getNestedValue(a, field);
+        const bVal = getNestedValue(b, field);
+        if (aVal === bVal) continue;
+        if (aVal === void 0 || aVal === null) return 1 * order;
+        if (bVal === void 0 || bVal === null) return -1 * order;
+        if (aVal < bVal) return -1 * order;
+        if (aVal > bVal) return 1 * order;
+      }
+      return 0;
+    });
+  }
+  if (options.start !== void 0 || options.end !== void 0) {
+    const start = options.start ?? 0;
+    const end = options.end ?? result.length;
+    result = result.slice(start, end);
+  } else if (options.page !== void 0 && options.limit !== void 0) {
+    const start = (options.page - 1) * options.limit;
+    result = result.slice(start, start + options.limit);
+  } else if (options.limit !== void 0) {
+    result = result.slice(0, options.limit);
+  }
+  return { data: result, total };
+}
+function generateLinkHeader(req, page, limit, total) {
+  const host = req.get("host") ?? "localhost";
+  const baseUrl = `${req.protocol}://${host}${req.path}`;
+  const query = new URLSearchParams(req.query);
+  const lastPage = Math.ceil(total / limit);
+  const links = [];
+  query.set("_page", "1");
+  query.set("_limit", String(limit));
+  links.push(`<${baseUrl}?${query.toString()}>; rel="first"`);
+  if (page > 1) {
+    query.set("_page", String(page - 1));
+    links.push(`<${baseUrl}?${query.toString()}>; rel="prev"`);
+  }
+  if (page < lastPage) {
+    query.set("_page", String(page + 1));
+    links.push(`<${baseUrl}?${query.toString()}>; rel="next"`);
+  }
+  query.set("_page", String(lastPage));
+  links.push(`<${baseUrl}?${query.toString()}>; rel="last"`);
+  return links.join(", ");
+}
+
+// src/relationships.ts
+function getForeignKey(collectionName, foreignKeySuffix) {
+  const singular = collectionName.endsWith("s") ? collectionName.slice(0, -1) : collectionName;
+  return `${singular}${foreignKeySuffix}`;
+}
+function embedChildren(items, parentCollection, childCollection, db, idField, foreignKeySuffix) {
+  const children = db.getCollection(childCollection);
+  if (!Array.isArray(children)) {
+    return items;
+  }
+  const foreignKey = getForeignKey(parentCollection, foreignKeySuffix);
+  return items.map((item) => {
+    const matchingChildren = children.filter((child) => {
+      if (typeof child !== "object" || child === null) return false;
+      const childFk = child[foreignKey];
+      const parentId = item[idField];
+      return childFk === parentId || String(childFk) === String(parentId);
+    });
+    return {
+      ...item,
+      [childCollection]: matchingChildren
+    };
+  });
+}
+function expandParent(items, _childCollection, parentCollection, db, idField, foreignKeySuffix) {
+  const parents = db.getCollection(parentCollection);
+  if (!Array.isArray(parents)) {
+    return items;
+  }
+  const foreignKey = getForeignKey(parentCollection, foreignKeySuffix);
+  return items.map((item) => {
+    const foreignKeyValue = item[foreignKey];
+    if (foreignKeyValue === void 0) {
+      return item;
+    }
+    const parent = parents.find((p) => {
+      if (typeof p !== "object" || p === null) return false;
+      const parentRecord = p;
+      const parentId = parentRecord[idField];
+      if (typeof foreignKeyValue === "number" || typeof foreignKeyValue === "string") {
+        return parentId === foreignKeyValue || String(parentId) === String(foreignKeyValue);
+      }
+      return false;
+    });
+    if (!parent || typeof parent !== "object") {
+      return item;
+    }
+    const parentPropName = parentCollection.endsWith("s") ? parentCollection.slice(0, -1) : parentCollection;
+    return {
+      ...item,
+      [parentPropName]: parent
+    };
+  });
+}
+function applyRelationships(data, resource, embed, expand, db, idField, foreignKeySuffix) {
+  let result = data;
+  for (const childCollection of embed) {
+    result = embedChildren(result, resource, childCollection, db, idField, foreignKeySuffix);
+  }
+  for (const parentCollection of expand) {
+    result = expandParent(result, resource, parentCollection, db, idField, foreignKeySuffix);
+  }
+  return result;
+}
+function parseRelationships(query) {
+  const embed = [];
+  const expand = [];
+  const embedParam = query._embed;
+  if (typeof embedParam === "string") {
+    embed.push(...embedParam.split(","));
+  } else if (Array.isArray(embedParam)) {
+    for (const e of embedParam) {
+      if (typeof e === "string") {
+        embed.push(e);
+      }
+    }
+  }
+  const expandParam = query._expand;
+  if (typeof expandParam === "string") {
+    expand.push(...expandParam.split(","));
+  } else if (Array.isArray(expandParam)) {
+    for (const e of expandParam) {
+      if (typeof e === "string") {
+        expand.push(e);
+      }
+    }
+  }
+  return { embed, expand };
+}
+
+// src/router.ts
+function getParam(req, name) {
+  const value = req.params[name];
+  if (value === void 0) {
+    throw new Error(`Route parameter '${name}' is missing`);
+  }
+  return value;
+}
+function createRouter(db, options = {}) {
+  const router = (0, import_express.Router)();
+  const readOnly = options.readOnly || false;
+  const idField = options.idField || "id";
+  const foreignKeySuffix = options.foreignKeySuffix || "Id";
+  const validateContentType = (req, _res, next) => {
+    const contentType = req.get("Content-Type");
+    if (!contentType || !contentType.includes("application/json")) {
+      logger.warn("Content-Type should be application/json");
+    }
+    next();
+  };
+  router.get("/db", (_req, res) => {
+    res.json(db.getData());
+  });
+  router.get("/:resource", (req, res) => {
+    const resource = getParam(req, "resource");
+    const data = db.getCollection(resource);
+    if (data === void 0) {
+      res.status(404).json({ error: `Resource '${resource}' not found` });
+      return;
+    }
+    if (Array.isArray(data)) {
+      const queryOptions = parseQuery(req);
+      const { data: filtered, total } = applyQuery(data, queryOptions);
+      const { embed, expand } = parseRelationships(req.query);
+      const withRelationships = applyRelationships(
+        filtered,
+        resource,
+        embed,
+        expand,
+        db,
+        idField,
+        foreignKeySuffix
+      );
+      res.set("X-Total-Count", String(total));
+      if (queryOptions.page !== void 0 && queryOptions.limit !== void 0) {
+        const linkHeader = generateLinkHeader(req, queryOptions.page, queryOptions.limit, total);
+        res.set("Link", linkHeader);
+      }
+      res.json(withRelationships);
+      return;
+    }
+    res.json(data);
+  });
+  router.get("/:resource/:id", (req, res) => {
+    const resource = getParam(req, "resource");
+    const id = getParam(req, "id");
+    if (!db.isCollection(resource)) {
+      res.status(404).json({ error: `Collection '${resource}' not found` });
+      return;
+    }
+    const item = db.getById(resource, id);
+    if (!item) {
+      res.status(404).json({ error: `Item with id '${id}' not found in '${resource}'` });
+      return;
+    }
+    const { embed, expand } = parseRelationships(req.query);
+    if (embed.length > 0 || expand.length > 0) {
+      const withRelationships = applyRelationships(
+        [item],
+        resource,
+        embed,
+        expand,
+        db,
+        idField,
+        foreignKeySuffix
+      );
+      res.json(withRelationships[0]);
+      return;
+    }
+    res.json(item);
+  });
+  router.get("/:parent/:parentId/:children", (req, res) => {
+    const parent = getParam(req, "parent");
+    const parentId = getParam(req, "parentId");
+    const children = getParam(req, "children");
+    if (!db.isCollection(parent)) {
+      res.status(404).json({ error: `Collection '${parent}' not found` });
+      return;
+    }
+    const parentItem = db.getById(parent, parentId);
+    if (!parentItem) {
+      res.status(404).json({ error: `Parent item with id '${parentId}' not found in '${parent}'` });
+      return;
+    }
+    const childrenData = db.getCollection(children);
+    if (!Array.isArray(childrenData)) {
+      res.status(404).json({ error: `Collection '${children}' not found` });
+      return;
+    }
+    const foreignKey = getForeignKey(parent, foreignKeySuffix);
+    const filtered = childrenData.filter((child) => {
+      if (typeof child !== "object" || child === null) return false;
+      const childFk = child[foreignKey];
+      return childFk === parentId || (typeof childFk === "number" || typeof childFk === "string" ? String(childFk) === parentId : false);
+    });
+    const queryOptions = parseQuery(req);
+    const { data: result, total } = applyQuery(filtered, queryOptions);
+    res.set("X-Total-Count", String(total));
+    res.json(result);
+  });
+  router.post(
+    "/:parent/:parentId/:children",
+    validateContentType,
+    async (req, res) => {
+      if (readOnly) {
+        return res.status(403).json({ error: "Read-only mode enabled" });
+      }
+      const parent = getParam(req, "parent");
+      const parentId = getParam(req, "parentId");
+      const children = getParam(req, "children");
+      const data = req.body;
+      if (typeof data !== "object") {
+        return res.status(400).json({ error: "Request body must be a JSON object" });
+      }
+      if (!db.isCollection(parent)) {
+        return res.status(404).json({ error: `Collection '${parent}' not found` });
+      }
+      const parentItem = db.getById(parent, parentId);
+      if (!parentItem) {
+        return res.status(404).json({ error: `Parent item with id '${parentId}' not found in '${parent}'` });
+      }
+      const foreignKey = getForeignKey(parent, foreignKeySuffix);
+      data[foreignKey] = parentId;
+      try {
+        const created = await db.create(children, data);
+        return res.status(201).json(created);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return res.status(400).json({ error: message });
+      }
+    }
+  );
+  router.post("/:resource", validateContentType, async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const data = req.body;
+    if (typeof data !== "object") {
+      return res.status(400).json({ error: "Request body must be a JSON object" });
+    }
+    try {
+      if (!db.isCollection(resource) && db.getCollection(resource) !== void 0) {
+        const updated = await db.updateSingular(resource, data);
+        return res.status(200).json(updated);
+      }
+      const created = await db.create(resource, data);
+      return res.status(201).json(created);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return res.status(400).json({ error: message });
+    }
+  });
+  router.put("/:resource/:id", validateContentType, async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const id = getParam(req, "id");
+    const data = req.body;
+    if (typeof data !== "object") {
+      return res.status(400).json({ error: "Request body must be a JSON object" });
+    }
+    if (!db.isCollection(resource)) {
+      return res.status(404).json({ error: `Collection '${resource}' not found` });
+    }
+    try {
+      const updated = await db.update(resource, id, data);
+      if (!updated) {
+        return res.status(404).json({ error: `Item with id '${id}' not found in '${resource}'` });
+      }
+      return res.json(updated);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return res.status(400).json({ error: message });
+    }
+  });
+  router.patch("/:resource/:id", validateContentType, async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const id = getParam(req, "id");
+    const data = req.body;
+    if (typeof data !== "object") {
+      return res.status(400).json({ error: "Request body must be a JSON object" });
+    }
+    if (!db.isCollection(resource)) {
+      return res.status(404).json({ error: `Collection '${resource}' not found` });
+    }
+    try {
+      const patched = await db.patch(resource, id, data);
+      if (!patched) {
+        return res.status(404).json({ error: `Item with id '${id}' not found in '${resource}'` });
+      }
+      return res.json(patched);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return res.status(400).json({ error: message });
+    }
+  });
+  router.put("/:resource", validateContentType, async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const data = req.body;
+    if (typeof data !== "object") {
+      return res.status(400).json({ error: "Request body must be a JSON object" });
+    }
+    if (db.isCollection(resource)) {
+      return res.status(400).json({
+        error: `Cannot PUT to collection '${resource}'. Use POST or PUT /${resource}/:id`
+      });
+    }
+    try {
+      const updated = await db.updateSingular(resource, data);
+      return res.json(updated);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return res.status(400).json({ error: message });
+    }
+  });
+  router.patch("/:resource", validateContentType, async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const data = req.body;
+    if (typeof data !== "object") {
+      return res.status(400).json({ error: "Request body must be a JSON object" });
+    }
+    if (db.isCollection(resource)) {
+      return res.status(400).json({ error: `Cannot PATCH collection '${resource}'. Use PATCH /${resource}/:id` });
+    }
+    const current = db.getCollection(resource);
+    if (!current || typeof current !== "object") {
+      return res.status(404).json({ error: `Resource '${resource}' not found` });
+    }
+    try {
+      const merged = { ...current, ...data };
+      const updated = await db.updateSingular(resource, merged);
+      return res.json(updated);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return res.status(400).json({ error: message });
+    }
+  });
+  router.delete("/:resource/:id", async (req, res) => {
+    if (readOnly) {
+      return res.status(403).json({ error: "Read-only mode enabled" });
+    }
+    const resource = getParam(req, "resource");
+    const id = getParam(req, "id");
+    if (!db.isCollection(resource)) {
+      return res.status(404).json({ error: `Collection '${resource}' not found` });
+    }
+    const deleted = await db.delete(resource, id);
+    if (!deleted) {
+      return res.status(404).json({ error: `Item with id '${id}' not found in '${resource}'` });
+    }
+    return res.status(204).send();
+  });
+  return router;
+}
+
+// src/static.ts
+var import_express2 = __toESM(require("express"));
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+function createStaticMiddleware(options = {}) {
+  const directory = options.directory || "./public";
+  const enabled = options.enabled !== false;
+  const staticPath = (0, import_path2.resolve)(process.cwd(), directory);
+  if (!enabled || !(0, import_fs2.existsSync)(staticPath)) {
+    return (_req, _res, next) => {
+      next();
+    };
+  }
+  return import_express2.default.static(staticPath, {
+    index: "index.html",
+    dotfiles: "ignore",
+    redirect: true
+  });
+}
+function createHomepageMiddleware(options = {}) {
+  const directory = options.directory || "./public";
+  const enabled = options.enabled !== false;
+  const staticPath = (0, import_path2.resolve)(process.cwd(), directory);
+  const indexPath = (0, import_path2.resolve)(staticPath, "index.html");
+  return (req, res, next) => {
+    if (req.path !== "/") {
+      next();
+      return;
+    }
+    if (enabled && (0, import_fs2.existsSync)(indexPath)) {
+      next();
+      return;
+    }
+    const host = req.get("host") || "localhost:3000";
+    const protocol = req.protocol;
+    const baseUrl = `${protocol}://${host}`;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.send(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>API Faker</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      padding: 2rem;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+      background: white;
+      border-radius: 12px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      padding: 3rem;
+    }
+    h1 {
+      color: #667eea;
+      font-size: 2.5rem;
+      margin-bottom: 1rem;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+    h2 {
+      color: #555;
+      font-size: 1.5rem;
+      margin-top: 2rem;
+      margin-bottom: 1rem;
+      border-bottom: 2px solid #667eea;
+      padding-bottom: 0.5rem;
+    }
+    .intro {
+      color: #666;
+      font-size: 1.1rem;
+      margin-bottom: 2rem;
+    }
+    .endpoint {
+      background: #f8f9fa;
+      border-left: 4px solid #667eea;
+      padding: 1rem;
+      margin-bottom: 1rem;
+      border-radius: 4px;
+    }
+    .endpoint a {
+      color: #667eea;
+      text-decoration: none;
+      font-family: 'Monaco', 'Courier New', monospace;
+      font-weight: bold;
+    }
+    .endpoint a:hover {
+      text-decoration: underline;
+    }
+    .endpoint p {
+      color: #666;
+      margin-top: 0.5rem;
+      font-size: 0.95rem;
+    }
+    .info-box {
+      background: #e3f2fd;
+      border-left: 4px solid #2196f3;
+      padding: 1rem;
+      margin-top: 2rem;
+      border-radius: 4px;
+    }
+    .info-box p {
+      color: #1565c0;
+      margin: 0;
+    }
+    code {
+      background: #f5f5f5;
+      padding: 0.2rem 0.4rem;
+      border-radius: 3px;
+      font-family: 'Monaco', 'Courier New', monospace;
+      font-size: 0.9em;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u{1F680} API Faker</h1>
+    <p class="intro">
+      Your JSON REST API is up and running! Use the endpoints below to interact with your data.
+    </p>
+
+    <h2>\u{1F4E1} Endpoints</h2>
+    <div class="endpoint">
+      <a href="${baseUrl}/db" target="_blank">${baseUrl}/db</a>
+      <p>View the full database</p>
+    </div>
+
+    <h2>\u{1F4A1} Tips</h2>
+    <div class="info-box">
+      <p>
+        Use query parameters to filter, sort, and paginate your data. 
+        Examples: <code>?_sort=name&_order=asc</code>, <code>?_page=1&_limit=10</code>
+      </p>
+    </div>
+  </div>
+</body>
+</html>`);
+  };
+}
+
+// src/loader.ts
+var import_node_url = require("url");
+async function loadModule(filePath) {
+  try {
+    const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+    const module2 = await import(fileUrl);
+    return module2;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load module '${filePath}': ${message}
+
+Make sure:
+  - The file exists and is a valid JavaScript file
+  - The file doesn't have syntax errors
+  - All dependencies are installed`
+    );
+  }
+}
+async function loadMiddlewares(filePath) {
+  const module2 = await loadModule(filePath);
+  let middlewareExport;
+  if (typeof module2 === "object" && module2 !== null && "default" in module2) {
+    const defaultExport = module2.default;
+    if (typeof defaultExport === "object" && defaultExport !== null && "default" in defaultExport) {
+      middlewareExport = defaultExport.default;
+    } else {
+      middlewareExport = defaultExport;
+    }
+  } else {
+    middlewareExport = module2;
+  }
+  const middlewares = Array.isArray(middlewareExport) ? middlewareExport : [middlewareExport];
+  for (let i = 0; i < middlewares.length; i++) {
+    const mw = middlewares[i];
+    if (typeof mw !== "function") {
+      const indexStr = String(i);
+      throw new Error(
+        `Middleware file '${filePath}' at index ${indexStr} is not a function, got ${typeof mw}`
+      );
+    }
+  }
+  return middlewares;
+}
+
+// src/rewriter.ts
+var import_promises = require("fs/promises");
+async function loadRewriteRules(filePath) {
+  try {
+    const content = await (0, import_promises.readFile)(filePath, "utf-8");
+    const rules = JSON.parse(content);
+    if (typeof rules !== "object" || rules === null || Array.isArray(rules)) {
+      throw new Error("Routes file must contain a JSON object with route mappings");
+    }
+    for (const [key, value] of Object.entries(rules)) {
+      if (typeof value !== "string") {
+        throw new Error(`Route mapping for '${key}' must be a string, got ${typeof value}`);
+      }
+    }
+    return rules;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Routes file must contain")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load routes from '${filePath}': ${message}
+
+Expected format:
+{
+  "/api/*": "/$1",
+  "/users/:id": "/api/users/:id"
+}
+
+See examples/routes.json for more examples.`
+    );
+  }
+}
+function patternToRegex(pattern) {
+  const params = [];
+  let regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  regexPattern = regexPattern.replace(/:([^/]+)/g, (_match, param) => {
+    params.push(param);
+    return "([^/]+)";
+  });
+  regexPattern = regexPattern.replace(/\*/g, () => {
+    params.push(`$${String(params.length + 1)}`);
+    return "(.*)";
+  });
+  return {
+    regex: new RegExp(`^${regexPattern}$`),
+    params
+  };
+}
+function rewriteUrl(url, fromPattern, toPattern) {
+  const { regex, params } = patternToRegex(fromPattern);
+  const match = url.match(regex);
+  if (!match) {
+    return null;
+  }
+  const captures = match.slice(1);
+  let result = toPattern;
+  for (let i = 0; i < captures.length; i++) {
+    const value = captures[i];
+    if (value !== void 0) {
+      result = result.replace(`$${String(i + 1)}`, value);
+    }
+  }
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const value = captures[i];
+    if (param && !param.startsWith("$") && value !== void 0) {
+      result = result.replace(`:${param}`, value);
+    }
+  }
+  return result;
+}
+function createRewriterMiddleware(rules) {
+  return (req, _res, next) => {
+    for (const [from, to] of Object.entries(rules)) {
+      const rewritten = rewriteUrl(req.url, from, to);
+      if (rewritten !== null) {
+        req.url = rewritten;
+        break;
+      }
+    }
+    next();
+  };
+}
+
+// src/server.ts
+async function createServer(db, options = {}) {
+  const app = (0, import_express3.default)();
+  if (!options.noCors) {
+    app.use((0, import_cors.default)());
+  }
+  if (!options.noGzip) {
+    app.use((0, import_compression.default)());
+  }
+  app.use(import_express3.default.json());
+  if (options.delay && options.delay > 0) {
+    const delay = options.delay;
+    app.use((_req, _res, next) => {
+      setTimeout(() => {
+        next();
+      }, delay);
+    });
+  }
+  if (!options.quiet) {
+    app.use((req, _res, next) => {
+      logger.request(req.method, req.url);
+      next();
+    });
+  }
+  if (options.middlewares) {
+    try {
+      const middlewares = await loadMiddlewares(options.middlewares);
+      for (const middleware of middlewares) {
+        app.use(middleware);
+      }
+      if (!options.quiet) {
+        logger.success(`Loaded custom middlewares from ${options.middlewares}`);
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to load middlewares: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  app.use(createHomepageMiddleware(options));
+  app.use(createStaticMiddleware(options));
+  if (options.routes) {
+    try {
+      const rules = await loadRewriteRules(options.routes);
+      const rewriter = createRewriterMiddleware(rules);
+      app.use(rewriter);
+      if (!options.quiet) {
+        logger.success(`Loaded route rewrite rules from ${options.routes}`);
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to load routes: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  app.get("/db", (_req, res) => {
+    res.json(db.getData());
+  });
+  const router = createRouter(db, options);
+  app.use(router);
+  app.use((_req, res) => {
+    res.status(404).json({ error: "Not Found" });
+  });
+  return app;
+}
+function startServer(app, options = {}) {
+  const port = options.port || 3e3;
+  const host = options.host || "localhost";
+  return app.listen(port, host, () => {
+    if (!options.quiet) {
+      logger.banner([
+        "\u{1F680} API Faker is running!",
+        "",
+        "  Resources:",
+        `  http://${host}:${String(port)}/`,
+        "",
+        "  Home:",
+        `  http://${host}:${String(port)}`
+      ]);
+    }
+  });
+}
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function findClosestMatch(input, candidates) {
+  const levenshtein = (a, b) => {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        if (b.charAt(i - 1) === a.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    return matrix[b.length][a.length];
+  };
+  let closestMatch = null;
+  let minDistance = Infinity;
+  for (const candidate of candidates) {
+    const distance = levenshtein(input.toLowerCase(), candidate.toLowerCase());
+    if (distance < minDistance && distance <= 3) {
+      minDistance = distance;
+      closestMatch = candidate;
+    }
+  }
+  return closestMatch;
+}
+function loadConfig(configPath) {
+  const resolvedPath = (0, import_node_path.resolve)(configPath);
+  if (!(0, import_node_fs.existsSync)(resolvedPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs.readFileSync)(resolvedPath, "utf-8");
+    const config = JSON.parse(content);
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+      throw new Error("Config file must contain a JSON object");
+    }
+    validateConfig(config);
+    return config;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Config file must contain")) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to load config from '${configPath}': ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateConfig(config) {
+  const validOptions = /* @__PURE__ */ new Set([
+    "port",
+    "host",
+    "watch",
+    "routes",
+    "middlewares",
+    "static",
+    "readOnly",
+    "noCors",
+    "noGzip",
+    "snapshots",
+    "delay",
+    "id",
+    "foreignKeySuffix",
+    "quiet"
+  ]);
+  for (const key of Object.keys(config)) {
+    if (!validOptions.has(key)) {
+      const suggestion = findClosestMatch(key, Array.from(validOptions));
+      const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : "";
+      throw new Error(
+        `Unknown config option: '${key}'.${didYouMean} Valid options are: ${Array.from(validOptions).join(", ")}`
+      );
+    }
+  }
+  if ("port" in config && (typeof config.port !== "number" || config.port < 0 || config.port > 65535)) {
+    throw new Error("Config option 'port' must be a number between 0 and 65535");
+  }
+  if ("host" in config && typeof config.host !== "string") {
+    throw new Error("Config option 'host' must be a string");
+  }
+  if ("watch" in config && typeof config.watch !== "boolean") {
+    throw new Error("Config option 'watch' must be a boolean");
+  }
+  if ("routes" in config && typeof config.routes !== "string") {
+    throw new Error("Config option 'routes' must be a string");
+  }
+  if ("middlewares" in config && typeof config.middlewares !== "string") {
+    throw new Error("Config option 'middlewares' must be a string");
+  }
+  if ("static" in config && typeof config.static !== "string") {
+    throw new Error("Config option 'static' must be a string");
+  }
+  if ("readOnly" in config && typeof config.readOnly !== "boolean") {
+    throw new Error("Config option 'readOnly' must be a boolean");
+  }
+  if ("noCors" in config && typeof config.noCors !== "boolean") {
+    throw new Error("Config option 'noCors' must be a boolean");
+  }
+  if ("noGzip" in config && typeof config.noGzip !== "boolean") {
+    throw new Error("Config option 'noGzip' must be a boolean");
+  }
+  if ("snapshots" in config && typeof config.snapshots !== "string") {
+    throw new Error("Config option 'snapshots' must be a string");
+  }
+  if ("delay" in config && (typeof config.delay !== "number" || config.delay < 0)) {
+    throw new Error("Config option 'delay' must be a non-negative number");
+  }
+  if ("id" in config && typeof config.id !== "string") {
+    throw new Error("Config option 'id' must be a string");
+  }
+  if ("foreignKeySuffix" in config && typeof config.foreignKeySuffix !== "string") {
+    throw new Error("Config option 'foreignKeySuffix' must be a string");
+  }
+  if ("quiet" in config && typeof config.quiet !== "boolean") {
+    throw new Error("Config option 'quiet' must be a boolean");
+  }
+}
+function mergeConfig(cliConfig, fileConfig) {
+  if (!fileConfig) {
+    return cliConfig;
+  }
+  return {
+    ...fileConfig,
+    ...cliConfig
+  };
+}
+
+// src/cli.ts
+function getVersion() {
+  try {
+    const packageJson = JSON.parse(
+      (0, import_fs3.readFileSync)((0, import_path3.resolve)(__dirname, "../package.json"), "utf-8")
+    );
+    return packageJson.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function parseCli() {
+  const argv = (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("api-faker").usage("Usage: $0 [options] <source>").example("$0 db.json", "Start API Faker with db.json").example("$0 file.js", "Start API Faker with a JS file").example("$0 http://example.com/db.json", "Start API Faker with a remote schema").option("config", {
+    alias: "c",
+    type: "string",
+    description: "Path to config file",
+    default: "api-faker.json"
+  }).option("port", {
+    alias: "p",
+    type: "number",
+    description: "Set port",
+    default: 3e3
+  }).option("host", {
+    alias: "H",
+    type: "string",
+    description: "Set host",
+    default: "localhost"
+  }).option("watch", {
+    alias: "w",
+    type: "boolean",
+    description: "Watch file(s)",
+    default: false
+  }).option("routes", {
+    alias: "r",
+    type: "string",
+    description: "Path to routes file"
+  }).option("middlewares", {
+    alias: "m",
+    type: "string",
+    description: "Path to middleware file"
+  }).option("static", {
+    alias: "s",
+    type: "string",
+    description: "Set static files directory",
+    default: "./public"
+  }).option("no-static", {
+    type: "boolean",
+    description: "Disable static file serving",
+    default: false
+  }).option("read-only", {
+    alias: "ro",
+    type: "boolean",
+    description: "Allow only GET requests",
+    default: false
+  }).option("no-cors", {
+    alias: "nc",
+    type: "boolean",
+    description: "Disable Cross-Origin Resource Sharing",
+    default: false
+  }).option("no-gzip", {
+    alias: "ng",
+    type: "boolean",
+    description: "Disable GZIP Content-Encoding",
+    default: false
+  }).option("snapshots", {
+    alias: "S",
+    type: "string",
+    description: "Set snapshots directory",
+    default: "."
+  }).option("delay", {
+    alias: "d",
+    type: "number",
+    description: "Add delay to responses (ms)"
+  }).option("id", {
+    alias: "i",
+    type: "string",
+    description: "Set database id property",
+    default: "id"
+  }).option("foreignKeySuffix", {
+    alias: "fks",
+    type: "string",
+    description: "Set foreign key suffix",
+    default: "Id"
+  }).option("quiet", {
+    alias: "q",
+    type: "boolean",
+    description: "Suppress log messages from output",
+    default: false
+  }).help("help", "Show help").alias("h", "help").version(getVersion()).alias("v", "version").epilogue("For more information, visit https://github.com/hamidmayeli/api-faker").parseSync();
+  let fileConfig = null;
+  try {
+    fileConfig = loadConfig(argv.config);
+  } catch (error) {
+    logger.error(
+      `Failed to load config file: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  const cliConfig = {};
+  if (argv.port !== 3e3) cliConfig.port = argv.port;
+  if (argv.host !== "localhost") cliConfig.host = argv.host;
+  if (argv.watch) cliConfig.watch = argv.watch;
+  if (argv.routes) cliConfig.routes = argv.routes;
+  if (argv.middlewares) cliConfig.middlewares = argv.middlewares;
+  if (argv.static !== "./public") cliConfig.static = argv.static;
+  if (argv["read-only"]) cliConfig.readOnly = argv["read-only"];
+  if (argv["no-cors"]) cliConfig.noCors = argv["no-cors"];
+  if (argv["no-gzip"]) cliConfig.noGzip = argv["no-gzip"];
+  if (argv.snapshots !== ".") cliConfig.snapshots = argv.snapshots;
+  if (argv.delay !== void 0) cliConfig.delay = argv.delay;
+  if (argv.id !== "id") cliConfig.id = argv.id;
+  if (argv.foreignKeySuffix !== "Id") cliConfig.foreignKeySuffix = argv.foreignKeySuffix;
+  if (argv.quiet) cliConfig.quiet = argv.quiet;
+  const merged = mergeConfig(cliConfig, fileConfig);
+  return {
+    source: argv._[0],
+    port: merged.port ?? 3e3,
+    host: merged.host ?? "localhost",
+    watch: merged.watch ?? false,
+    routes: merged.routes,
+    middlewares: merged.middlewares,
+    static: merged.static ?? "./public",
+    noStatic: argv["no-static"],
+    readOnly: merged.readOnly ?? false,
+    noCors: merged.noCors ?? false,
+    noGzip: merged.noGzip ?? false,
+    snapshots: merged.snapshots ?? ".",
+    delay: merged.delay,
+    id: merged.id ?? "id",
+    foreignKeySuffix: merged.foreignKeySuffix ?? "Id",
+    quiet: merged.quiet ?? false,
+    config: argv.config
+  };
+}
+async function main() {
+  const config = parseCli();
+  if (!config.quiet) {
+    logger.log(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                       \u2551
+  \u2551         API Faker v${getVersion().padEnd(19)}\u2551
+  \u2551                                       \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+    `);
+  }
+  if (!config.source) {
+    logger.error("No source file specified");
+    logger.info('Run "api-faker --help" for usage information');
+    process.exit(1);
+  }
+  if (!config.quiet) {
+    logger.info(`Source:  ${config.source}`);
+    logger.info(`Port:    ${String(config.port)}`);
+    logger.info(`Host:    ${config.host}`);
+    logger.log("");
+    logger.info("Loading database...");
+  }
+  try {
+    const db = new Database(config.source, {
+      idField: config.id,
+      foreignKeySuffix: config.foreignKeySuffix
+    });
+    await db.init();
+    if (!config.quiet) {
+      const data = db.getData();
+      const resources = Object.keys(data);
+      logger.success(`Loaded ${String(resources.length)} resource(s): ${resources.join(", ")}`);
+      logger.log("");
+    }
+    const serverOptions = {
+      port: config.port,
+      host: config.host,
+      readOnly: config.readOnly,
+      noCors: config.noCors,
+      noGzip: config.noGzip,
+      quiet: config.quiet,
+      idField: config.id,
+      foreignKeySuffix: config.foreignKeySuffix,
+      enabled: !config.noStatic
+    };
+    if (config.static) {
+      serverOptions.directory = config.static;
+    }
+    if (config.routes) {
+      serverOptions.routes = config.routes;
+    }
+    if (config.middlewares) {
+      serverOptions.middlewares = config.middlewares;
+    }
+    if (config.delay !== void 0) {
+      serverOptions.delay = config.delay;
+    }
+    const app = await createServer(db, serverOptions);
+    const server = startServer(app, {
+      port: config.port,
+      host: config.host,
+      quiet: config.quiet
+    });
+    if (config.watch && config.source && (0, import_fs3.existsSync)(config.source)) {
+      const watcher = (0, import_chokidar.watch)(config.source, {
+        ignoreInitial: true,
+        persistent: true
+      });
+      watcher.on("change", (path) => {
+        if (!config.quiet) {
+          logger.log("");
+          logger.info(`File changed: ${path}`);
+          logger.info("Reloading database...");
+        }
+        db.init().then(() => {
+          if (!config.quiet) {
+            const data = db.getData();
+            const resources = Object.keys(data);
+            logger.success(
+              `Reloaded ${String(resources.length)} resource(s): ${resources.join(", ")}`
+            );
+          }
+        }).catch((error) => {
+          logger.error(
+            `Failed to reload database: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        });
+      });
+      watcher.on("error", (error) => {
+        logger.error(`Watcher error: ${error instanceof Error ? error.message : String(error)}`);
+      });
+      if (!config.quiet) {
+        logger.info(`Watching ${config.source} for changes...`);
+        logger.log("");
+      }
+      process.on("SIGINT", () => {
+        if (!config.quiet) {
+          logger.log("");
+          logger.info("Shutting down...");
+        }
+        watcher.close().catch(() => {
+        });
+        server.close(() => {
+          process.exit(0);
+        });
+      });
+    }
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  logger.error(`Fatal error: ${error instanceof Error ? error.message : "Unknown error"}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map