json-server 1.0.0-beta.1 → 1.0.0-beta.10

package/lib/bin.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { extname } from 'node:path';
-import { parseArgs } from 'node:util';
-import chalk from 'chalk';
-import { watch } from 'chokidar';
-import JSON5 from 'json5';
-import { Low } from 'lowdb';
-import { DataFile, JSONFile } from 'lowdb/node';
-import { fileURLToPath } from 'node:url';
-import { createApp } from './app.js';
-import { Observer } from './observer.js';
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { extname } from "node:path";
+import { parseArgs } from "node:util";
+import chalk from "chalk";
+import { watch } from "chokidar";
+import JSON5 from "json5";
+import { Low } from "lowdb";
+import { DataFile, JSONFile } from "lowdb/node";
+import { fileURLToPath } from "node:url";
+import { createApp } from "./app.js";
+import { Observer } from "./observer.js";
 function help() {
     console.log(`Usage: json-server [options] <file>
 
@@ -27,44 +27,44 @@ function args() {
         const { values, positionals } = parseArgs({
             options: {
                 port: {
-                    type: 'string',
-                    short: 'p',
-                    default: process.env['PORT'] ?? '3000',
+                    type: "string",
+                    short: "p",
+                    default: process.env["PORT"] ?? "3000",
                 },
                 host: {
-                    type: 'string',
-                    short: 'h',
-                    default: process.env['HOST'] ?? 'localhost',
+                    type: "string",
+                    short: "h",
+                    default: process.env["HOST"] ?? "localhost",
                 },
                 static: {
-                    type: 'string',
-                    short: 's',
+                    type: "string",
+                    short: "s",
                     multiple: true,
                     default: [],
                 },
                 help: {
-                    type: 'boolean',
+                    type: "boolean",
                 },
                 version: {
-                    type: 'boolean',
+                    type: "boolean",
                 },
                 // Deprecated
                 watch: {
-                    type: 'boolean',
-                    short: 'w',
+                    type: "boolean",
+                    short: "w",
                 },
             },
             allowPositionals: true,
         });
         // --version
         if (values.version) {
-            const pkg = JSON.parse(readFileSync(fileURLToPath(new URL('../package.json', import.meta.url)), 'utf-8'));
+            const pkg = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf-8"));
             console.log(pkg.version);
             process.exit();
         }
         // Handle --watch
         if (values.watch) {
-            console.log(chalk.yellow('--watch/-w can be omitted, JSON Server 1+ watches for file changes by default'));
+            console.log(chalk.yellow("--watch/-w can be omitted, JSON Server 1+ watches for file changes by default"));
         }
         if (values.help || positionals.length === 0) {
             help();
@@ -72,15 +72,15 @@ function args() {
         }
         // App args and options
         return {
-            file: positionals[0] ?? '',
+            file: positionals[0] ?? "",
             port: parseInt(values.port),
             host: values.host,
             static: values.static,
         };
     }
     catch (e) {
-        if (e.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
-            console.log(chalk.red(e.message.split('.')[0]));
+        if (e.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+            console.log(chalk.red(e.message.split(".")[0]));
             help();
             process.exit(1);
         }
@@ -95,12 +95,12 @@ if (!existsSync(file)) {
     process.exit(1);
 }
 // Handle empty string JSON file
-if (readFileSync(file, 'utf-8').trim() === '') {
-    writeFileSync(file, '{}');
+if (readFileSync(file, "utf-8").trim() === "") {
+    writeFileSync(file, "{}");
 }
 // Set up database
 let adapter;
-if (extname(file) === '.json5') {
+if (extname(file) === ".json5") {
     adapter = new DataFile(file, {
         parse: JSON5.parse,
         stringify: JSON5.stringify,
@@ -115,41 +115,42 @@ await db.read();
 // Create app
 const app = createApp(db, { logger: false, static: staticArr });
 function logRoutes(data) {
-    console.log(chalk.bold('Endpoints:'));
+    console.log(chalk.bold("Endpoints:"));
     if (Object.keys(data).length === 0) {
         console.log(chalk.gray(`No endpoints found, try adding some data to ${file}`));
         return;
     }
     console.log(Object.keys(data)
         .map((key) => `${chalk.gray(`http://${host}:${port}/`)}${chalk.blue(key)}`)
-        .join('\n'));
+        .join("\n"));
 }
-const kaomojis = ['♡⸜(˶˃ ᵕ ˂˶)⸝♡', '♡( ◡‿◡ )', '( ˶ˆ ᗜ ˆ˵ )', '(˶ᵔ ᵕ ᵔ˶)'];
+const kaomojis = ["♡⸜(˶˃ ᵕ ˂˶)⸝♡", "♡( ◡‿◡ )", "( ˶ˆ ᗜ ˆ˵ )", "(˶ᵔ ᵕ ᵔ˶)"];
 function randomItem(items) {
     const index = Math.floor(Math.random() * items.length);
-    return items.at(index) ?? '';
+    return items.at(index) ?? "";
 }
 app.listen(port, () => {
     console.log([
         chalk.bold(`JSON Server started on PORT :${port}`),
-        chalk.gray('Press CTRL-C to stop'),
+        chalk.gray("Press CTRL-C to stop"),
         chalk.gray(`Watching ${file}...`),
-        '',
+        "",
         chalk.magenta(randomItem(kaomojis)),
-        '',
-        chalk.bold('Index:'),
+        "",
+        chalk.bold("Index:"),
         chalk.gray(`http://localhost:${port}/`),
-        '',
-        chalk.bold('Static files:'),
-        chalk.gray('Serving ./public directory if it exists'),
-        '',
-    ].join('\n'));
+        "",
+        chalk.bold("Static files:"),
+        chalk.gray("Serving ./public directory if it exists"),
+        "",
+    ].join("\n"));
     logRoutes(db.data);
 });
 // Watch file for changes
