@xirconsss/zero-mock 1.0.0 → 1.2.0

package/README.md

@@ -1,37 +1,148 @@
-# Frontend Consumer Test
+# zero-mock
 
-This branch tests `zero-mock` as an end-user using the published npm package.
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.8-blue?logo=typescript&logoColor=white)](tsconfig.json)
+[![npm version](https://img.shields.io/npm/v/@xirconsss/zero-mock.svg)](https://www.npmjs.com/package/@xirconsss/zero-mock)
 
-## How to run
+**zero-mock** is a zero-config Node.js CLI that turns any JSON file into a persistent, production-grade REST API in seconds. It includes an interactive setup wizard, a high-contrast brutalist UI, and smart schema inference with automatic validation.
 
-1. **Install the CLI globally (or run via npx):**
-   ```bash
-   npm install -g @xirconsss/zero-mock
-   ```
+Built for frontend developers and architects who need a realistic, stable backend for prototypes, demos, and integration tests without the overhead of database orchestration.
 
-2. **Start the mock server:**
-   ```bash
-   npx @xirconsss/zero-mock -- --file ./data.json --port 3000
-   ```
+## Key Features
 
-   With simulated delay (2s) and watch, use **long flags** so `npx`/`npm` never treats `-d` as its own debug flag:
+- **Zero-config** — your JSON file is your database and API definition.
+- **Interactive wizard** — run `zero-mock` to start the setup guide.
+- **Smart validation** — automatically infers Zod schemas from your data to validate `POST`, `PUT`, and `PATCH` requests.
+- **Atomic and secure** — cross-platform atomic writes (Windows-safe) with file-locking to prevent data corruption.
+- **Advanced REST** — supports filtering (`_gte`, `_lte`, `_like`), sorting (`_sort`, `_order`), and pagination (`_page`, `_limit`).
+- **Realistic simulation** — simulate network latency and configure custom CORS origins/methods.
+- **Watch mode** — hot-reloads data from disk on manual file changes without a server restart.
+- **Session memory** — remembers your last used configuration for a faster workflow.
 
-   ```bash
-   npx @xirconsss/zero-mock -- --file ./data.json --port 3000 --delay 2000 --watch
-   ```
+---
 
-   If you still see `required option '-f, --file' not specified`, use **`npm exec`** instead:
+## Installation
 
-   ```bash
-   npm exec -- @xirconsss/zero-mock -- --file ./data.json --port 3000 --delay 2000
-   ```
+### Global
 
-   Or install globally and avoid `npx` parsing entirely:
+```bash
+npm install -g @xirconsss/zero-mock
+```
 
-   ```bash
-   zero-mock --file ./data.json --port 3000 --delay 2000
-   ```
+Run the CLI as `zero-mock`.
 
-3. **Run the Frontend:**
-   Simply open `index.html` in your browser.
+### One-off with npx
 
+```bash
+npx @xirconsss/zero-mock
+```
+
+---
+
+## Usage
+
+### 1. Interactive mode (recommended)
+
+Run the command without arguments to launch the setup wizard:
+
+```bash
+zero-mock
+```
+
+### 2. Manual CLI
+
+Pass flags to skip the wizard:
+
+```bash
+zero-mock -f ./data.json -p 8080 -w -d 200
+```
+
+| Flag | Description |
+| ---- | ----------- |
+| `-f`, `--file` | Path to the source JSON file. |
+| `-p`, `--port` | HTTP port (default `3000`, must be 1024–65535). |
+| `-d`, `--delay` | Delay every request by X milliseconds (default `0`). |
+| `-w`, `--watch` | Enable hot-reloading on manual file changes. |
+| `--cors-origin` | Comma-separated allowed origins (default `*`). |
+| `--reset` | Clear saved wizard configuration and exit. |
+
+---
+
+## Auto-generated API
+
+The tool generates full CRUD endpoints for every top-level key in your JSON (e.g., `users`, `posts`).
+
+| Method | Path | Description |
+| ------ | ---- | ----------- |
+| `GET` | `/{resource}` | List items (supports filtering, sorting, paging). |
+| `POST` | `/{resource}` | Create item (auto-id + schema validation). |
+| `GET` | `/{resource}/{id}` | Return a single item by `id`. |
+| `PUT` | `/{resource}/{id}` | Replace item (schema validation). |
+| `PATCH` | `/{resource}/{id}` | Partial update (schema validation). |
+| `DELETE` | `/{resource}/{id}` | Remove item. |
+
+### Advanced List Features
+
+**Filtering**
+
+- `GET /posts?category=tech` — exact match
+- `GET /posts?views_gte=100` — greater than or equal
+- `GET /posts?title_like=hello` — case-insensitive search
+
+**Sorting**
+
+- `GET /posts?_sort=createdAt&_order=desc`
+
+**Pagination**
+
+- `GET /posts?_page=1&_limit=10`
+- Returns an `X-Total-Count` header and a wrapped `{ data, pagination }` object.
+
+---
+
+## JSON Structure
+
+The root must be an object, and every resource must be an array.
+
+```json
+{
+  "users": [
+    { "id": 1, "name": "Alice", "role": "admin" },
+    { "id": 2, "name": "Bob" }
+  ]
+}
+```
+
+Note: zero-mock automatically infers that `role` is an optional string based on the items above.
+
+---
+
+## Development
+
+1. Clone the repo.
+2. `npm install`
+3. `npm run dev` (runs with `ts-node`)
+4. `npm run build` (compiles to `dist/`)
+
+---
+
+## Publishing (Maintainers)
+
+This project uses `semantic-release` for fully automated versioning and npm publishing.
+
+1. Ensure your commits follow the [Conventional Commits](https://www.conventionalcommits.org/) format (e.g., `feat:`, `fix:`, `chore:`).
+2. Push or open a PR against the `main` branch.
+3. GitHub Actions handles testing, version bumping, changelog generation, and publishing to npm.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+## Links
+
+- **Repository:** [github.com/xircons/zero-mock](https://github.com/xircons/zero-mock)
+- **Issues:** [github.com/xircons/zero-mock/issues](https://github.com/xircons/zero-mock/issues)

package/dist/cli-wizard.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PANEL_W = void 0;
+exports.stripAnsi = stripAnsi;
+exports.centerPad = centerPad;
+exports.sectionHeader = sectionHeader;
+exports.renderConfigPanel = renderConfigPanel;
+exports.runWizard = runWizard;
+const prompts_1 = require("@inquirer/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const config_store_1 = require("./config-store");
+exports.PANEL_W = 42;
+function stripAnsi(s) {
+    return s.replace(/\x1B\[[0-9;]*[mGKHF]/g, '');
+}
+function centerPad(text, width = 42) {
+    const stripped = stripAnsi(text);
+    const padding = Math.max(0, Math.floor((width - stripped.length) / 2));
+    return ' '.repeat(padding) + text;
+}
+function sectionHeader(title) {
+    const header = `${picocolors_1.default.blue('◆')} ${picocolors_1.default.bold(picocolors_1.default.white(title))}`;
+    const rule = picocolors_1.default.dim('─'.repeat(exports.PANEL_W));
+    return `${header}\n${rule}`;
+}
+function renderConfigPanel(config, saved) {
+    let out = picocolors_1.default.dim('╭' + '─'.repeat(exports.PANEL_W) + '╮\n');
+    const rows = [
+        { label: 'Target File', value: config.file },
+        { label: 'Default Port', value: config.port },
+        { label: 'Latency', value: `${config.delay}ms` },
+        { label: 'Watch Mode', value: config.watch ? 'Active' : 'Inactive' },
+    ];
+    for (const row of rows) {
+        const labelPadded = ` · ${row.label} `.padEnd(20, ' ');
+        const valRaw = row.value;
+        const spaceCount = Math.max(0, exports.PANEL_W - labelPadded.length - valRaw.length - 3);
+        const spaces = ' '.repeat(spaceCount);
+        out += picocolors_1.default.dim('│') + picocolors_1.default.dim(labelPadded) + picocolors_1.default.white(row.value) + spaces + ' ' + picocolors_1.default.green('✓') + ' ' + picocolors_1.default.dim('│') + '\n';
+    }
+    if (saved) {
+        out += picocolors_1.default.dim('├' + '─'.repeat(exports.PANEL_W) + '┤\n');
+        const footerText = `last used ${(0, config_store_1.formatSavedAt)(saved.savedAt)}`;
+        const footerPadded = ` · ${footerText} `.padEnd(exports.PANEL_W, ' ');
+        out += picocolors_1.default.dim('│') + picocolors_1.default.dim(footerPadded) + picocolors_1.default.dim('│') + '\n';
+    }
+    out += picocolors_1.default.dim('╰' + '─'.repeat(exports.PANEL_W) + '╯');
+    return out;
+}
+const hex = (hexCode, text) => {
+    const r = parseInt(hexCode.slice(1, 3), 16);
+    const g = parseInt(hexCode.slice(3, 5), 16);
+    const b = parseInt(hexCode.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+};
+const FALLBACK = {
+    file: './example/db.json',
+    port: '8080',
+    delay: '200',
+    watch: true,
+};
+async function runWizard() {
+    console.clear();
+    const saved = (0, config_store_1.loadSavedConfig)();
+    const defaults = saved ?? FALLBACK;
+    const isReturning = saved !== null;
+    const logoTop = hex('#bfdbfe', '  ▗▄▄▄▄▖▗▄▄▄▖▗▄▄▖  ▗▄▖ ▗▖  ▗▖ ▗▄▖  ▗▄▄▖▗▖ ▗▖');
+    const logoMid1 = hex('#60a5fa', '     ▗▞▘▐▌   ▐▌ ▐▌▐▌ ▐▌▐▛▚▞▜▌▐▌ ▐▌▐▌   ▐▌▗▞▘');
+    const logoMid2 = hex('#2563eb', '   ▗▞▘  ▐▛▀▀▘▐▛▀▚▖▐▌ ▐▌▐▌  ▐▌▐▌ ▐▌▐▌   ▐▛▚▖ ');
+    const logoBottom = hex('#1e3a8a', '  ▐▙▄▄▄▖▐▙▄▄▖▐▌ ▐▌▝▚▄▞▘▐▌  ▐▌▝▚▄▞▘▝▚▄▄▖▐▌ ▐▌');
+    console.log(`\n${logoTop}\n${logoMid1}\n${logoMid2}\n${logoBottom}\n`);
+    console.log(centerPad(picocolors_1.default.bold(picocolors_1.default.white("Zero-Mock By Xircons"))));
+    console.log(centerPad(picocolors_1.default.dim("Zero-config REST API setup in seconds")));
+    if (isReturning && saved) {
+        console.log(centerPad(picocolors_1.default.dim(`last session ${(0, config_store_1.formatSavedAt)(saved.savedAt)}`)));
+    }
+    console.log('\n' + renderConfigPanel(defaults, saved) + '\n');
+    const promptTheme = { prefix: picocolors_1.default.blue('◆') };
+    const choice = await (0, prompts_1.select)({
+        message: 'What would you like to do?',
+        theme: promptTheme,
+        choices: [
+            { name: `${picocolors_1.default.green('▶')}  Continue`, value: 'continue', short: 'Continue' },
+            { name: `${picocolors_1.default.yellow('◈')}  Change configuration (pick manually)`, value: 'change', short: 'Change configuration' },
+            { name: `${picocolors_1.default.dim('✕')}  Cancel (exit wizard)`, value: 'cancel', short: 'Cancel' },
+        ],
+    });
+    if (choice === 'cancel') {
+        console.clear();
+        console.log(picocolors_1.default.dim('Setup cancelled. zero-mock aborted.'));
+        process.exit(0);
+    }
+    if (choice === 'continue') {
+        console.clear();
+        (0, config_store_1.saveConfig)(defaults, saved);
+        return defaults;
+    }
+    // Change configuration
+    console.clear();
+    console.log('\n' + sectionHeader('CUSTOM CONFIGURATION'));
+    if (isReturning) {
+        console.log(picocolors_1.default.dim('Pre-filled from last session — press Enter to keep\n'));
+    }
+    const file = await (0, prompts_1.input)({
+        message: 'Target File Path:',
+        default: defaults.file,
+        theme: promptTheme,
+        validate: (value) => {
+            if (!value.trim())
+                return "File path cannot be empty.";
+            if (!value.endsWith('.json'))
+                return "File must be a JSON file (.json).";
+            return true;
+        }
+    });
+    const port = await (0, prompts_1.input)({
+        message: 'Port Number:',
+        default: defaults.port,
+        theme: promptTheme,
+        validate: (value) => {
+            const p = parseInt(value, 10);
+            if (isNaN(p) || p < 1 || p > 65535)
+                return "Port must be a number between 1 and 65535.";
+            return true;
+        }
+    });
+    const delay = await (0, prompts_1.input)({
+        message: 'Simulated Latency (ms):',
+        default: defaults.delay,
+        theme: promptTheme,
+        validate: (value) => {
+            const d = parseInt(value, 10);
+            if (isNaN(d) || d < 0)
+                return "Latency must be a non-negative integer.";
+            return true;
+        }
+    });
+    const watch = await (0, prompts_1.confirm)({
+        message: 'Enable Watch Mode (auto-reload on save)?',
+        default: defaults.watch,
+        theme: promptTheme,
+    });
+    const newConfig = { file, port, delay, watch };
+    (0, config_store_1.saveConfig)(newConfig, saved);
+    console.log(`\n  ${picocolors_1.default.green('✓')} Configuration updated.`);
+    console.clear();
+    return newConfig;
+}

package/dist/config-store.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSavedConfig = loadSavedConfig;
+exports.saveConfig = saveConfig;
+exports.clearSavedConfig = clearSavedConfig;
+exports.formatSavedAt = formatSavedAt;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const getConfigPath = () => path_1.default.join(os_1.default.homedir(), '.config', 'zero-mock', 'config.json');
+function loadSavedConfig() {
+    try {
+        const configPath = getConfigPath();
+        if (!fs_1.default.existsSync(configPath)) {
+            return null;
+        }
+        const raw = fs_1.default.readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' &&
+            parsed !== null &&
+            typeof parsed.file === 'string' &&
+            typeof parsed.port === 'string' &&
+            typeof parsed.delay === 'string' &&
+            typeof parsed.watch === 'boolean') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveConfig(config, prev) {
+    try {
+        const configPath = getConfigPath();
+        const configDir = path_1.default.dirname(configPath);
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+        const savedConfig = {
+            ...config,
+            savedAt: new Date().toISOString(),
+            useCount: Math.min((prev?.useCount || 0) + 1, 99999),
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(savedConfig, null, 2), 'utf8');
+    }
+    catch {
+        // Non-fatal, do nothing
+    }
+}
+function clearSavedConfig() {
+    try {
+        const configPath = getConfigPath();
+        if (fs_1.default.existsSync(configPath)) {
+            fs_1.default.unlinkSync(configPath);
+            console.log(`${picocolors_1.default.green('✓')} Cleared saved configuration.`);
+        }
+        else {
+            console.log(`${picocolors_1.default.dim('✕')} No saved configuration found.`);
+        }
+    }
+    catch (err) {
+        console.log(`${picocolors_1.default.red('✕')} Failed to clear config: ${err.message}`);
+    }
+    process.exit(0);
+}
+function formatSavedAt(iso) {
+    const date = new Date(iso);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const mins = Math.floor(diffMs / 60000);
+    if (mins < 2)
+        return "just now";
+    const hours = Math.floor(mins / 60);
+    if (hours < 1)
+        return `${mins}m ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 1)
+        return `${hours}h ago`;
+    if (days < 7)
+        return `${days}d ago`;
+    return date.toLocaleDateString(undefined, { month: 'short', day: 'numeric' });
+}

package/dist/errors.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printError = printError;
+exports.printFatal = printFatal;
+exports.validateConfig = validateConfig;
+exports.acquireLock = acquireLock;
+const picocolors_1 = __importDefault(require("picocolors"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ERROR_MESSAGES = {
+    FILE_NOT_FOUND: { msg: 'Target JSON file not found.', hint: 'Check if the file path is correct.' },
+    FILE_NOT_JSON: { msg: 'Target file is not a JSON file.', hint: 'Ensure the file ends with .json.' },
+    FILE_UNREADABLE: { msg: 'Cannot read the target file.', hint: 'Check file permissions.' },
+    JSON_INVALID: { msg: 'Invalid JSON format.', hint: 'Check the file for syntax errors.' },
+    JSON_NOT_OBJECT: { msg: 'JSON root is not an object.', hint: 'The JSON file must have an object at its root.' },
+    JSON_EMPTY: { msg: 'JSON file is empty.', hint: 'The API will start with no resources. Add arrays to the root object.' },
+    PORT_IN_USE: { msg: 'Port is already in use.', hint: 'Choose a different port or kill the process using it.' },
+    PORT_INVALID: { msg: 'Invalid port number.', hint: 'Port must be an integer between 1024 and 65535.' },
+    PORT_PRIVILEGED: { msg: 'Port requires root privileges.', hint: 'Use a port number >= 1024.' },
+    LOCK_STALE: { msg: 'Found a stale lock file.', hint: 'The lock file will be automatically removed.' },
+    LOCK_CONFLICT: { msg: 'Another instance is running.', hint: 'Stop the other zero-mock instance or use a different file.' },
+    LOCK_WRITE_FAILED: { msg: 'Failed to write lock file.', hint: 'Check directory permissions.' },
+    WATCH_FAILED: { msg: 'File watcher failed to start.', hint: 'Hot-reloading will not work. Check OS file watch limits.' },
+    WATCH_RELOAD_FAILED: { msg: 'Failed to reload JSON file.', hint: 'Fix the JSON syntax error. Serving last good snapshot.' },
+    SERVER_CRASH: { msg: 'Server crashed unexpectedly.', hint: 'Check the error details below.' },
+    UNKNOWN: { msg: 'An unknown error occurred.', hint: 'Please report this issue.' },
+};
+function formatErrorBlock(type, code, detail) {
+    const badge = type === 'ERROR'
+        ? picocolors_1.default.red(picocolors_1.default.bold(picocolors_1.default.inverse(' ERROR ')))
+        : picocolors_1.default.yellow(picocolors_1.default.bold(picocolors_1.default.inverse(' WARN  ')));
+    const { msg, hint } = ERROR_MESSAGES[code];
+    let out = `\n  ${badge}  ${picocolors_1.default.bold(picocolors_1.default.white(msg))}\n`;
+    if (detail) {
+        out += `  ${picocolors_1.default.dim('│')}  ${picocolors_1.default.dim(detail)}\n`;
+    }
+    out += `  ${picocolors_1.default.dim('╰─')}  ${picocolors_1.default.blue(hint)}\n`;
+    return out;
+}
+function printError(code, detail) {
+    console.error(formatErrorBlock('WARN', code, detail));
+}
+function printFatal(code, detail) {
+    console.error(formatErrorBlock('ERROR', code, detail));
+    process.exit(1);
+}
+function validateConfig(file, port) {
+    if (path_1.default.extname(file) !== '.json') {
+        printFatal('FILE_NOT_JSON', `Path: ${file}`);
+    }
+    if (!fs_1.default.existsSync(file)) {
+        printFatal('FILE_NOT_FOUND', `Path: ${file}`);
+    }
+    try {
+        fs_1.default.accessSync(file, fs_1.default.constants.R_OK);
+    }
+    catch (e) {
+        printFatal('FILE_UNREADABLE', e.message);
+    }
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        printFatal('PORT_INVALID', `Given: ${port}`);
+    }
+    if (port < 1024) {
+        printFatal('PORT_PRIVILEGED', `Given: ${port}`);
+    }
+}
+function acquireLock(file) {
+    const lockFilePath = `${file}.zero-mock.lock`;
+    if (fs_1.default.existsSync(lockFilePath)) {
+        try {
+            const lockData = fs_1.default.readFileSync(lockFilePath, 'utf8');
+            const { pid, startedAt } = JSON.parse(lockData);
+            try {
+                process.kill(pid, 0); // test liveness
+                // Alive
+                printFatal('LOCK_CONFLICT', `PID ${pid} since ${startedAt}`);
+            }
+            catch (e) {
+                if (e.code === 'ESRCH') {
+                    // Stale
+                    printError('LOCK_STALE', `PID ${pid} is dead.`);
+                    fs_1.default.unlinkSync(lockFilePath);
+                }
+                else {
+                    // No permission or other error
+                    printFatal('LOCK_CONFLICT', `Unable to check PID ${pid}.`);
+                }
+            }
+        }
+        catch (e) {
+            // Unreadable or invalid lock file format
+            printError('LOCK_STALE', `Invalid lock file format.`);
+            fs_1.default.unlinkSync(lockFilePath);
+        }
+    }
+    try {
+        fs_1.default.writeFileSync(lockFilePath, JSON.stringify({
+            pid: process.pid,
+            startedAt: new Date().toISOString()
+        }), { flag: 'wx' });
+    }
+    catch (e) {
+        if (e.code === 'EEXIST') {
+            printFatal('LOCK_CONFLICT', 'Lock file appeared during race condition.');
+        }
+        else {
+            printFatal('LOCK_WRITE_FAILED', e.message);
+        }
+    }
+    const cleanup = () => {
+        try {
+            if (fs_1.default.existsSync(lockFilePath)) {
+                fs_1.default.unlinkSync(lockFilePath);
+            }
+        }
+        catch (_) { /* ignore cleanup errors */ }
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => { cleanup(); process.exit(130); });
+    process.on('SIGTERM', () => { cleanup(); process.exit(143); });
+    process.on('uncaughtException', (err) => {
+        cleanup();
+        printFatal('SERVER_CRASH', err.message);
+    });
+}

package/dist/index.js

@@ -1,10 +1,50 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
+const chokidar = __importStar(require("chokidar"));
+const picocolors_1 = __importDefault(require("picocolors"));
 const commander_1 = require("commander");
 const jsonStore_1 = require("./store/jsonStore");
 const bootstrap_1 = require("./server/bootstrap");
+const cli_wizard_1 = require("./cli-wizard");
+const errors_1 = require("./errors");
+const config_store_1 = require("./config-store");
 function parseDelayMs(raw) {
     const trimmed = raw.trim();
     if (!/^\d+$/.test(trimmed)) {
@@ -12,77 +52,114 @@ function parseDelayMs(raw) {
     }
     return Number.parseInt(trimmed, 10);
 }
+const program = new commander_1.Command();
+let watcher = null;
 function startFileWatcher(filePath) {
-    let reloadInFlight = false;
+    let reloadTimeout = null;
+    if (watcher) {
+        watcher.close().catch(() => { });
+        watcher = null;
+    }
     const reload = async () => {
-        if (reloadInFlight) {
-            return;
-        }
-        reloadInFlight = true;
         try {
-            await jsonStore_1.JsonStore.load(filePath);
+            await jsonStore_1.JsonStore.load(filePath, true);
+            console.log(`\n  ${picocolors_1.default.dim('│')}  ${picocolors_1.default.green('✓')} ${picocolors_1.default.dim('Hot reloaded data from')} ${picocolors_1.default.white(filePath)}`);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[watch] Could not reload "${filePath}": ${message}`);
-        }
-        finally {
-            reloadInFlight = false;
+            (0, errors_1.printError)('WATCH_RELOAD_FAILED', err.message);
         }
     };
     try {
-        (0, fs_1.watch)(filePath, { persistent: true }, () => {
-            void reload();
+        watcher = chokidar.watch(filePath, { persistent: true, ignoreInitial: true });
+        watcher
+            .on("change", () => {
+            if (reloadTimeout)
+                clearTimeout(reloadTimeout);
+            reloadTimeout = setTimeout(() => void reload(), 100);
+        })
+            .on("error", (err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, errors_1.printError)('WATCH_FAILED', msg);
         });
-        console.log(`[watch] Watching "${filePath}" for changes.`);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`[watch] Failed to watch "${filePath}": ${message}`);
+        (0, errors_1.printError)('WATCH_FAILED', err.message);
     }
 }
-const program = new commander_1.Command();
 program
     .name("zero-mock")
     .description("Generate a REST API from a JSON file")
-    .requiredOption("-f, --file <path>", "path to the source JSON file")
-    .option("-p, --port <number>", "HTTP port", "3000")
-    .option("-d, --delay <ms>", "delay each request by this many ms (0 = off)", "0")
-    .option("-w, --watch", "reload JSON from disk when the file changes", false)
+    .option("-f, --file <path>", "path to the source JSON file")
+    .option("-p, --port <number>", "HTTP port")
+    .option("-d, --delay <ms>", "delay each request by this many ms (0 = off)")
+    .option("-w, --watch", "reload JSON from disk when the file changes")
+    .option("--cors-origin <origins>", "comma-separated list of allowed origins (e.g., http://localhost:3000)", "*")
+    .option("--cors-methods <methods>", "comma-separated list of allowed HTTP methods", "GET,HEAD,PUT,PATCH,POST,DELETE")
+    .option("--cors-credentials", "enable CORS credentials (cookies, authorization headers)", false)
+    .option("--reset", "clear saved wizard configuration")
     .action(async (opts) => {
-    const port = Number.parseInt(opts.port, 10);
-    if (Number.isNaN(port) || port < 1 || port > 65535) {
-        console.error("error: --port must be a number between 1 and 65535");
-        process.exit(1);
-        return;
+    if (process.argv.includes('--reset')) {
+        (0, config_store_1.clearSavedConfig)();
+        process.exit(0);
     }
-    const delayMs = parseDelayMs(opts.delay);
+    let { file, port: portRaw, delay: delayRaw, watch } = opts;
+    if (!file && !portRaw && !delayRaw && watch === undefined) {
+        const wizardConfig = await (0, cli_wizard_1.runWizard)();
+        file = wizardConfig.file;
+        portRaw = wizardConfig.port;
+        delayRaw = wizardConfig.delay;
+        watch = wizardConfig.watch;
+    }
+    else {
+        if (!file) {
+            console.error("error: required option '-f, --file <path>' not specified");
+            process.exit(1);
+            return;
+        }
+        portRaw = portRaw ?? "3000";
+        delayRaw = delayRaw ?? "0";
+        watch = watch ?? false;
+    }
+    const port = Number.parseInt(portRaw, 10);
+    const delayMs = parseDelayMs(delayRaw);
     if (delayMs === null) {
         console.error("error: --delay must be a non-negative integer");
         process.exit(1);
         return;
     }
-    const filePath = opts.file;
+    const filePath = file;
+    // Ordered Validation Step 1 & 2
+    (0, errors_1.validateConfig)(filePath, port);
+    (0, errors_1.acquireLock)(filePath);
     try {
         await jsonStore_1.JsonStore.load(filePath);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(message);
-        process.exit(1);
-        return;
+        // JsonStore.load handles its own printFatal internally, 
+        // but we catch to ensure we don't crash without formatting.
+        (0, errors_1.printFatal)('UNKNOWN', err.message);
     }
     try {
-        await (0, bootstrap_1.bootstrap)(port, { delayMs });
+        await (0, bootstrap_1.bootstrap)(port, filePath, watch, {
+            delayMs,
+            corsOrigin: opts.corsOrigin,
+            corsMethods: opts.corsMethods,
+            corsCredentials: opts.corsCredentials,
+        });
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Failed to start server: ${message}`);
-        process.exit(1);
-        return;
+        // Bootstrap will handle EADDRINUSE internally, catching just in case.
+        (0, errors_1.printFatal)('UNKNOWN', err.message);
     }
-    if (opts.watch) {
+    if (watch) {
         startFileWatcher(filePath);
     }
+    const cleanup = () => {
+        if (watcher) {
+            watcher.close().catch(() => { });
+        }
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
 });
 program.parse(process.argv);

package/dist/server/app.js

@@ -7,19 +7,14 @@ exports.createApp = createApp;
 const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
 const dynamicRouter_1 = require("./routes/dynamicRouter");
+const logger_1 = require("./logger");
 const errorHandler = (err, _req, res, _next) => {
     if (res.headersSent) {
         return;
     }
     const message = err instanceof Error ? err.message : String(err);
-    res.status(500).json({ error: message });
+    res.status(500).json({ error: "INTERNAL_SERVER_ERROR", message, statusCode: 500 });
 };
-function requestLoggingMiddleware(req, res, next) {
-    res.on("finish", () => {
-        console.log(`[${req.method}] ${req.path} - ${res.statusCode}`);
-    });
-    next();
-}
 function delayMiddleware(delayMs) {
     return (_req, _res, next) => {
         if (delayMs <= 0) {
@@ -31,9 +26,13 @@ function delayMiddleware(delayMs) {
 }
 function createApp(options) {
     const app = (0, express_1.default)();
-    app.use((0, cors_1.default)());
+    app.use((0, cors_1.default)({
+        origin: options.corsOrigin && options.corsOrigin !== "*" ? options.corsOrigin.split(",") : "*",
+        methods: options.corsMethods || "GET,HEAD,PUT,PATCH,POST,DELETE",
+        credentials: options.corsCredentials || false,
+    }));
     app.use(express_1.default.json());
-    app.use(requestLoggingMiddleware);
+    app.use(logger_1.requestLoggingMiddleware);
     app.use(delayMiddleware(options.delayMs));
     app.use("/", (0, dynamicRouter_1.buildDynamicRouter)());
     app.use(errorHandler);

package/dist/server/bootstrap.js

@@ -3,20 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bootstrap = bootstrap;
 const app_1 = require("./app");
 const jsonStore_1 = require("../store/jsonStore");
-async function bootstrap(port, appOptions) {
+const logger_1 = require("./logger");
+const errors_1 = require("../errors");
+async function bootstrap(port, file, watch, appOptions) {
     const app = (0, app_1.createApp)(appOptions);
     await new Promise((resolve, reject) => {
         const server = app.listen(port, () => {
             resolve();
         });
-        server.on("error", reject);
+        server.on("error", (e) => {
+            if (e.code === 'EADDRINUSE') {
+                (0, errors_1.printFatal)('PORT_IN_USE', `Port ${port} — ${e.message}`);
+            }
+            else {
+                (0, errors_1.printFatal)('UNKNOWN', e.message);
+            }
+            reject(e);
+        });
     });
-    const base = `http://localhost:${port}`;
-    console.log(`🚀 Server is running at ${base}`);
-    console.log("Read/write API: GET, POST, PUT, PATCH, DELETE are active for each resource below.\n");
-    for (const resource of Object.keys(jsonStore_1.JsonStore.getData())) {
-        console.log(`  ${resource}`);
-        console.log(`    GET    POST              ${base}/${resource}`);
-        console.log(`    GET    PUT   PATCH DELETE  ${base}/${resource}/:id`);
-    }
+    const resources = Object.keys(jsonStore_1.JsonStore.getData());
+    (0, logger_1.printStartupBanner)(file, port, watch, appOptions.delayMs, resources);
 }

package/dist/server/logger.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMethodBadge = getMethodBadge;
+exports.requestLoggingMiddleware = requestLoggingMiddleware;
+exports.getMonochromeBadge = getMonochromeBadge;
+exports.printStartupBanner = printStartupBanner;
+const picocolors_1 = __importDefault(require("picocolors"));
+const cli_wizard_1 = require("../cli-wizard");
+function getMethodBadge(method) {
+    const m = method.toUpperCase();
+    const padded = m.padEnd(6, ' ');
+    const inner = `[${padded}]`;
+    switch (m) {
+        case 'GET': return picocolors_1.default.bold(picocolors_1.default.cyan(inner));
+        case 'POST': return picocolors_1.default.bold(picocolors_1.default.green(inner));
+        case 'PUT': return picocolors_1.default.bold(picocolors_1.default.yellow(inner));
+        case 'PATCH': return picocolors_1.default.bold(picocolors_1.default.magenta(inner));
+        case 'DELETE': return picocolors_1.default.bold(picocolors_1.default.red(inner));
+        default: return picocolors_1.default.bold(picocolors_1.default.white(inner));
+    }
+}
+function requestLoggingMiddleware(req, res, next) {
+    const startMs = Date.now();
+    const start = new Date();
+    res.on("finish", () => {
+        const timeStr = start.toLocaleTimeString('en-US', { hour12: true });
+        const duration = Date.now() - startMs;
+        const badge = getMethodBadge(req.method);
+        let statusStr = String(res.statusCode);
+        if (res.statusCode >= 200 && res.statusCode < 300)
+            statusStr = picocolors_1.default.green(statusStr);
+        else if (res.statusCode >= 300 && res.statusCode < 400)
+            statusStr = picocolors_1.default.cyan(statusStr);
+        else if (res.statusCode >= 400 && res.statusCode < 500)
+            statusStr = picocolors_1.default.yellow(statusStr);
+        else if (res.statusCode >= 500)
+            statusStr = picocolors_1.default.red(statusStr);
+        const pathPadded = req.path.length > 20 ? req.path : req.path.padEnd(20, ' ');
+        console.log(`${picocolors_1.default.dim(`[${timeStr}]`)} ${badge} ${picocolors_1.default.white(pathPadded)} ${statusStr} ${picocolors_1.default.dim(`${duration}ms`)}`);
+    });
+    next();
+}
+function getMonochromeBadge(method) {
+    const m = method.toUpperCase();
+    const padded = m.padEnd(6, ' ');
+    return `[${padded}]`;
+}
+function printStartupBanner(file, port, isWatch, delayMs, resources) {
+    console.log('\n' + (0, cli_wizard_1.sectionHeader)('SERVER READY'));
+    console.log((0, cli_wizard_1.renderConfigPanel)({
+        file,
+        port: String(port),
+        delay: String(delayMs),
+        watch: isWatch
+    }) + '\n');
+    console.log((0, cli_wizard_1.sectionHeader)('AVAILABLE RESOURCES'));
+    const base = `http://localhost:${port}`;
+    const get = getMonochromeBadge('GET');
+    const post = getMonochromeBadge('POST');
+    const put = getMonochromeBadge('PUT');
+    const patch = getMonochromeBadge('PATCH');
+    const del = getMonochromeBadge('DELETE');
+    for (const resource of resources) {
+        console.log(picocolors_1.default.bold(picocolors_1.default.white(`■ /${resource}`)));
+        const methodsLeft1 = `  ${get}  ${post}`;
+        const methodsLeft2 = `  ${get}  ${put}  ${patch}  ${del}`;
+        // Align URLs at column 45
+        const pad1 = ' '.repeat(Math.max(1, 45 - (0, cli_wizard_1.stripAnsi)(methodsLeft1).length));
+        const pad2 = ' '.repeat(Math.max(1, 45 - (0, cli_wizard_1.stripAnsi)(methodsLeft2).length));
+        console.log(`${methodsLeft1}${pad1}${picocolors_1.default.white(`${base}/${resource}`)}`);
+        console.log(`${methodsLeft2}${pad2}${picocolors_1.default.white(`${base}/${resource}/:id`)}\n`);
+    }
+    console.log((0, cli_wizard_1.sectionHeader)('REQUEST LOGS'));
+    console.log(`${picocolors_1.default.green('✓')} ${picocolors_1.default.dim('Ready on')} ${picocolors_1.default.white(`${base}`)}\n`);
+}

package/dist/server/routes/dynamicRouter.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDynamicRouter = buildDynamicRouter;
 const crypto_1 = require("crypto");
 const express_1 = __importDefault(require("express"));
+const zod_1 = require("zod");
 const jsonStore_1 = require("../../store/jsonStore");
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -44,27 +45,74 @@ function parsePagination(query) {
     return { page, limit };
 }
 function filterCollection(items, query) {
-    const filterEntries = Object.entries(query).filter(([k]) => k !== "_page" && k !== "_limit");
+    let result = items;
+    // Sorting
+    const sort = firstQueryValue(query["_sort"]);
+    const order = firstQueryValue(query["_order"])?.toLowerCase() === "desc" ? -1 : 1;
+    if (sort) {
+        result = [...result].sort((a, b) => {
+            if (!isPlainObject(a) || !isPlainObject(b))
+                return 0;
+            const valA = a[sort];
+            const valB = b[sort];
+            if (valA === valB)
+                return 0;
+            if (valA === undefined)
+                return order;
+            if (valB === undefined)
+                return -order;
+            if (typeof valA === "number" && typeof valB === "number")
+                return (valA - valB) * order;
+            return String(valA).localeCompare(String(valB)) * order;
+        });
+    }
+    const filterEntries = Object.entries(query).filter(([k]) => !["_page", "_limit", "_sort", "_order"].includes(k));
     if (filterEntries.length === 0) {
-        return items;
+        return result;
     }
-    return items.filter((item) => {
+    return result.filter((item) => {
         if (!isPlainObject(item)) {
             return false;
         }
         const rec = item;
         for (const [key, qVal] of filterEntries) {
             const want = firstQueryValue(qVal);
-            if (want === undefined) {
+            if (want === undefined)
                 continue;
+            let field = key;
+            let op = "eq";
+            if (key.endsWith("_gte")) {
+                field = key.slice(0, -4);
+                op = "gte";
             }
-            if (!Object.prototype.hasOwnProperty.call(rec, key)) {
-                return false;
+            else if (key.endsWith("_lte")) {
+                field = key.slice(0, -4);
+                op = "lte";
             }
-            if (rec[key] == want) {
-                continue;
+            else if (key.endsWith("_like")) {
+                field = key.slice(0, -5);
+                op = "like";
+            }
+            const actual = rec[field];
+            if (op === "eq") {
+                if (actual != want)
+                    return false;
+            }
+            else if (op === "gte") {
+                if (Number(actual) < Number(want))
+                    return false;
+            }
+            else if (op === "lte") {
+                if (Number(actual) > Number(want))
+                    return false;
+            }
+            else if (op === "like") {
+                if (actual === undefined || actual === null)
+                    return false;
+                const escaped = want.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                if (!new RegExp(escaped, 'i').test(String(actual)))
+                    return false;
             }
-            return false;
         }
         return true;
     });
@@ -98,6 +146,43 @@ function itemNotFound(res, resource, id) {
 function badBody(res) {
     res.status(400).json({ error: "Request body must be a JSON object." });
 }
+/**
+ * Infer a zod schema from the first item in a collection.
+ * Returns null if the collection is empty (skip validation).
+ * The schema is "partial" so that POST/PATCH with missing optional fields still pass —
+ * only fields that ARE present are type-checked.
+ */
+function inferSchema(collection) {
+    const first = collection.find(isPlainObject);
+    if (!first)
+        return null;
+    const shape = {};
+    for (const [key, value] of Object.entries(first)) {
+        if (key === "id")
+            continue;
+        if (typeof value === "string")
+            shape[key] = zod_1.z.string();
+        else if (typeof value === "number")
+            shape[key] = zod_1.z.number();
+        else if (typeof value === "boolean")
+            shape[key] = zod_1.z.boolean();
+        else
+            shape[key] = zod_1.z.unknown();
+    }
+    return zod_1.z.object(shape).partial();
+}
+function validateBody(res, collection, body) {
+    const schema = inferSchema(collection);
+    if (!schema)
+        return true; // empty collection → skip
+    const result = schema.safeParse(body);
+    if (!result.success) {
+        const messages = result.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`);
+        res.status(400).json({ error: "Validation failed.", details: messages });
+        return false;
+    }
+    return true;
+}
 function numericIdValue(id) {
     if (typeof id === "number" && Number.isFinite(id) && Number.isInteger(id)) {
         return id;
@@ -151,10 +236,23 @@ function buildDynamicRouter() {
             const collection = jsonStore_1.JsonStore.getData()[resource];
             const query = req.query;
             let rows = filterCollection(collection, query);
+            const total = rows.length;
+            res.setHeader("X-Total-Count", total);
             const pageInfo = parsePagination(query);
             if (pageInfo !== null) {
                 const start = (pageInfo.page - 1) * pageInfo.limit;
                 rows = rows.slice(start, start + pageInfo.limit);
+                const totalPages = Math.ceil(total / pageInfo.limit);
+                res.json({
+                    data: rows,
+                    pagination: {
+                        total,
+                        page: pageInfo.page,
+                        limit: pageInfo.limit,
+                        totalPages
+                    }
+                });
+                return;
             }
             res.json(rows);
         });
@@ -164,6 +262,8 @@ function buildDynamicRouter() {
                 return;
             }
             const collection = jsonStore_1.JsonStore.getData()[resource];
+            if (!validateBody(res, collection, req.body))
+                return;
             const newId = nextIdForCollection(collection);
             const rawBody = req.body;
             const rest = { ...rawBody };
@@ -180,6 +280,8 @@ function buildDynamicRouter() {
             }
             const { id: idParam } = req.params;
             const collection = jsonStore_1.JsonStore.getData()[resource];
+            if (!validateBody(res, collection, req.body))
+                return;
             const index = findIndexById(collection, idParam);
             if (index === -1) {
                 itemNotFound(res, resource, idParam);
@@ -202,6 +304,8 @@ function buildDynamicRouter() {
             }
             const { id: idParam } = req.params;
             const collection = jsonStore_1.JsonStore.getData()[resource];
+            if (!validateBody(res, collection, req.body))
+                return;
             const index = findIndexById(collection, idParam);
             if (index === -1) {
                 itemNotFound(res, resource, idParam);

package/dist/store/jsonStore.js

@@ -1,51 +1,62 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonStore = void 0;
 const crypto_1 = require("crypto");
 const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
 const promises_1 = require("fs/promises");
+const errors_1 = require("../errors");
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseJsonStorePayload(raw, filePath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Invalid JSON in "${filePath}": ${message}`);
-    }
-    if (!isPlainObject(parsed)) {
-        throw new Error(`JSON root in "${filePath}" must be a non-null object (got ${parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed}).`);
-    }
-    const data = {};
-    for (const [key, value] of Object.entries(parsed)) {
-        if (!Array.isArray(value)) {
-            throw new Error(`Invalid mock database shape in "${filePath}": property "${key}" must be an array.`);
-        }
-        data[key] = value;
-    }
-    return data;
-}
 class JsonStoreImpl {
     data = {};
     backingPath = null;
     /** Serializes concurrent save() calls so writes are not interleaved. */
     saveChain = Promise.resolve();
-    async load(filePath) {
+    async load(filePath, isReload = false) {
         let raw;
         try {
             raw = await (0, promises_1.readFile)(filePath, "utf8");
         }
         catch (err) {
-            const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
-            const message = err instanceof Error ? err.message : String(err);
-            throw new Error(code
-                ? `Could not read JSON file "${filePath}" (${code}): ${message}`
-                : `Could not read JSON file "${filePath}": ${message}`);
+            if (isReload)
+                throw new Error(`Unreadable: ${err.message}`);
+            (0, errors_1.printFatal)('FILE_UNREADABLE', err.message);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            if (isReload)
+                throw new Error(`Parse error: ${err.message}`);
+            (0, errors_1.printFatal)('JSON_INVALID', err.message);
+        }
+        if (!isPlainObject(parsed)) {
+            const msg = `got ${parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed}`;
+            if (isReload)
+                throw new Error(`Root not an object (${msg})`);
+            (0, errors_1.printFatal)('JSON_NOT_OBJECT', msg);
+        }
+        const keys = Object.keys(parsed);
+        if (keys.length === 0) {
+            (0, errors_1.printError)('JSON_EMPTY');
+        }
+        const data = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!Array.isArray(value)) {
+                const msg = `property "${key}" must be an array.`;
+                if (isReload)
+                    throw new Error(msg);
+                (0, errors_1.printFatal)('JSON_INVALID', msg);
+            }
+            data[key] = value;
         }
-        this.data = parseJsonStorePayload(raw, filePath);
+        this.data = data;
         this.backingPath = filePath;
     }
     getData() {
@@ -66,10 +77,22 @@ class JsonStoreImpl {
             const payload = `${JSON.stringify(this.data, null, 2)}\n`;
             try {
                 await (0, promises_1.writeFile)(tmp, payload, "utf8");
-                await (0, promises_1.rename)(tmp, target);
+                try {
+                    fs_1.default.renameSync(tmp, target);
+                }
+                catch (e) {
+                    if (e.code === 'EXDEV') {
+                        fs_1.default.copyFileSync(tmp, target);
+                        fs_1.default.unlinkSync(tmp);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
             }
             catch (err) {
-                await (0, promises_1.unlink)(tmp).catch(() => { });
+                if (fs_1.default.existsSync(tmp))
+                    fs_1.default.unlinkSync(tmp);
                 const message = err instanceof Error ? err.message : String(err);
                 throw new Error(`Could not write JSON file "${target}": ${message}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xirconsss/zero-mock",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Zero-config CLI that generates REST APIs from JSON files",
   "license": "MIT",
   "keywords": [
@@ -47,9 +47,14 @@
   },
   "homepage": "https://github.com/xircons/zero-mock#readme",
   "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "cors": "^2.8.5",
-    "express": "^4.21.2"
+    "express": "^4.21.2",
+    "gradient-string": "^3.0.0",
+    "picocolors": "^1.1.1",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@commitlint/cli": "^21.0.2",
@@ -62,6 +67,7 @@
     "@semantic-release/release-notes-generator": "^14.1.1",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
+    "@types/gradient-string": "^1.1.6",
     "@types/node": "^22.14.0",
     "@vitest/coverage-v8": "^2.1.9",
     "husky": "^9.1.7",

package/example/db.json

@@ -1,45 +0,0 @@
-{
-  "users": [
-    {
-      "id": 1,
-      "name": "Ada Lovelace",
-      "email": "ada@example.com",
-      "role": "admin"
-    },
-    {
-      "id": 2,
-      "name": "Grace Hopper",
-      "email": "grace@example.com",
-      "role": "editor"
-    },
-    {
-      "id": 3,
-      "name": "Margaret Hamilton",
-      "email": "margaret@example.com",
-      "role": "viewer"
-    }
-  ],
-  "posts": [
-    {
-      "id": "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
-      "title": "Shipping a mock API in minutes",
-      "body": "Point zero-mock at a JSON file and iterate on your UI without waiting on backend tickets.",
-      "userId": 1,
-      "published": true
-    },
-    {
-      "id": "b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e",
-      "title": "Why atomic writes matter",
-      "body": "Your JSON file stays the source of truth—even when multiple tabs hit the API at once.",
-      "userId": 2,
-      "published": false
-    },
-    {
-      "id": "c3d4e5f6-a7b8-4c9d-0e1f-2a3b4c5d6e7f",
-      "title": "Frontend-first workflows",
-      "body": "Prototype with realistic CRUD, then swap the mock for a production API when you are ready.",
-      "userId": 1,
-      "published": true
-    }
-  ]
-}