@primate/jsondb 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/private/ColumnTypes.d.ts

@@ -0,0 +1,13 @@
+import type { JSONValue } from "@rcompat/type";
+type ColumnTypes = {
+    BIGINT: bigint;
+    BLOB: Blob;
+    BOOLEAN: boolean;
+    DATE: Date;
+    JSON: JSONValue;
+    NUMBER: number;
+    STRING: string;
+    URL: URL;
+};
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/JSONDB.d.ts

@@ -0,0 +1,38 @@
+import type { As, DataDict, DB, Schema, Sort, With } from "@primate/core/db";
+import type { Dict, PartialDict } from "@rcompat/type";
+type Tables = PartialDict<Dict[]>;
+declare const config_schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly directory: import("pema").DefaultType<import("pema").StringType, "data">;
+}>, {
+    directory: string;
+}>;
+export default class JSONDB implements DB<Tables> {
+    #private;
+    static config: typeof config_schema.input;
+    constructor(config?: typeof config_schema.input);
+    get client(): Tables;
+    get schema(): Schema;
+    close(): void;
+    create<O extends Dict>(as: As, record: Dict): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): Promise<number>;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): Promise<number>;
+}
+export {};
+//# sourceMappingURL=JSONDB.d.ts.map

package/lib/private/JSONDB.js

