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

Type-safe databases for OrbitDB.

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") {
                const wrappedGet = async (key) => {
                    if (!supportedKey(key))
                        throw new Error(`Unsupported key ${key}.`);
                    const value = await target.get(key);
                    if (value === undefined)
                        return value;
                    const valid = validateKey(value, key);
                    return valid ? value : undefined;
                };
                return wrappedGet;
            }
            else if (prop === "move") {
                const wrappedMove = async (key, position) => {
                    if (!supportedKey(key))
                        throw new Error(`Unsupported key ${key}.`);
                    return await target.move(key, position);
                };
                return wrappedMove;
            }
            else if (prop === "put" || prop === "set") {
                const wrappedPut = 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));
                };
                return wrappedPut;
            }
            else if (prop === "all") {
                const wrappedAll = async () => {
                    const all = await target.all();
                    return all.filter((x) => validateKey(x.value, x.key));
                };
                return wrappedAll;
            }
            else {
                return target[prop];
            }
        },
    });
};
//# sourceMappingURL=ordered-keyvalue.js.map