json-server 0.17.4 → 1.0.0-alpha.3

package/lib/app.js

@@ -0,0 +1,75 @@
+import { dirname, isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { App } from '@tinyhttp/app';
+import { Eta } from 'eta';
+import { json } from 'milliparsec';
+import sirv from 'sirv';
+import { isItem, Service } from './service.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const isProduction = process.env['NODE_ENV'] === 'production';
+const eta = new Eta({
+    views: join(__dirname, '../views'),
+    cache: isProduction,
+});
+export function createApp(db, options = {}) {
+    // Create service
+    const service = new Service(db);
+    // Create app
+    const app = new App();
+    // Body parser
+    app.use(json());
+    // Static files
+    app.use(sirv(join(__dirname, '../public')));
+    options.static
+        ?.map((path) => (isAbsolute(path) ? path : join(process.cwd(), path)))
+        .forEach((dir) => app.use(sirv(dir, { dev: !isProduction })));
+    app.get('/', (_req, res) => res.send(eta.render('index.html', { data: db.data })));
+    app.get('/:name', (req, res, next) => {
+        const { name = '' } = req.params;
+        res.locals['data'] = service.find(name, req.query);
+        next();
+    });
+    app.get('/:name/:id', (req, res, next) => {
+        const { name = '', id = '' } = req.params;
+        res.locals['data'] = service.findById(name, id, req.query);
+        next();
+    });
+    app.post('/:name', async (req, res, next) => {
+        const { name = '' } = req.params;
+        if (isItem(req.body)) {
+            res.locals['data'] = await service.create(name, req.body);
+        }
+        next();
+    });
+    app.put('/:name/:id', async (req, res, next) => {
+        const { name = '', id = '' } = req.params;
+        if (isItem(req.body)) {
+            res.locals['data'] = await service.update(name, id, req.body);
+        }
+        next();
+    });
+    app.patch('/:name/:id', async (req, res, next) => {
+        const { name = '', id = '' } = req.params;
+        if (isItem(req.body)) {
+            res.locals['data'] = await service.patch(name, id, req.body);
+        }
+        next();
+    });
+    app.delete('/:name/:id', async (req, res, next) => {
+        const { name = '', id = '' } = req.params;
+        res.locals['data'] = await service.destroy(name, id);
+        next();
+    });
+    app.use('/:name', (req, res) => {
+        const { data } = res.locals;
+        if (data === undefined) {
+            res.sendStatus(404);
+        }
+        else {
+            if (req.method === 'POST')
+                res.status(201);
+            res.json(data);
+        }
+    });
+    return app;
+}

package/lib/app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/app.test.js

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+import getPort from 'get-port';
+import { Low, Memory } from 'lowdb';
+import { temporaryDirectory } from 'tempy';
+import { createApp } from './app.js';
+const port = await getPort();
+// Create custom static dir with an html file
+const tmpDir = temporaryDirectory();
+const file = 'file.html';
+writeFileSync(join(tmpDir, file), 'utf-8');
+// Create app
+const db = new Low(new Memory(), {});
+db.data = {
+    posts: [{ id: '1', title: 'foo' }],
+    comments: [{ id: '1', postId: '1' }],
+};
+const app = createApp(db, { static: [tmpDir] });
+await new Promise((resolve, reject) => {
+    try {
+        const server = app.listen(port, () => resolve());
+        test.after(() => server.close());
+    }
+    catch (err) {
+        reject(err);
+    }
+});
+await test('createApp', async () => {
+    // URLs
+    const POSTS = '/posts';
+    const POST_1 = '/posts/1';
+    const POST_NOT_FOUND = '/posts/-1';
+    const COMMENTS = '/comments';
+    const POST_COMMENTS = '/comments?postId=1';
+    const NOT_FOUND = '/not-found';
+    const arr = [
+        // Static
+        { method: 'GET', url: '/', statusCode: 200 },
+        { method: 'GET', url: '/output.css', statusCode: 200 },
+        { method: 'GET', url: `/${file}`, statusCode: 200 },
+        // API
+        { method: 'GET', url: POSTS, statusCode: 200 },
+        { method: 'GET', url: POST_1, statusCode: 200 },
+        { method: 'GET', url: POST_NOT_FOUND, statusCode: 404 },
+        { method: 'GET', url: COMMENTS, statusCode: 200 },
+        { method: 'GET', url: POST_COMMENTS, statusCode: 200 },
+        { method: 'GET', url: NOT_FOUND, statusCode: 404 },
+        { method: 'POST', url: POSTS, statusCode: 201 },
+        { method: 'POST', url: POST_1, statusCode: 404 },
+        { method: 'POST', url: POST_NOT_FOUND, statusCode: 404 },
+        { method: 'POST', url: NOT_FOUND, statusCode: 404 },
+        { method: 'PUT', url: POSTS, statusCode: 404 },
+        { method: 'PUT', url: POST_1, statusCode: 200 },
+        { method: 'PUT', url: POST_NOT_FOUND, statusCode: 404 },
+        { method: 'PUT', url: NOT_FOUND, statusCode: 404 },
+        { method: 'PATCH', url: POSTS, statusCode: 404 },
+        { method: 'PATCH', url: POST_1, statusCode: 200 },
+        { method: 'PATCH', url: POST_NOT_FOUND, statusCode: 404 },
+        { method: 'PATCH', url: NOT_FOUND, statusCode: 404 },
+        { method: 'DELETE', url: POSTS, statusCode: 404 },
+        { method: 'DELETE', url: POST_1, statusCode: 200 },
+        { method: 'DELETE', url: POST_NOT_FOUND, statusCode: 404 },
+        { method: 'DELETE', url: NOT_FOUND, statusCode: 404 },
+    ];
+    for (const tc of arr) {
+        const response = await fetch(`http://localhost:${port}${tc.url}`, {
+            method: tc.method,
+        });
+        assert.equal(response.status, tc.statusCode, `${response.status} !== ${tc.statusCode} ${tc.method} ${tc.url} failed`);
+    }
+});

package/lib/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { watch } from 'chokidar';
+import { Low } from 'lowdb';
+import { JSONFile } from 'lowdb/node';
+import { createApp } from './app.js';
+import { Observer } from './observer.js';
+// Parse args
+const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+        port: {
+            type: 'string',
+            short: 'p',
+        },
+        host: {
+            type: 'string',
+            short: 'h',
+        },
+        static: {
+            type: 'string',
+            short: 's',
+            multiple: true,
+        },
+        help: {
+            type: 'boolean',
+        },
+        version: {
+            type: 'boolean',
+        },
+    },
+    allowPositionals: true,
+});
+if (values.help || positionals.length === 0) {
+    console.log(`Usage: json-server [options] [file]
+Options:
+  -p, --port <port>  Port (default: 3000)
+  -h, --host <host>  Host (default: localhost)
+  -s, --static <dir> Static files directory (multiple allowed)
+  --help  Show this message
+`);
+}
+if (values.version) {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+    console.log(pkg.version);
+    process.exit();
+}
+// App args and options
+const file = positionals[0] ?? 'db.json';
+const port = parseInt(values.port ?? process.env['PORT'] ?? '3000');
+const host = values.host ?? process.env['HOST'] ?? 'localhost';
+// Set up database
+const adapter = new JSONFile(file);
+const observer = new Observer(adapter);
+const db = new Low(observer, {});
+await db.read();
+// Create app
+const app = createApp(db, { logger: false, static: values.static });
+function routes(db) {
+    return Object.keys(db.data).map((key) => `http://${host}:${port}/${key}`);
+}
+// Watch file for changes
+if (process.env['NODE_ENV'] !== 'production') {
+    let writing = false; // true if the file is being written to by the app
+    observer.onWriteStart = () => {
+        writing = true;
+    };
+    observer.onWriteEnd = () => {
+        writing = false;
+    };
+    observer.onReadStart = () => console.log(`reloading ${file}...`);
+    observer.onReadEnd = () => console.log('reloaded');
+    watch(file).on('change', () => {
+        // Do no reload if the file is being written to by the app
+        if (!writing) {
+            db.read()
+                .then(() => routes(db))
+                .catch((e) => {
+                if (e instanceof SyntaxError) {
+                    return console.log(e.message);
+                }
+                console.log(e);
+            });
+        }
+    });
+}
+app.listen(port, () => {
+    console.log(`Started on :${port}`);
+    console.log(routes(db));
+});