@@ -0,0 +1,436 @@
+import E from "@primate/core/db/errors";
+import assert from "@rcompat/assert";
+import fs from "@rcompat/fs";
+import is from "@rcompat/is";
+import p from "pema";
+function escape_re(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function comparable(x) {
+    if (is.date(x))
+        return x.getTime();
+    if (is.url(x))
+        return x.href;
+    return x;
+}
+function like_re(pattern, flags = "") {
+    return new RegExp("^" +
+        escape_re(pattern)
+            .replace(/\\%/g, "<<PERCENT>>")
+            .replace(/\\_/g, "<<UNDERSCORE>>")
+            .replace(/%/g, "[\\s\\S]*")
+            .replace(/_/g, "[\\s\\S]")
+            .replace(/<<PERCENT>>/g, "%")
+            .replace(/<<UNDERSCORE>>/g, "_") +
+        "$", flags);
+}
+function match(record, where) {
+    return Object.entries(where).every(([k, v]) => {
+        const value = record[k];
+        if (v === null)
+            return value === null || value === undefined;
+        if (is.dict(v)) {
+            if (value === null || value === undefined)
+                return false;
+            for (const [op, op_val] of Object.entries(v)) {
+                switch (op) {
+                    case "$like": {
+                        if (!is.string(value))
+                            return false;
+                        if (!like_re(op_val).test(value))
+                            return false;
+                        break;
+                    }
+                    case "$ilike": {
+                        if (!is.string(value))
+                            return false;
+                        if (!like_re(op_val, "i").test(value))
+                            return false;
+                        break;
+                    }
+                    case "$gte":
+                        if (!(comparable(value) >= comparable(op_val)))
+                            return false;
+                        break;
+                    case "$gt":
+                    case "$after":
+                        if (!(comparable(value) > comparable(op_val)))
+                            return false;
+                        break;
+                    case "$lte":
+                        if (!(comparable(value) <= comparable(op_val)))
+                            return false;
+                        break;
+                    case "$lt":
+                    case "$before":
+                        if (!(comparable(value) < comparable(op_val)))
+                            return false;
+                        break;
+                    case "$ne": {
+                        if (is.date(value) && is.date(op_val)) {
+                            if (value.getTime() === op_val.getTime())
+                                return false;
+                            break;
+                        }
+                        if (is.url(value) && is.url(op_val)) {
+                            if (value.href === op_val.href)
+                                return false;
+                            break;
+                        }
+                        if (value === op_val)
+                            return false;
+                        break;
+                    }
+                    case "$in": {
+                        const arr = op_val;
+                        if (is.date(value)) {
+                            if (!arr.some(v => is.date(v) && v.getTime() === value.getTime()))
+                                return false;
+                            break;
+                        }
+                        if (is.url(value)) {
+                            if (!arr.some(v => is.url(v) && v.href === value.href))
+                                return false;
+                            break;
+                        }
+                        if (!arr.includes(value))
+                            return false;
+                        break;
+                    }
+                    default:
+                        throw E.operator_unknown(k, op);
+                }
+            }
+            return true;
+        }
+        if (is.date(value) && is.date(v))
+            return value.getTime() === v.getTime();
+        if (is.url(value) && is.url(v))
+            return value.href === v.href;
+        return value === v;
+    });
+}
+function filter(record, fields) {
+    return Object.fromEntries(Object.entries(record).filter(([key]) => fields.includes(key)));
+}
+function to_sorted(d1, d2, sort) {
+    return Object.entries(sort)
+        .map(([k, value]) => [k, value === "asc" ? 1 : -1])
+        .reduce((sorting, [field, direction]) => {
+        const left = d1[field];
+        const right = d2[field];
+        if (sorting !== 0)
+            return sorting;
+        if (left === right)
+            return sorting;
+        if (left < right)
+            return -1 * direction;
+        return direction;
+    }, 0);
+}
+// JSON serialization for types that JSON can't represent natively
+async function prepare_for_json(rows) {
+    return Promise.all(rows.map(async (row) => {
+        const out = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (typeof value === "bigint") {
+                out[key] = { __type: "bigint", value: String(value) };
+            }
+            else if (value instanceof Blob) {
+                out[key] = { __type: "blob", value: (await value.bytes()).toBase64() };
+            }
+            else if (is.date(value)) {
+                out[key] = { __type: "datetime", value: value.toISOString() };
+            }
+            else if (is.url(value)) {
+                out[key] = { __type: "url", value: value.href };
+            }
+            else {
+                out[key] = value;
+            }
+        }
+        return out;
+    }));
+}
+function revive_from_json(rows) {
+    return rows.map(row => {
+        const out = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (is.dict(value) && "__type" in value && "value" in value) {
+                switch (value.__type) {
+                    case "bigint":
+                        out[key] = BigInt(value.value);
+                        break;
+                    case "blob": {
+                        out[key] = new Blob([Uint8Array.fromBase64(value.value)], { type: "application/octet-stream" });
+                        break;
+                    }
+                    case "datetime":
+                        out[key] = new Date(value.value);
+                        break;
+                    case "url":
+                        out[key] = new URL(value.value);
+                        break;
+                    default:
+                        out[key] = value;
+                }
+            }
+            else {
+                out[key] = value;
+            }
+        }
+        return out;
+    });
+}
+const config_schema = p({
+    directory: p.string.default("data"),
+});
+export default class JSONDB {
+    static config;
+    #directory;
+    #tables = {};
+    #types = {};
+    constructor(config) {
+        const parsed = config_schema.parse(config);
+        this.#directory = fs.ref(parsed.directory);
+    }
+    get client() {
+        return this.#tables;
+    }
+    #ref(table) {
+        return this.#directory.join(`${table}.json`);
+    }
+    async #load(table) {
+        if (this.#tables[table] !== undefined)
+            return;
+        const ref = this.#ref(table);
+        if (await ref.exists()) {
+            const text = await ref.text();
+            const raw = JSON.parse(text);
+            this.#tables[table] = revive_from_json(raw);
+        }
+        else {
+            this.#tables[table] = [];
+        }
+    }
+    async #persist(table) {
+        const rows = this.#use(table);
+        const prepared = await prepare_for_json(rows);
+        const text = JSON.stringify(prepared, null, 2);
+        if (!await this.#directory.exists()) {
+            await this.#directory.create();
+        }
+        await this.#ref(table).write(text);
+    }
+    #use(table) {
+        this.#tables[table] ??= [];
+        return this.#tables[table];
+    }
+    get schema() {
+        return {
+            create: async (table, _pk, types) => {
+                await this.#load(table);
+                this.#types[table] = types;
+            },
+            delete: async (table) => {
+                delete this.#tables[table];
+                delete this.#types[table];
+                const ref = this.#ref(table);
+                if (await ref.exists()) {
+                    await ref.remove();
+                }
+            },
+            introspect: (table) => {
+                if (this.#tables[table] === undefined)
+                    return null;
+                const types = this.#types[table] ?? {};
+                return Object.fromEntries(Object.entries(types).map(([field, type]) => [field, [type]]));
+            },
+            alter: (table, diff) => {
+                if (this.#types[table] === undefined)
+                    throw E.table_not_found(table);
+                const types = { ...this.#types[table] };
+                const { add, drop, rename } = diff;
+                for (const [field, type] of Object.entries(add))
+                    types[field] = type;
+                for (const field of drop)
+                    delete types[field];
+                for (const [from, to] of rename) {
+                    types[to] = types[from];
+                    delete types[from];
+                }
+                this.#types[table] = types;
+            },
+        };
+    }
+    close() { }
+    #next_id(as) {
+        const table = this.#use(as.table);
+        const size = table.length;
+        const pk = assert.defined(as.pk);
+        const type = as.types[pk];
+        if (type === "uuid" || type === "uuid_v4" || type === "uuid_v7") {
+            return crypto.randomUUID();
+        }
+        else if (["u64", "u128", "i64", "i128"].includes(type)) {
+            return size === 0 ? 0n : table[size - 1][pk] + 1n;
+        }
+        else {
+            return size === 0 ? 0 : table[size - 1][pk] + 1;
+        }
+    }
+    async create(as, record) {
+        assert.nonempty(record);
+        await this.#load(as.table);
+        const table = this.#use(as.table);
+        const pk = as.pk;
+        let to_insert = record;
+        if (pk !== null && !(pk in record)) {
+            if (as.generate_pk === false)
+                throw E.pk_required(pk);
+            to_insert = { ...record, [pk]: this.#next_id(as) };
+        }
+        if (pk !== null) {
+            const pv = to_insert[pk];
+            if (table.find(s => s[pk] === pv) !== undefined) {
+                throw E.pk_duplicate(pk);
+            }
+        }
+        table.push({ ...to_insert });
+        await this.#persist(as.table);
+        return to_insert;
+    }
+    async read(as, args) {
+        assert.dict(args.where);
+        await this.#load(as.table);
+        const table = this.#use(as.table);
+        const matches = table.filter(r => match(r, args.where));
+        if (args.count === true)
+            return matches.length;
+        const sort = args.sort ?? {};
+        const sorted = Object.keys(sort).length === 0
+            ? matches
+            : matches.toSorted((a, b) => to_sorted(a, b, sort));
+        const offset = args.offset ?? 0;
+        const limit = args.limit ?? sorted.length;
+        const base_rows = sorted.slice(offset, offset + limit);
+        if (args.with === undefined) {
+            const fields = args.fields ?? [];
+            return fields.length === 0
+                ? base_rows
+                : base_rows.map(r => filter(r, fields));
+        }
+        assert.dict(args.with);
+        const base_fields = args.fields ?? [];
+        const out = base_rows.map(full => base_fields.length === 0 ? { ...full } : filter(full, base_fields));
+        const base_full = base_rows;
+        for (const [r_name, rel] of Object.entries(args.with)) {
+            const target_as = rel.as;
+            const kind = rel.kind;
+            const fk = rel.fk;
+            const reverse = rel.reverse === true;
+            const r_where = rel.where;
+            const r_sort = rel.sort;
+            const r_limit = rel.limit;
+            const r_fields = rel.fields ?? [];
+            await this.#load(target_as.table);
+            const target = this.#use(target_as.table);
+            function project_rel(row) {
+                if (r_fields.length === 0)
+                    return { ...row };
+                return filter(row, r_fields);
+            }
+            if (kind === "one" && reverse) {
+                const target_pk = target_as.pk;
+                if (target_pk === null)
+                    throw E.relation_requires_pk("target");
+                for (let i = 0; i < out.length; i++) {
+                    const parent_full = base_full[i];
+                    const fk_value = parent_full[fk];
+                    if (fk_value == null) {
+                        out[i][r_name] = null;
+                        continue;
+                    }
+                    let candidates = target.filter(t => t[target_pk] === fk_value && match(t, r_where));
+                    if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
+                        candidates = candidates.toSorted((a, b) => to_sorted(a, b, r_sort));
+                    }
+                    if (r_limit !== undefined)
+                        candidates = candidates.slice(0, r_limit);
+                    const got = candidates[0];
+                    out[i][r_name] = got ? project_rel(got) : null;
+                }
+                continue;
+            }
+            const parent_pk = as.pk;
+            if (parent_pk === null)
+                throw E.relation_requires_pk("parent");
+            const parent_keys = new Set(base_full.map(r => r[parent_pk]));
+            const grouped = new Map();
+            for (const row of target) {
+                const key = row[fk];
+                if (!parent_keys.has(key))
+                    continue;
+                if (!match(row, r_where))
+                    continue;
+                const bucket = grouped.get(key);
+                if (bucket !== undefined)
+                    bucket.push(row);
+                else
+                    grouped.set(key, [row]);
+            }
+            for (let i = 0; i < out.length; i++) {
+                const parent_full = base_full[i];
+                const key = parent_full[parent_pk];
+                let rows = grouped.get(key) ?? [];
+                if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
+                    rows = rows.toSorted((a, b) => to_sorted(a, b, r_sort));
+                }
+                if (kind === "one") {
+                    if (r_limit !== undefined)
+                        rows = rows.slice(0, r_limit);
+                    const got = rows[0];
+                    out[i][r_name] = got ? project_rel(got) : null;
+                }
+                else {
+                    if (r_limit !== undefined)
+                        rows = rows.slice(0, r_limit);
+                    out[i][r_name] = rows.map(project_rel);
+                }
+            }
+        }
+        return out;
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        await this.#load(as.table);
+        const table = this.#use(as.table);
+        const matched = table.filter(record => match(record, args.where));
+        const pk = as.pk;
+        const count = matched.map(record => {
+            const merged = { ...record, ...args.set };
+            const changed = Object.fromEntries(Object.entries(merged).filter(([, value]) => !is.null(value)));
+            const index = pk !== null
+                ? table.findIndex(stored => stored[pk] === record[pk])
+                : table.findIndex(stored => stored === record);
+            table.splice(index, 1, changed);
+            return changed;
+        }).length;
+        if (count > 0)
+            await this.#persist(as.table);
+        return count;
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        await this.#load(as.table);
+        const table = this.#use(as.table);
+        const size_before = table.length;
+        this.#tables[as.table] = table.filter(record => !match(record, args.where));
+        const count = size_before - this.#use(as.table).length;
+        if (count > 0)
+            await this.#persist(as.table);
+        return count;
+    }
+}
+//# sourceMappingURL=JSONDB.js.map

