@constl/bohr-db/dist/ordered-keyvalue.js

Type-safe databases for orbit-db.

import { generateDictValidator, removeUndefinedProperties } from "./utils.js";
export const typedOrderedKeyValue = ({ db, schema, }) => {
    const { validateKey, getKeyValidator, supportedKey } = generateDictValidator(schema);
    return new Proxy(db, {
        get(target, prop) {
            if (prop === "get") {
                return async (key) => {
                    if (!supportedKey(key))
                        throw new Error(`Unsupported key ${key}.`);
                    const val = await target.get(key);
                    if (val === undefined)
                        return val;
                    const { value, position } = val;
                    const valid = validateKey(value, key);
                    return valid ? { value: value, position } : undefined;
                };
            }
            else if (prop === "move") {
                return async (key, position) => {
                    if (!supportedKey(key))
                        throw new Error(`Unsupported key ${key}.`);
                    return await target.move(key, position);
                };
            }
            else if (prop === "put" || prop === "set") {
                return async (key, value, position) => {
                    if (!supportedKey(key))
                        throw new Error(`Unsupported key ${key}.`);
                    if (typeof value === "object" && !Array.isArray(value)) {
                        value = removeUndefinedProperties(value);
                    }
                    const valid = validateKey(value, key);
                    if (valid)
                        return await target.put(key, value, position);
                    else
                        throw new Error(JSON.stringify(getKeyValidator(key).errors, undefined, 2));
                };
            }
            else if (prop === "all") {
                return async () => {
                    const all = await target.all();
                    return all.filter((x) => validateKey(x.value, x.key));
                };
            }
            else {
                return target[prop];
            }
        },
    });
};
//# sourceMappingURL=ordered-keyvalue.js.map