package/lib/observer.d.ts

@@ -0,0 +1,11 @@
+import { Adapter } from 'lowdb';
+export declare class Observer<T> {
+    #private;
+    onReadStart: () => void;
+    onReadEnd: () => void;
+    onWriteStart: () => void;
+    onWriteEnd: () => void;
+    constructor(adapter: Adapter<T>);
+    read(): Promise<T | null>;
+    write(arg: T): Promise<void>;
+}

package/lib/observer.js

@@ -0,0 +1,30 @@
+// Lowdb adapter to observe read/write events
+export class Observer {
+    #adapter;
+    onReadStart = function () {
+        return;
+    };
+    onReadEnd = function () {
+        return;
+    };
+    onWriteStart = function () {
+        return;
+    };
+    onWriteEnd = function () {
+        return;
+    };
+    constructor(adapter) {
+        this.#adapter = adapter;
+    }
+    async read() {
+        this.onReadStart();
+        const data = await this.#adapter.read();
+        this.onReadEnd();
+        return data;
+    }
+    async write(arg) {
+        this.onWriteStart();
+        await this.#adapter.write(arg);
+        this.onWriteEnd();
+    }
+}

package/lib/service.d.ts

@@ -0,0 +1,39 @@
+import { Low } from 'lowdb';
+export type Headers = Record<string, string>;
+export type Item = Record<string, unknown>;
+export type Data = Record<string, Item[]>;
+export declare function isItem(obj: unknown): obj is Item;
+export declare function isData(obj: unknown): obj is Record<string, Item[]>;
+export type PaginatedItems = {
+    first: number;
+    prev: number | null;
+    next: number | null;
+    last: number;
+    pages: number;
+    items: number;
+    data: Item[];
+};
+export declare class Service {
+    #private;
+    constructor(db: Low<Data>);
+    list(): string[];
+    has(name: string): boolean;
+    findById(name: string, id: string, query: {
+        _include?: string[];
+    }): Item | undefined;
+    find(name: string, query?: {
+        [key: string]: unknown;
+    } & {
+        _include?: string[];
+        _sort?: string;
+        _start?: number;
+        _end?: number;
+        _limit?: number;
+        _page?: number;
+        _per_page?: number;
+    }): Item[] | PaginatedItems | undefined;
+    create(name: string, data?: Omit<Item, 'id'>): Promise<Item | undefined>;
+    update(name: string, id: string, body?: Omit<Item, 'id'>): Promise<Item | undefined>;
+    patch(name: string, id: string, body?: Omit<Item, 'id'>): Promise<Item | undefined>;
+    destroy(name: string, id: string, dependents?: string[]): Promise<Item | undefined>;
+}

