@casl/prisma/dist/cjs/runtime-D3gLw0ml.cjs

Allows to query accessible records using Prisma client based on CASL rules

let e = require("@ucast/core"), t = require("@ucast/js"), r = require("@casl/ability/extra"), n = require("@casl/ability"), o = require("@prisma/client/extension");

var a = class extends Error {
    static invalidArgument(e, t, r) {
        return new this(`"${e}" expects to receive ${r} but instead got "${`${typeof t}(${JSON.stringify(t, null, 2)})`}"`);
    }
};

const s = e => e && (e.constructor === Object || !e.constructor), i = {
    type: "field",
    validate(e, t) {
        if (Array.isArray(t) || s(t)) throw new a(`"${e.name}" does not supports comparison of arrays and objects`);
    }
}, u = {
    type: "field",
    parse(t, r, {hasOperators: n, field: o, parse: i}) {
        if (s(r) && !n(r) || Array.isArray(r)) throw new a(`"${t.name}" does not supports comparison of arrays and objects`);
        return s(r) ? new e.CompoundCondition("NOT", [ i(r, {
            field: o
        }) ]) : new e.FieldCondition("notEquals", o, r);
    }
}, c = {
    type: "field",
    validate(e, t) {
        if (!Array.isArray(t)) throw a.invalidArgument(e.name, t, "an array");
    }
}, l = {
    type: "field",
    validate(e, t) {
        const r = typeof t;
        if (!("string" === r || "number" === r && Number.isFinite(t) || t instanceof Date)) throw a.invalidArgument(e.name, t, "comparable value");
    }
}, p = new Set([ "insensitive", "default" ]), f = {
    type: "field",
    validate(e, t) {
        if (!p.has(t)) throw a.invalidArgument(e.name, t, `one of ${Array.from(p).join(", ")}`);
    },
    parse: () => e.NULL_CONDITION
}, y = {
    type: "field",
    validate(e, t) {
        if ("string" != typeof t) throw a.invalidArgument(e.name, t, "string");
    },
    parse(t, r, {query: n, field: o}) {
        const a = "insensitive" === n.mode ? `i${t.name}` : t.name;
        return new e.FieldCondition(a, o, r);
    }
}, d = {
    type: "compound",
    validate(e, t) {
        if (!t || "object" != typeof t) throw a.invalidArgument(e.name, t, "an array or object");
    },
    parse(t, r, {parse: n}) {
        const o = (Array.isArray(r) ? r : [ r ]).map(e => n(e));
        return new e.CompoundCondition(t.name, o);
    }
}, b = {
    type: "field",
    validate(e, t) {
        if ("boolean" != typeof t) throw a.invalidArgument(e.name, t, "a boolean");
    }
}, h = {
    type: "field",
    validate(e, t) {
        if (!Array.isArray(t)) throw a.invalidArgument(e.name, t, "an array");
    }
}, g = {
    type: "field",
    parse(t, r, {field: n, parse: o}) {
        if (!s(r)) throw a.invalidArgument(t.name, r, "a query for nested relation");
        return new e.FieldCondition(t.name, n, o(r));
    }
}, m = (t, r) => {
    const n = r.parse;
    return n ? {
        ...r,
        parse(r, o, a) {
            const s = n(r, o, a);
            if (s.operator !== r.name) throw new Error(`Cannot invert "${t}" operator parser because it returns a complex Condition`);
            return s.operator = t, new e.CompoundCondition("NOT", [ s ]);
        }
    } : {
        ...r,
        parse: (r, n, o) => new e.CompoundCondition("NOT", [ new e.FieldCondition(t, o.field, n) ])
    };
}, w = {
    equals: i,
    not: u,
    in: c,
    notIn: m("in", c),
    lt: l,
    lte: l,
    gt: l,
    gte: l,
    mode: f,
    startsWith: y,
    endsWith: y,
    contains: y,
    isEmpty: b,
    has: {
        type: "field"
    },
    hasSome: h,
    hasEvery: h,
    NOT: d,
    AND: d,
    OR: d,
    every: g,
    some: g,
    none: m("some", g),
    is: g,
    isNot: m("is", g),
    isSet: b
};

var O = class extends e.ObjectQueryParser {
    constructor() {
        super(w, {
            defaultOperatorName: "equals"
        });
    }
    parse(t, r) {
        return r && r.field ? (0, e.buildAnd)(this.parseFieldOperators(r.field, t)) : super.parse(t);
    }
};

function v(e) {
    return e && "object" == typeof e ? e.valueOf() : e;
}