-if (process.env['NODE_ENV'] !== 'production') {
+if (process.env["NODE_ENV"] !== "production") {
     let writing = false; // true if the file is being written to by the app
-    let prevEndpoints = '';
+    let hadReadError = false;
+    let prevEndpoints = "";
     observer.onWriteStart = () => {
         writing = true;
     };
@@ -164,17 +165,19 @@ if (process.env['NODE_ENV'] !== 'production') {
             return;
         }
         const nextEndpoints = JSON.stringify(Object.keys(data).sort());
-        if (prevEndpoints !== nextEndpoints) {
+        if (hadReadError || prevEndpoints !== nextEndpoints) {
             console.log();
             logRoutes(data);
         }
+        hadReadError = false;
     };
-    watch(file).on('change', () => {
+    watch(file).on("change", () => {
         // Do no reload if the file is being written to by the app
         if (!writing) {
             db.read().catch((e) => {
                 if (e instanceof SyntaxError) {
-                    return console.log(chalk.red(['', `Error parsing ${file}`, e.message].join('\n')));
+                    hadReadError = true;
+                    return console.log(chalk.red(["", `Error parsing ${file}`, e.message].join("\n")));
                 }
                 console.log(e);
             });

package/lib/matches-where.js

@@ -0,0 +1,87 @@
+import { WHERE_OPERATORS } from "./where-operators.js";
+function isJSONObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getKnownOperators(value) {
+    if (!isJSONObject(value))
+        return [];
+    const ops = [];
+    for (const op of WHERE_OPERATORS) {
+        if (op in value) {
+            ops.push(op);
+        }
+    }
+    return ops;
+}
+export function matchesWhere(obj, where) {
+    for (const [key, value] of Object.entries(where)) {
+        if (key === 'or') {
+            if (!Array.isArray(value) || value.length === 0)
+                return false;
+            let matched = false;
+            for (const subWhere of value) {
+                if (isJSONObject(subWhere) && matchesWhere(obj, subWhere)) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched)
+                return false;
+            continue;
+        }
+        const field = obj[key];
+        if (isJSONObject(value)) {
+            const knownOps = getKnownOperators(value);
+            if (knownOps.length > 0) {
+                if (field === undefined)
+                    return false;
+                const op = value;
+                if (knownOps.includes('lt') && !(field < op.lt))
+                    return false;
+                if (knownOps.includes('lte') && !(field <= op.lte))
+                    return false;
+                if (knownOps.includes('gt') && !(field > op.gt))
+                    return false;
+                if (knownOps.includes('gte') && !(field >= op.gte))
+                    return false;
+                if (knownOps.includes('eq') && !(field === op.eq))
+                    return false;
+                if (knownOps.includes('ne') && !(field !== op.ne))
+                    return false;
+                if (knownOps.includes('in')) {
+                    const inValues = Array.isArray(op.in) ? op.in : [op.in];
+                    if (!inValues.some((v) => field === v))
+                        return false;
+                }
+                if (knownOps.includes('contains')) {
+                    if (typeof field !== 'string')
+                        return false;
+                    if (!field.toLowerCase().includes(String(op.contains).toLowerCase()))
+                        return false;
+                }
+                if (knownOps.includes('startsWith')) {
+                    if (typeof field !== 'string')
+                        return false;
+                    if (!field.toLowerCase().startsWith(String(op.startsWith).toLowerCase()))
+                        return false;
+                }
+                if (knownOps.includes('endsWith')) {
+                    if (typeof field !== 'string')
+                        return false;
+                    if (!field.toLowerCase().endsWith(String(op.endsWith).toLowerCase()))
+                        return false;
+                }
+                continue;
+            }
+            if (isJSONObject(field)) {
+                if (!matchesWhere(field, value))
+                    return false;
+            }
+            continue;
+        }
+        if (field === undefined)
+            return false;
+        return false;
+    }
+    return true;
+}

package/lib/paginate.js

@@ -0,0 +1,24 @@
+export function paginate(items, page, perPage) {
+    const totalItems = items.length;
+    const safePerPage = Number.isFinite(perPage) && perPage > 0 ? Math.floor(perPage) : 1;
+    const pages = Math.max(1, Math.ceil(totalItems / safePerPage));
+    // Ensure page is within the valid range
+    const safePage = Number.isFinite(page) ? Math.floor(page) : 1;
+    const currentPage = Math.max(1, Math.min(safePage, pages));
+    const first = 1;
+    const prev = currentPage > 1 ? currentPage - 1 : null;
+    const next = currentPage < pages ? currentPage + 1 : null;
+    const last = pages;
+    const start = (currentPage - 1) * safePerPage;
+    const end = start + safePerPage;
+    const data = items.slice(start, end);
+    return {
+        first,
+        prev,
+        next,
+        last,
+        pages,
+        items: totalItems,
+        data,
+    };
+}

package/lib/parse-where.js

@@ -0,0 +1,56 @@
+import { setProperty } from 'dot-prop';
+import { isWhereOperator } from "./where-operators.js";
+function splitKey(key) {
+    const colonIdx = key.lastIndexOf(':');
+    if (colonIdx !== -1) {
+        const path = key.slice(0, colonIdx);
+        const op = key.slice(colonIdx + 1);
+        if (!op) {
+            return { path: key, op: 'eq' };
+        }
+        return isWhereOperator(op) ? { path, op } : { path, op: null };
+    }
+    // Compatibility with v0.17 operator style (e.g. _lt, _gt)
+    const underscoreMatch = key.match(/^(.*)_([a-z]+)$/);
+    if (underscoreMatch) {
+        const path = underscoreMatch[1];
+        const op = underscoreMatch[2];
+        if (path && isWhereOperator(op)) {
+            return { path, op };
+        }
+    }
+    return { path: key, op: 'eq' };
+}
+function setPathOp(root, path, op, value) {
+    const fullPath = `${path}.${op}`;
+    if (op === 'in') {
+        setProperty(root, fullPath, value.split(',').map((part) => coerceValue(part.trim())));
+        return;
+    }
+    setProperty(root, fullPath, coerceValue(value));
+}
+function coerceValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (value.trim() === '')
+        return value;
+    const num = Number(value);
+    if (Number.isFinite(num))
+        return num;
+    return value;
+}
+export function parseWhere(query) {
+    const out = {};
+    const params = new URLSearchParams(query);
+    for (const [rawKey, rawValue] of params.entries()) {
+        const { path, op } = splitKey(rawKey);
+        if (op === null)
+            continue;
+        setPathOp(out, path, op, rawValue);
+    }
+    return out;
+}

package/lib/service.js

@@ -1,28 +1,18 @@
 import { randomBytes } from 'node:crypto';
-import { getProperty } from 'dot-prop';
 import inflection from 'inflection';
+import { Low } from 'lowdb';
 import sortOn from 'sort-on';
+import { matchesWhere } from "./matches-where.js";
+import { paginate } from "./paginate.js";
 export function isItem(obj) {
-    return typeof obj === 'object' && obj !== null;
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
 }
 export function isData(obj) {
     if (typeof obj !== 'object' || obj === null) {
         return false;
     }
     const data = obj;
-    return Object.values(data).every((value) => Array.isArray(value) && value.every(isItem));
-}
-var Condition;
-(function (Condition) {
-    Condition["lt"] = "lt";
-    Condition["lte"] = "lte";
-    Condition["gt"] = "gt";
-    Condition["gte"] = "gte";
-    Condition["ne"] = "ne";
-    Condition["default"] = "";
-})(Condition || (Condition = {}));
-function isCondition(value) {
-    return Object.values(Condition).includes(value);
+    return Object.values(data).every((value) => Array.isArray(value) ? value.every(isItem) : isItem(value));
 }
 function ensureArray(arg = []) {
     return Array.isArray(arg) ? arg : [arg];
@@ -120,157 +110,24 @@ export class Service {
         }
         return;
     }
-    find(name, query = {}) {
-        let items = this.#get(name);
+    find(name, opts) {
+        const items = this.#get(name);
         if (!Array.isArray(items)) {
             return items;
         }
+        let results = items;
         // Include
-        ensureArray(query._embed).forEach((related) => {
-            if (items !== undefined && Array.isArray(items)) {
-                items = items.map((item) => embed(this.#db, name, item, related));
-            }
-        });
-        // Return list if no query params
-        if (Object.keys(query).length === 0) {
-            return items;
-        }
-        // Convert query params to conditions
-        const conds = {};
-        for (const [key, value] of Object.entries(query)) {
-            if (value === undefined || typeof value !== 'string') {
-                continue;
-            }
-            const re = /_(lt|lte|gt|gte|ne)$/;
-            const reArr = re.exec(key);
-            const op = reArr?.at(1);
-            if (op && isCondition(op)) {
-                const field = key.replace(re, '');
-                conds[field] = [op, value];
-                continue;
-            }
-            if ([
-                '_embed',
-                '_sort',
-                '_start',
-                '_end',
-                '_limit',
-                '_page',
-                '_per_page',
-            ].includes(key)) {
-                continue;
-            }
-            conds[key] = [Condition.default, value];
-        }
-        // Loop through conditions and filter items
-        const res = items.filter((item) => {
-            for (const [key, [op, paramValue]] of Object.entries(conds)) {
-                if (paramValue && !Array.isArray(paramValue)) {
-                    // https://github.com/sindresorhus/dot-prop/issues/95
-                    const itemValue = getProperty(item, key);
-                    switch (op) {
-                        // item_gt=value
-                        case Condition.gt: {
-                            if (!(typeof itemValue === 'number' &&
-                                itemValue > parseInt(paramValue))) {
-                                return false;
-                            }
-                            break;
-                        }
-                        // item_gte=value
-                        case Condition.gte: {
-                            if (!(typeof itemValue === 'number' &&
-                                itemValue >= parseInt(paramValue))) {
-                                return false;
-                            }
-                            break;
-                        }
-                        // item_lt=value
-                        case Condition.lt: {
-                            if (!(typeof itemValue === 'number' &&
-                                itemValue < parseInt(paramValue))) {
-                                return false;
-                            }
-                            break;
-                        }
-                        // item_lte=value
-                        case Condition.lte: {
-                            if (!(typeof itemValue === 'number' &&
-                                itemValue <= parseInt(paramValue))) {
-                                return false;
-                            }
-                            break;
-                        }
-                        // item_ne=value
-                        case Condition.ne: {
-                            switch (typeof itemValue) {
-                                case 'number':
-                                    return itemValue !== parseInt(paramValue);
-                                case 'string':
-                                    return itemValue !== paramValue;
-                                case 'boolean':
-                                    return itemValue !== (paramValue === 'true');
-                            }
-                            break;
-                        }
-                        // item=value
-                        case Condition.default: {
-                            switch (typeof itemValue) {
-                                case 'number':
-                                    return itemValue === parseInt(paramValue);
-                                case 'string':
-                                    return itemValue === paramValue;
-                                case 'boolean':
-                                    return itemValue === (paramValue === 'true');
-                            }
-                        }
-                    }
-                }
-            }
-            return true;
+        ensureArray(opts.embed).forEach((related) => {
+            results = results.map((item) => embed(this.#db, name, item, related));
         });
-        // Sort
-        const sort = query._sort || '';
-        const sorted = sortOn(res, sort.split(','));
-        // Slice
-        const start = query._start;
-        const end = query._end;
-        const limit = query._limit;
-        if (start !== undefined) {
-            if (end !== undefined) {
-                return sorted.slice(start, end);
-            }
-            return sorted.slice(start, start + (limit || 0));
-        }
-        if (limit !== undefined) {
-            return sorted.slice(0, limit);
+        results = results.filter((item) => matchesWhere(item, opts.where));
+        if (opts.sort) {
+            results = sortOn(results, opts.sort.split(','));
         }
-        // Paginate
-        let page = query._page;
-        const perPage = query._per_page || 10;
-        if (page) {
-            const items = sorted.length;
-            const pages = Math.ceil(items / perPage);
-            // Ensure page is within the valid range
-            page = Math.max(1, Math.min(page, pages));
-            const first = 1;
-            const prev = page > 1 ? page - 1 : null;
-            const next = page < pages ? page + 1 : null;
-            const last = pages;
-            const start = (page - 1) * perPage;
-            const end = start + perPage;
-            const data = sorted.slice(start, end);
-            return {
-                first,
-                prev,
-                next,
-                last,
-                pages,
-                items,
-                data,
-            };
+        if (opts.page !== undefined) {
+            return paginate(results, opts.page, opts.perPage ?? 10);
         }
-        return sorted.slice(start, end);
+        return results;
     }
     async create(name, data = {}) {
         const items = this.#get(name);
@@ -285,7 +142,7 @@ export class Service {
         const item = this.#get(name);
         if (item === undefined || Array.isArray(item))
             return;
-        const nextItem = (this.#db.data[name] = isPatch ? { item, ...body } : body);
+        const nextItem = (this.#db.data[name] = isPatch ? { ...item, ...body } : body);
         await this.#db.write();
         return nextItem;
     }
@@ -322,7 +179,7 @@ export class Service {
         if (item === undefined)
             return;
         const index = items.indexOf(item);
-        items.splice(index, 1)[0];
+        items.splice(index, 1);
         nullifyForeignKey(this.#db, name, id);
         const dependents = ensureArray(dependent);
         deleteDependents(this.#db, name, dependents);

package/lib/where-operators.js

@@ -0,0 +1,15 @@
+export const WHERE_OPERATORS = [
+    'lt',
+    'lte',
+    'gt',
+    'gte',
+    'eq',
+    'ne',
+    'in',
+    'contains',
+    'startsWith',
+    'endsWith',
+];
+export function isWhereOperator(value) {
+    return WHERE_OPERATORS.includes(value);
+}