package/lib/service.js

@@ -0,0 +1,270 @@
+import { randomBytes } from 'node:crypto';
+import { getProperty } from 'dot-prop';
+import inflection from 'inflection';
+import sortOn from 'sort-on';
+export function isItem(obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+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 Operator;
+(function (Operator) {
+    Operator["lt"] = "lt";
+    Operator["lte"] = "lte";
+    Operator["gt"] = "gt";
+    Operator["gte"] = "gte";
+    Operator["ne"] = "ne";
+    Operator["default"] = "";
+})(Operator || (Operator = {}));
+function isOperator(value) {
+    return Object.values(Operator).includes(value);
+}
+function include(db, name, item, related) {
+    if (inflection.singularize(related) === related) {
+        const relatedData = db.data[inflection.pluralize(related)];
+        if (!relatedData) {
+            return item;
+        }
+        const foreignKey = `${related}Id`;
+        const relatedItem = relatedData.find((relatedItem) => {
+            return relatedItem['id'] === item[foreignKey];
+        });
+        return { ...item, [related]: relatedItem };
+    }
+    const relatedData = db.data[related];
+    if (!relatedData) {
+        return item;
+    }
+    const foreignKey = `${inflection.singularize(name)}Id`;
+    const relatedItems = relatedData.filter((relatedItem) => relatedItem[foreignKey] === item['id']);
+    return { ...item, [related]: relatedItems };
+}
+function nullifyForeignKey(db, name, id) {
+    const foreignKey = `${inflection.singularize(name)}Id`;
+    Object.entries(db.data).forEach(([key, items]) => {
+        // Skip
+        if (key === name)
+            return;
+        // Nullify
+        items.forEach((item) => {
+            if (item[foreignKey] === id) {
+                item[foreignKey] = null;
+            }
+        });
+    });
+}
+function deleteDependents(db, name, dependents) {
+    const foreignKey = `${inflection.singularize(name)}Id`;
+    Object.entries(db.data).forEach(([key, items]) => {
+        // Skip
+        if (key === name || !dependents.includes(key))
+            return;
+        // Delete if foreign key is null
+        db.data[key] = items.filter((item) => item[foreignKey] !== null);
+    });
+}
+export class Service {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    #get(name) {
+        return this.#db.data[name];
+    }
+    list() {
+        return Object.keys(this.#db?.data || {});
+    }
+    has(name) {
+        return Object.prototype.hasOwnProperty.call(this.#db?.data, name);
+    }
+    findById(name, id, query) {
+        let item = this.#get(name)?.find((item) => item['id'] === id);
+        query._include?.forEach((related) => {
+            if (item !== undefined)
+                item = include(this.#db, name, item, related);
+        });
+        return item;
+    }
+    find(name, query = {}) {
+        let items = this.#get(name);
+        // Not found
+        if (items === undefined)
+            return;
+        // Include
+        query._include?.forEach((related) => {
+            if (items !== undefined)
+                items = items.map((item) => include(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 && isOperator(op)) {
+                const field = key.replace(re, '');
+                conds[field] = [op, value];
+                continue;
+            }
+            if (['_sort', '_start', '_end', '_limit', '_page', '_per_page'].includes(key))
+                continue;
+            conds[key] = [Operator.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)) {
+                    const itemValue = getProperty(item, key);
+                    switch (op) {
+                        // item_gt=value
+                        case Operator.gt: {
+                            if (!(typeof itemValue === 'number' &&
+                                itemValue > parseInt(paramValue))) {
+                                return false;
+                            }
+                            break;
+                        }
+                        // item_gte=value
+                        case Operator.gte: {
+                            if (!(typeof itemValue === 'number' &&
+                                itemValue >= parseInt(paramValue))) {
+                                return false;
+                            }
+                            break;
+                        }
+                        // item_lt=value
+                        case Operator.lt: {
+                            if (!(typeof itemValue === 'number' &&
+                                itemValue < parseInt(paramValue))) {
+                                return false;
+                            }
+                            break;
+                        }
+                        // item_lte=value
+                        case Operator.lte: {
+                            if (!(typeof itemValue === 'number' &&
+                                itemValue <= parseInt(paramValue))) {
+                                return false;
+                            }
+                            break;
+                        }
+                        // item_ne=value
+                        case Operator.ne: {
+                            if (!(itemValue != paramValue))
+                                return false;
+                            break;
+                        }
+                        // item=value
+                        case Operator.default: {
+                            if (!(itemValue == paramValue))
+                                return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        });
+        const sort = query._sort || '';
+        const sorted = sortOn(res, sort.split(','));
+        const start = query._start;
+        const end = query._end;
+        const limit = query._limit;
+        if (start === undefined && limit) {
+            return sorted.slice(0, limit);
+        }
+        if (start && limit) {
+            return sorted.slice(start, start + limit);
+        }
+        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,
+            };
+        }
+        return sorted.slice(start, end);
+    }
+    async create(name, data = {}) {
+        const items = this.#get(name);
+        if (items === undefined)
+            return;
+        const nextData = { id: randomBytes(2).toString('hex'), ...data };
+        items.push(nextData);
+        await this.#db.write();
+        return nextData;
+    }
+    async update(name, id, body = {}) {
+        const items = this.#get(name);
+        if (items === undefined)
+            return;
+        const index = items.findIndex((item) => item['id'] === id);
+        if (index === -1)
+            return;
+        const item = items.at(index);
+        if (item) {
+            const nextItem = { ...body, id: item['id'] };
+            items.splice(index, 1, nextItem);
+            await this.#db.write();
+            return nextItem;
+        }
+        return;
+    }
+    async patch(name, id, body = {}) {
+        const items = this.#get(name);
+        if (items === undefined)
+            return;
+        const index = items.findIndex((item) => item['id'] === id);
+        if (index === -1)
+            return;
+        const item = items.at(index);
+        if (item) {
+            const nextItem = { ...item, ...body, id: item['id'] };
+            items.splice(index, 1, nextItem);
+            await this.#db.write();
+            return nextItem;
+        }
+        return;
+    }
+    async destroy(name, id, dependents = []) {
+        const items = this.#get(name);
+        if (items === undefined)
+            return;
+        const index = items.findIndex((item) => item['id'] === id);
+        if (index === -1)
+            return;
+        const item = items.splice(index, 1)[0];
+        nullifyForeignKey(this.#db, name, id);
+        deleteDependents(this.#db, name, dependents);
+        await this.#db.write();
+        return item;
+    }
+}

package/lib/service.test.d.ts

@@ -0,0 +1 @@
+export {};