const A = (0, t.createJsInterpreter)({
    equals: t.eq,
    notEquals: t.ne,
    in: t.within,
    lt: t.lt,
    lte: t.lte,
    gt: t.gt,
    gte: t.gte,
    startsWith: (e, t, {get: r}) => r(t, e.field).startsWith(e.value),
    istartsWith: (e, t, {get: r}) => r(t, e.field).toLowerCase().startsWith(e.value.toLowerCase()),
    endsWith: (e, t, {get: r}) => r(t, e.field).endsWith(e.value),
    iendsWith: (e, t, {get: r}) => r(t, e.field).toLowerCase().endsWith(e.value.toLowerCase()),
    contains: (e, t, {get: r}) => r(t, e.field).includes(e.value),
    icontains: (e, t, {get: r}) => r(t, e.field).toLowerCase().includes(e.value.toLowerCase()),
    isEmpty: (e, t, {get: r}) => {
        const n = r(t, e.field);
        return (Array.isArray(n) && 0 === n.length) === e.value;
    },
    has: (e, t, {get: r}) => {
        const n = r(t, e.field);
        return Array.isArray(n) && n.includes(e.value);
    },
    hasSome: (e, t, {get: r}) => {
        const n = r(t, e.field);
        return Array.isArray(n) && e.value.some(e => n.includes(e));
    },
    hasEvery: (e, t, {get: r}) => {
        const n = r(t, e.field);
        return Array.isArray(n) && e.value.every(e => n.includes(e));
    },
    and: t.and,
    or: t.or,
    AND: t.and,
    OR: t.or,
    NOT: (e, t, {interpret: r}) => e.value.every(e => !r(e, t)),
    every: (e, t, {get: r, interpret: n}) => {
        const o = r(t, e.field);
        return Array.isArray(o) && o.every(t => n(e.value, t));
    },
    some: (e, t, {get: r, interpret: n}) => {
        const o = r(t, e.field);
        return Array.isArray(o) && o.some(t => n(e.value, t));
    },
    is: (e, t, {get: r, interpret: n}) => {
        const o = r(t, e.field);
        return o && "object" == typeof o && n(e.value, o);
    },
    isSet: (e, t, {get: r}) => void 0 !== r(t, e.field)
}, {
    get: (e, t) => e[t],
    compare: (e, r) => (0, t.compare)(v(e), v(r))
}), j = new O, N = (0, e.createTranslatorFactory)(j.parse, A);

function q(e) {
    return e.inverted ? {
        NOT: e.conditions
    } : e.conditions;
}

const x = {
    and: e => ({
        AND: e
    }),
    or: e => ({
        OR: e
    }),
    empty: () => ({})
};

var $ = class {
    constructor(e, t) {
        this.t = e, this.o = t;
    }
    ofType(e) {
        const t = this.t.rulesFor(this.o, e), n = (0, r.rulesToCondition)(t, q, x);
        return null === n ? {
            OR: []
        } : n;
    }
};

function E(e, t = "read") {
    return new $(e, t);
}

function D(e = [], t = {}) {
    return new n.Ability(e, {
        ...t,
        conditionsMatcher: N,
        fieldMatcher: n.fieldPatternMatcher
    });
}

function R() {
    return o.Prisma.defineExtension({
        name: "casl",
        query: {
            $allModels: {
                $allOperations({args: e, query: t}) {
                    const r = e?.where;
                    let n = e;
                    return T(r) && (n = {
                        ...e
                    }, Array.isArray(r) ? n.where = {
                        OR: [],
                        AND: r
                    } : n.where = "object" == typeof r ? {
                        ...r,
                        OR: [],
                        AND: [ r ]
                    } : {
                        OR: [],
                        AND: [ r ]
                    }), t(n);
                }
            }
        }
    });
}

function T(e) {
    if (!e || "object" != typeof e) return !1;
    const t = e;
    if (Array.isArray(t)) {
        for (let e = 0, r = t.length; e < r; e++) if (T(t[e])) return !0;
        return !1;
    }
    if (0 === t.OR?.length) return !0;
    for (const e in t) {
        if (!Object.hasOwn(t, e)) continue;
        const r = t[e];
        if (r && "object" == typeof r && T(r)) return !0;
    }
    return !1;
}

Object.defineProperty(exports, "ParsingQueryError", {
    enumerable: !0,
    get: function() {
        return a;
    }
}), Object.defineProperty(exports, "accessibleBy", {
    enumerable: !0,
    get: function() {
        return E;
    }
}), Object.defineProperty(exports, "createCaslExtension", {
    enumerable: !0,
    get: function() {
        return R;
    }
}), Object.defineProperty(exports, "createPrismaAbility", {
    enumerable: !0,
    get: function() {
        return D;
    }
}), Object.defineProperty(exports, "prismaQuery", {
    enumerable: !0,
    get: function() {
        return N;
    }
});
//# sourceMappingURL=runtime-D3gLw0ml.cjs.map