package/lib/private/typemap.d.ts

@@ -0,0 +1,5 @@
+import type ColumnTypes from "#ColumnTypes";
+import type { TypeMap } from "@primate/core/db";
+declare const typemap: TypeMap<ColumnTypes>;
+export default typemap;
+//# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -0,0 +1,33 @@
+function identity(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => value,
+    };
+}
+const typemap = {
+    blob: identity("BLOB"),
+    boolean: identity("BOOLEAN"),
+    datetime: identity("DATE"),
+    f32: identity("NUMBER"),
+    f64: identity("NUMBER"),
+    i128: identity("BIGINT"),
+    i16: identity("NUMBER"),
+    i32: identity("NUMBER"),
+    i64: identity("BIGINT"),
+    i8: identity("NUMBER"),
+    json: identity("JSON"),
+    string: identity("STRING"),
+    time: identity("STRING"),
+    u128: identity("BIGINT"),
+    u16: identity("NUMBER"),
+    u32: identity("NUMBER"),
+    u64: identity("BIGINT"),
+    u8: identity("NUMBER"),
+    url: identity("URL"),
+    uuid: identity("STRING"),
+    uuid_v4: identity("STRING"),
+    uuid_v7: identity("STRING"),
+};
+export default typemap;
+//# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import JSONDB from "#JSONDB";
+declare const _default: (config?: typeof JSONDB.config) => JSONDB;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import JSONDB from "#JSONDB";
+export default (config) => new JSONDB(config);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@primate/jsondb",
+  "version": "0.1.0",
+  "description": "JSON file databases for Primate",
+  "homepage": "https://primate.run/docs/database/jsondb",
+  "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primate-run/primate",
+    "directory": "packages/jsondb"
+  },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
+  "dependencies": {
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/fs": "^0.33.2",
+    "@rcompat/is": "^0.11.0",
+    "@primate/core": "^0.7.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.17.0",
+    "pema": "^0.7.0"
+  },
+  "peerDependencies": {
+    "primate": "^0.38.0"
+  },
+  "imports": {
+    "#*": {
+      "@primate/source": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "@primate/source": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npx proby",
+    "test:bun": "bunx --bun proby",
+    "test:deno": "deno run -A npm:proby"
+  }
+}