@mgarlik/json-filter 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @mgarlik/json-filter
+
+Shared TypeScript filter/rule engine for backend and frontend applications.
+
+## Scripts
+
+- `npm run build` - compile package to `dist/` and generate type declarations
+- `npm test` - run unit tests with Vitest
+- `npm run test:watch` - run tests in watch mode
+- `npm run lint` - type-check source code
+
+## Usage
+
+```ts
+import { matchJson, type JsonFilter } from "@mgarlik/json-filter";
+
+type Product = {
+  status: string;
+  price: number;
+};
+
+const filter: JsonFilter<Product> = {
+  status: { $eq: "active" },
+  price: { $gte: 100 },
+};
+
+const ok = matchJson({ status: "active", price: 120 }, filter);
+```
+
+## Documentation
+
+- [matchJson docs](docs/matchJson.md)
+
+## Publish
+
+1. Update version in `package.json`.
+2. Run `npm run build`.
+3. Publish with `npm publish`.

package/dist/dotPath.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vrati hodnotu z objektu podle dot-path cesty.
+ *
+ * @example getValueByDotPath({ a: { b: { c: 1 } } }, "a.b.c") => 1
+ */
+export declare function getValueByDotPath(obj: any, path: string): any;

package/dist/dotPath.js

@@ -0,0 +1,19 @@
+/**
+ * Vrati hodnotu z objektu podle dot-path cesty.
+ *
+ * @example getValueByDotPath({ a: { b: { c: 1 } } }, "a.b.c") => 1
+ */
+export function getValueByDotPath(obj, path) {
+    if (!obj || typeof obj !== "object" || typeof path !== "string") {
+        return undefined;
+    }
+    const keys = path.split(".");
+    let result = obj;
+    for (const key of keys) {
+        if (result === null || result === undefined) {
+            return undefined;
+        }
+        result = result[key];
+    }
+    return result;
+}

package/dist/filterDocuments.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filtruje jeden dokument nebo pole dokumentu podle filtru.
+ *
+ * - Pokud je `documents` pole, vrati vyfiltrovane pole.
+ * - Pokud je `documents` jeden dokument, vrati dokument nebo `null`.
+ * - `null`/`undefined` na vstupu vraci beze zmeny.
+ */
+import type { contextType, filterType, targetType } from "./types";
+declare function filterDocuments<TTarget extends targetType, TContext extends contextType = contextType>(documents: TTarget[], filter?: filterType<TTarget, TContext> | boolean | null, context?: TContext): TTarget[];
+declare function filterDocuments<TTarget extends targetType, TContext extends contextType = contextType>(documents: TTarget | null | undefined, filter?: filterType<TTarget, TContext> | boolean | null, context?: TContext): TTarget | null | undefined;
+export { filterDocuments };
+export default filterDocuments;

package/dist/filterDocuments.js

@@ -0,0 +1,24 @@
+/**
+ * Filtruje jeden dokument nebo pole dokumentu podle filtru.
+ *
+ * - Pokud je `documents` pole, vrati vyfiltrovane pole.
+ * - Pokud je `documents` jeden dokument, vrati dokument nebo `null`.
+ * - `null`/`undefined` na vstupu vraci beze zmeny.
+ */
+import { matchesFilter } from "./matchesFilter";
+function filterDocuments(documents, filter, context = {}) {
+    if (documents == null)
+        return documents;
+    if (filter == null)
+        return Array.isArray(documents) ? [...documents] : documents;
+    if (filter === true)
+        return Array.isArray(documents) ? [...documents] : documents;
+    if (filter === false)
+        return Array.isArray(documents) ? [] : null;
+    if (Array.isArray(documents)) {
+        return documents.filter((item) => matchesFilter(item, filter, context));
+    }
+    return matchesFilter(documents, filter, context) ? documents : null;
+}
+export { filterDocuments };
+export default filterDocuments;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { matchesFilter as matchJson, defineFilter as defineJsonFilter, filterArray as filterJsonArray, filterObject as filterJsonObjectMap, evaluateValue as evaluateJsonExpression, } from "./matchesFilter";
+export { filterDocuments as filterJsonDocuments, } from "./filterDocuments";
+export { getValueByDotPath as getJsonPathValue, } from "./dotPath";
+export { default as transformJsonDocument, } from "./recalculateWithDocument";
+export type { scalarType, scalarType as JsonScalar, contextType, contextType as JsonFilterContext, targetType, targetType as JsonDocument, conditionType, conditionType as JsonCondition, conditionObjectType, conditionObjectType as JsonConditionObject, filterType, filterType as JsonFilter, documentsArrayType, documentsArrayType as JsonDocumentsArray, documentsMapType, documentsMapType as JsonDocumentsMap, valueExpressionType, valueExpressionType as JsonExpression, } from "./types";

package/dist/index.js

@@ -0,0 +1,20 @@
+export { 
+// matchesFilter,
+matchesFilter as matchJson, 
+// defineFilter,
+defineFilter as defineJsonFilter, 
+// filterArray,
+filterArray as filterJsonArray, 
+// filterObject,
+filterObject as filterJsonObjectMap, 
+// evaluateValue,
+evaluateValue as evaluateJsonExpression, } from "./matchesFilter";
+export { 
+// filterDocuments,
+filterDocuments as filterJsonDocuments, } from "./filterDocuments";
+export { 
+// getValueByDotPath,
+getValueByDotPath as getJsonPathValue, } from "./dotPath";
+export { 
+// default as recalculateObjectWithDocument,
+default as transformJsonDocument, } from "./recalculateWithDocument";

package/dist/matchesFilter.d.ts

@@ -0,0 +1,33 @@
+import type { contextType, documentsArrayType, documentsMapType, filterType, targetType, valueExpressionType } from "./types";
+/**
+ * Vyhodnoti, jestli dokument odpovida zadanemu filtru.
+ *
+ * @param target Dokument, nad kterym se filtr vyhodnocuje.
+ * @param filter Filtr nebo boolean hodnota. `null`/`undefined` znamena "vse projde".
+ * @param context Volitelny kontext pro reference jako `$ctx.*`.
+ * @returns `true`, pokud dokument splnuje filtr.
+ */
+export declare function matchesFilter<TTarget extends targetType, TContext extends contextType = contextType>(target: TTarget, filter: filterType<TTarget, TContext> | null | undefined | boolean, context?: TContext): boolean;
+/**
+ * Pomocna funkce pro definici filtru se zachovanim plneho typovani.
+ *
+ * Hodí se hlavne kdyz filtr ulozis do promenne pred predanim do `matchesFilter`,
+ * aby VS Code spravne naseptaval cesty (`$this.*`, `$ctx.*`) a operatory.
+ */
+export declare function defineFilter<TTarget extends targetType, TContext extends contextType = contextType>(filter: filterType<TTarget, TContext>): filterType<TTarget, TContext>;
+/**
+ * Vyhodnoti hodnotovy vyraz (napr. `$plus`, `$concat`, `$val`) v kontextu dat.
+ *
+ * @param expr Vyraz k vyhodnoceni.
+ * @param context Kontext pro reference jako `$ctx.*`.
+ * @returns Vysledna hodnota vyrazu.
+ */
+export declare function evaluateValue(expr: valueExpressionType, context?: contextType): unknown;
+/**
+ * Vyfiltruje pole JSON dokumentu podle filtru.
+ */
+export declare function filterArray(documents: documentsArrayType, filter: filterType<targetType>, context?: contextType): documentsArrayType;
+/**
+ * Vyfiltruje mapu JSON dokumentu (`Record<string, doc>`) podle filtru.
+ */
+export declare function filterObject(documents: documentsMapType, filter: filterType<targetType>, context?: contextType): documentsMapType;

package/dist/matchesFilter.js

@@ -0,0 +1,394 @@
+/**
+ * Resolves a dot-notation path on an object.
+ * "brand.name" -> obj.brand.name
+ */
+function resolvePath(obj, path) {
+    return path.split(".").reduce((cur, key) => {
+        if (cur == null || typeof cur !== "object")
+            return undefined;
+        return cur[key];
+    }, obj);
+}
+/**
+ * Resolves a context reference like "$profile.type"
+ * from the provided context object.
+ */
+function resolveContextRef(ref, context) {
+    if (typeof ref !== "string" || !ref.startsWith("$"))
+        return ref;
+    if (ref.startsWith("$ctx.")) {
+        return resolvePath(context, ref.slice(5));
+    }
+    const path = ref.slice(1);
+    return resolvePath(context, path);
+}
+function resolveTargetRef(ref, target) {
+    if (typeof ref !== "string" || !ref.startsWith("$this."))
+        return ref;
+    return resolvePath(target, ref.slice(6));
+}
+/**
+ * Resolves a value - either a context reference or a literal.
+ */
+function resolveValue(val, target, context) {
+    if (typeof val === "string" && val.startsWith("$this.")) {
+        return resolveTargetRef(val, target);
+    }
+    if (typeof val === "string" && val.startsWith("$")) {
+        return resolveContextRef(val, context);
+    }
+    return val;
+}
+/**
+ * Vyhodnoti, jestli dokument odpovida zadanemu filtru.
+ *
+ * @param target Dokument, nad kterym se filtr vyhodnocuje.
+ * @param filter Filtr nebo boolean hodnota. `null`/`undefined` znamena "vse projde".
+ * @param context Volitelny kontext pro reference jako `$ctx.*`.
+ * @returns `true`, pokud dokument splnuje filtr.
+ */
+export function matchesFilter(target, filter, context = {}) {
+    if (filter === null || filter === undefined)
+        return true;
+    if (typeof filter !== "object")
+        return Boolean(filter);
+    const keys = Object.keys(filter);
+    for (const key of keys) {
+        const val = filter[key];
+        if (key === "$and") {
+            if (!evalAnd(target, val, context))
+                return false;
+            continue;
+        }
+        if (key === "$nand") {
+            if (evalAnd(target, val, context))
+                return false;
+            continue;
+        }
+        if (key === "$or") {
+            if (!evalOr(target, val, context))
+                return false;
+            continue;
+        }
+        if (key === "$nor") {
+            if (evalOr(target, val, context))
+                return false;
+            continue;
+        }
+        if (key === "$not") {
+            if (matchesFilter(target, val, context))
+                return false;
+            continue;
+        }
+        // Value reference as field: "$ctx.profile.type" or legacy "$profile.type"
+        if (key.startsWith("$ctx.") || (key.startsWith("$") && !key.startsWith("$this."))) {
+            const fieldVal = resolveContextRef(key, context);
+            if (!evalCondition(fieldVal, val, target, context))
+                return false;
+            continue;
+        }
+        if (key.startsWith("$this.")) {
+            const fieldVal = resolveTargetRef(key, target);
+            if (!evalCondition(fieldVal, val, target, context))
+                return false;
+            continue;
+        }
+        // Optional field (suffix ?)
+        const optional = key.endsWith("?");
+        const cleanKey = optional ? key.slice(0, -1) : key;
+        const fieldVal = resolvePath(target, cleanKey);
+        if (optional && fieldVal === undefined)
+            continue;
+        if (!evalCondition(fieldVal, val, target, context))
+            return false;
+    }
+    return true;
+}
+/**
+ * Pomocna funkce pro definici filtru se zachovanim plneho typovani.
+ *
+ * Hodí se hlavne kdyz filtr ulozis do promenne pred predanim do `matchesFilter`,
+ * aby VS Code spravne naseptaval cesty (`$this.*`, `$ctx.*`) a operatory.
+ */
+export function defineFilter(filter) {
+    return filter;
+}
+function evalAnd(target, arr, context) {
+    return arr.every(cond => matchesFilter(target, cond, context));
+}
+function evalOr(target, arr, context) {
+    return arr.some(cond => matchesFilter(target, cond, context));
+}
+/**
+ * Evaluates a single field value against its condition.
+ * Condition can be a primitive (implicit $eq) or an operator object.
+ */
+function evalCondition(fieldVal, condition, target, context) {
+    if (condition === null || typeof condition !== "object") {
+        if (Array.isArray(fieldVal))
+            return fieldVal.includes(condition);
+        return fieldVal === condition;
+    }
+    if (Array.isArray(condition)) {
+        return fieldVal === condition;
+    }
+    const keys = Object.keys(condition);
+    for (const op of keys) {
+        const arg = condition[op];
+        if (!evalOperator(op, fieldVal, arg, target, context))
+            return false;
+    }
+    return true;
+}
+/**
+ * Evaluates a single operator against a field value.
+ */
+function evalOperator(op, fieldVal, arg, target, context) {
+    switch (op) {
+        case "$eq": {
+            if (Array.isArray(arg) && arg.length === 2) {
+                const left = resolveValue(arg[0], target, context);
+                const right = resolveValue(arg[1], target, context);
+                return left === right;
+            }
+            const resolved = resolveValue(arg, target, context);
+            if (Array.isArray(fieldVal))
+                return fieldVal.includes(resolved);
+            return fieldVal === resolved;
+        }
+        case "$neq": {
+            const resolved = resolveValue(arg, target, context);
+            if (Array.isArray(fieldVal))
+                return !fieldVal.includes(resolved);
+            return fieldVal !== resolved;
+        }
+        case "$gt":
+            return fieldVal > resolveValue(arg, target, context);
+        case "$gte":
+            return fieldVal >= resolveValue(arg, target, context);
+        case "$lt":
+            return fieldVal < resolveValue(arg, target, context);
+        case "$lte":
+            return fieldVal <= resolveValue(arg, target, context);
+        case "$between": {
+            if (!Array.isArray(arg) || arg.length !== 2) {
+                throw new Error("$between requires an array of [min, max]");
+            }
+            return fieldVal >= arg[0]
+                && fieldVal <= arg[1];
+        }
+        case "$in":
+            return Array.isArray(arg) && arg.includes(fieldVal);
+        case "$nin":
+            return Array.isArray(arg) && !arg.includes(fieldVal);
+        case "$ein":
+            if (!Array.isArray(fieldVal) || !Array.isArray(arg))
+                return false;
+            return fieldVal.every(v => arg.includes(v));
+        case "$nein":
+            if (!Array.isArray(fieldVal) || !Array.isArray(arg))
+                return false;
+            return fieldVal.some(v => !arg.includes(v));
+        case "$has":
+            return typeof fieldVal === "string"
+                && fieldVal.includes(String(resolveValue(arg, target, context)));
+        case "$nhas":
+            return typeof fieldVal === "string"
+                && !fieldVal.includes(String(resolveValue(arg, target, context)));
+        case "$ihas": {
+            const needle = String(resolveValue(arg, target, context)).toLowerCase();
+            return typeof fieldVal === "string" && fieldVal.toLowerCase().includes(needle);
+        }
+        case "$nihas": {
+            const needle = String(resolveValue(arg, target, context)).toLowerCase();
+            return typeof fieldVal === "string" && !fieldVal.toLowerCase().includes(needle);
+        }
+        case "$sw":
+            return typeof fieldVal === "string" && fieldVal.startsWith(String(arg));
+        case "$nsw":
+            return typeof fieldVal === "string" && !fieldVal.startsWith(String(arg));
+        case "$ew":
+            return typeof fieldVal === "string" && fieldVal.endsWith(String(arg));
+        case "$new":
+            return typeof fieldVal === "string" && !fieldVal.endsWith(String(arg));
+        case "$regex":
+            return new RegExp(String(arg)).test(String(fieldVal));
+        case "$iregex":
+            return new RegExp(String(arg), "i").test(String(fieldVal));
+        case "$exists":
+            return arg ? fieldVal !== undefined : fieldVal === undefined;
+        case "$and":
+            return Array.isArray(arg) && arg.every(cond => evalCondition(fieldVal, cond, target, context));
+        case "$nand":
+            return Array.isArray(arg) && !arg.every(cond => evalCondition(fieldVal, cond, target, context));
+        case "$or":
+            return Array.isArray(arg) && arg.some(cond => evalCondition(fieldVal, cond, target, context));
+        case "$nor":
+            return Array.isArray(arg) && !arg.some(cond => evalCondition(fieldVal, cond, target, context));
+        case "$not":
+            return !evalCondition(fieldVal, arg, target, context);
+        case "$some":
+            if (!Array.isArray(fieldVal))
+                return false;
+            return fieldVal.some(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+        case "$nsome":
+            if (!Array.isArray(fieldVal))
+                return true;
+            return !fieldVal.some(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+        case "$every":
+            if (!Array.isArray(fieldVal))
+                return false;
+            return fieldVal.every(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+        case "$nevery":
+            if (!Array.isArray(fieldVal))
+                return false;
+            return !fieldVal.every(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+        case "$length":
+        case "$size": {
+            const len = Array.isArray(fieldVal)
+                ? fieldVal.length
+                : (typeof fieldVal === "string" ? fieldVal.length : undefined);
+            if (len === undefined)
+                return false;
+            return evalCondition(len, arg, target, context);
+        }
+        case "$sum": {
+            if (!Array.isArray(fieldVal))
+                return false;
+            const sum = fieldVal.reduce((a, b) => (Number(a) || 0) + (Number(b) || 0), 0);
+            return evalCondition(sum, arg, target, context);
+        }
+        case "$date":
+            return evalCondition(getCurrentDate(), arg, target, context);
+        case "$time":
+            return evalCondition(getCurrentTime(), arg, target, context);
+        case "$datetime":
+            return evalCondition(getCurrentDatetime(), arg, target, context);
+        case "$day":
+            return evalCondition(new Date().getDay(), arg, target, context);
+        default:
+            throw new Error(`Unknown operator: ${op}`);
+    }
+}
+/**
+ * Vyhodnoti hodnotovy vyraz (napr. `$plus`, `$concat`, `$val`) v kontextu dat.
+ *
+ * @param expr Vyraz k vyhodnoceni.
+ * @param context Kontext pro reference jako `$ctx.*`.
+ * @returns Vysledna hodnota vyrazu.
+ */
+export function evaluateValue(expr, context = {}) {
+    if (expr === null || expr === undefined)
+        return expr;
+    if (typeof expr !== "object") {
+        return resolveValue(expr, {}, context);
+    }
+    if (Array.isArray(expr)) {
+        return expr.map(e => evaluateValue(e, context));
+    }
+    const obj = expr;
+    const keys = Object.keys(obj);
+    if (keys.includes("$first")) {
+        return evalFirst(obj["$first"], context);
+    }
+    if (keys.includes("$val") || keys.includes("$value")) {
+        const val = obj["$val"] !== undefined ? obj["$val"] : obj["$value"];
+        const rule = obj["$rule"];
+        if (rule !== undefined && !evalRule(rule, context))
+            return undefined;
+        return evaluateValue(val, context);
+    }
+    if (keys.includes("$concat")) {
+        const list = obj["$concat"] || [];
+        return list.map(s => String(evaluateValue(s, context))).join("");
+    }
+    if (keys.includes("$plus")) {
+        const list = obj["$plus"] || [];
+        return list.reduce((acc, v) => Number(acc) + Number(evaluateValue(v, context)), 0);
+    }
+    if (keys.includes("$minus")) {
+        const vals = (obj["$minus"] || []).map(v => Number(evaluateValue(v, context)));
+        return vals.slice(1).reduce((acc, v) => acc - v, vals[0]);
+    }
+    if (keys.includes("$times")) {
+        const list = obj["$times"] || [];
+        return list.reduce((acc, v) => Number(acc) * Number(evaluateValue(v, context)), 1);
+    }
+    if (keys.includes("$div")) {
+        const vals = (obj["$div"] || []).map(v => Number(evaluateValue(v, context)));
+        return vals.slice(1).reduce((acc, v) => acc / v, vals[0]);
+    }
+    if (keys.includes("$min")) {
+        const vals = (obj["$min"] || []).map(v => Number(evaluateValue(v, context)));
+        return Math.min(...vals);
+    }
+    if (keys.includes("$max")) {
+        const vals = (obj["$max"] || []).map(v => Number(evaluateValue(v, context)));
+        return Math.max(...vals);
+    }
+    if (keys.includes("$avg")) {
+        const vals = (obj["$avg"] || []).map(v => Number(evaluateValue(v, context)));
+        return vals.reduce((a, b) => a + b, 0) / vals.length;
+    }
+    if (keys.includes("$median")) {
+        const sorted = [...(obj["$median"] || []).map(v => Number(evaluateValue(v, context)))]
+            .sort((a, b) => a - b);
+        const mid = Math.floor(sorted.length / 2);
+        return sorted.length % 2 !== 0
+            ? sorted[mid]
+            : (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+    if (keys.includes("$last")) {
+        const arr = obj["$last"];
+        return Array.isArray(arr) ? evaluateValue(arr[arr.length - 1], context) : evaluateValue(arr, context);
+    }
+    return expr;
+}
+function evalFirst(arr, context) {
+    if (!Array.isArray(arr))
+        return undefined;
+    for (const item of arr) {
+        if (typeof item !== "object" || item === null)
+            return item;
+        const result = evaluateValue(item, context);
+        if (result !== undefined)
+            return result;
+    }
+    return undefined;
+}
+function evalRule(rule, context) {
+    if (typeof rule !== "object" || rule === null)
+        return Boolean(rule);
+    const keys = Object.keys(rule);
+    if (keys.length === 1
+        && keys[0].startsWith("$")
+        && Array.isArray(rule[keys[0]])) {
+        const op = keys[0];
+        const arg = rule[op];
+        if (arg.length === 2) {
+            return evalOperator(op, undefined, arg, {}, context);
+        }
+    }
+    return matchesFilter({}, rule, context);
+}
+function getCurrentDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function getCurrentTime() {
+    return new Date().toTimeString().slice(0, 8);
+}
+function getCurrentDatetime() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+/**
+ * Vyfiltruje pole JSON dokumentu podle filtru.
+ */
+export function filterArray(documents, filter, context = {}) {
+    return documents.filter(doc => matchesFilter(doc, filter, context));
+}
+/**
+ * Vyfiltruje mapu JSON dokumentu (`Record<string, doc>`) podle filtru.
+ */
+export function filterObject(documents, filter, context = {}) {
+    return Object.fromEntries(Object.entries(documents).filter(([, doc]) => matchesFilter(doc, filter, context)));
+}

package/dist/recalculateWithDocument.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rekurzivne vyhodnocuje transformacni vyraz nad JSON dokumentem.
+ *
+ * Podporuje operatory jako `$rule`, `$and`, `$or`, `$sum`, `$avg`, `$concat`
+ * a reference hodnot pres dot-path (`$field.subfield`).
+ */
+declare function recalculateObjectWithDocument(obj: any, document: any): any;
+export default recalculateObjectWithDocument;

package/dist/recalculateWithDocument.js

@@ -0,0 +1,310 @@
+import { getValueByDotPath } from "./dotPath.js";
+import { matchesFilter } from "./matchesFilter.js";
+function getObjectValue(ddd, obj, documents) {
+    const data = Array.isArray(ddd)
+        ? ddd.length > 0
+            ? [...ddd]
+            : undefined
+        : typeof ddd === "object"
+            ? Object.keys(ddd).length > 0
+                ? { ...ddd }
+                : undefined
+            : ddd;
+    if (!data)
+        return undefined;
+    // console.log("DATA v getObjectValue", data)
+    // console.log("getObjectValue", obj)
+    switch (Object.keys(obj)[0]) {
+        case "$pipe":
+            let result = data;
+            // console.log("PIPE")
+            for (const action of obj.$pipe) {
+                // console.log("Action", action, result)
+                if (result)
+                    result = getObjectValue(result, action, documents);
+            }
+            return result;
+        case "$filter":
+            // console.log("Data", data[0], obj.$filter)
+            const filterRes = data
+                .map((d) => {
+                if (matchesFilter(d, obj.$filter, documents))
+                    return d;
+            })
+                .filter((u) => u);
+            // console.log("FILTER RESULT", filterRes)
+            return filterRes;
+        case "$sort":
+            console.log("Sorting", obj.$sort);
+            if (typeof obj.$sort === "object") {
+                const rr = data.sortBy(obj.$sort);
+                // console.log("Sorting result", JSON.stringify(rr, null, 2))
+                return rr;
+            }
+            else
+                return obj.$sort === "ASC" ? data.sort((a, b) => a - b) : data.sort((a, b) => b - a);
+        case "$limit":
+            let limit = Array.isArray(obj.$limit) ? [...obj.$limit] : [obj.$limit];
+            // console.log("Limiting", limit)
+            if (limit.length === 1)
+                limit.unshift(0);
+            else
+                limit[1] = limit[1] + limit[0];
+            const res = data.slice(...limit);
+            // console.log("Limit res", res)
+            return res;
+        case "$project":
+            // console.log("Project", obj.$project)
+            if (!Array.isArray(obj.$project))
+                obj.$project = [obj.$project];
+            return data.map((o) => Object.fromEntries(Object.entries(o).filter(([key]) => obj.$project.includes(key))));
+        case "$extract":
+            // console.log("Extract", obj.$extract)
+            // return data.map(o => o[obj.$extract])
+            const sres = data.map((o) => {
+                const res = getValueByDotPath(o, obj.$extract);
+                // console.log("EXTRACT RES", res)
+                return res;
+            });
+            // console.log("SRES JE ", sres.flat())
+            return sres.flat();
+        // return sres
+        case "$extractValue":
+            const rv = data.map((o) => o[obj.$extract]);
+            if (rv.length === 1)
+                return rv[0];
+            else
+                return rv;
+        case "$val":
+        case "$value":
+            // $val/$value return the current data as-is (or extract if specified)
+            return data;
+        default:
+        // console.log("JE TU NEZNAMY", Object.keys(obj)[0])
+    }
+    return data;
+}
+/**
+ * Rekurzivne vyhodnocuje transformacni vyraz nad JSON dokumentem.
+ *
+ * Podporuje operatory jako `$rule`, `$and`, `$or`, `$sum`, `$avg`, `$concat`
+ * a reference hodnot pres dot-path (`$field.subfield`).
+ */
+function recalculateObjectWithDocument(obj, document) {
+    if (obj === undefined)
+        return;
+    if (Array.isArray(obj)) {
+        var results = [];
+        obj.forEach((item) => {
+            const result = recalculateObjectWithDocument(item, document);
+            if (result !== undefined) {
+                results.push(result);
+            }
+        });
+        return results;
+    }
+    else if (typeof obj === "object") {
+        const keys = Object.keys(obj);
+        if (keys.some((item) => item.startsWith("$"))) {
+            if (keys.includes("$rule")) {
+                // console.log("Test je ", obj["$rule"])
+                const res = matchesFilter(document, obj["$rule"]);
+                // console.log("Rule", obj["$rule"])
+                // const res = recalculateObjectWithDocument(obj["$rule"], document)
+                if (res && obj["$value"] !== undefined) {
+                    // console.log("Volam recaluclate", obj["$value"])
+                    return recalculateObjectWithDocument(obj["$value"], document);
+                }
+                else if (obj["$value"] === undefined) {
+                    // console.log("Tady", obj["$rule"], res)
+                    return res;
+                }
+            }
+            else if (keys.includes("$or")) {
+                return obj["$or"].some((condition) => matchesFilter(document, condition));
+            }
+            else if (keys.includes("$and")) {
+                return obj["$and"].every((condition) => matchesFilter(document, condition));
+            }
+            else if (keys.includes("$min")) {
+                const res = recalculateObjectWithDocument(obj["$min"], document);
+                if (res.length === 0)
+                    return undefined;
+                // console.log("Vybiram z ", res)
+                return Math.min(...res);
+            }
+            else if (keys.includes("$max")) {
+                const res = recalculateObjectWithDocument(obj["$max"], document);
+                if (res.length === 0)
+                    return undefined;
+                return Math.max(...res);
+            }
+            else if (keys.includes("$sum")) {
+                const res = recalculateObjectWithDocument(obj["$sum"], document);
+                if (res)
+                    return res.reduce((acc, val) => acc + val, 0);
+                else
+                    return undefined;
+            }
+            else if (keys.includes("$avg")) {
+                const res = recalculateObjectWithDocument(obj["$avg"], document);
+                const sum = res.reduce((acc, val) => acc + val, 0);
+                return sum / res.length;
+            }
+            else if (keys.includes("$median")) {
+                const res = recalculateObjectWithDocument(obj["$median"], document);
+                const sortedArray = res.slice().sort((a, b) => a - b);
+                let median;
+                const middleIndex = Math.floor(sortedArray.length / 2);
+                if (sortedArray.length % 2 === 0) {
+                    // Even number of elements
+                    median = (sortedArray[middleIndex - 1] + sortedArray[middleIndex]) / 2;
+                }
+                else {
+                    // Odd number of elements
+                    median = sortedArray[middleIndex];
+                }
+                return median;
+            }
+            else if (keys.includes("$val") || keys.includes("$value")) {
+                const res = recalculateObjectWithDocument(obj["$val"] || obj["$value"], document);
+                if (res.length === 1)
+                    return res[0];
+                return res;
+            }
+            else if (keys.includes("$first")) {
+                const res = recalculateObjectWithDocument(obj["$first"], document);
+                return res?.[0];
+            }
+            else if (keys.includes("$last")) {
+                const res = recalculateObjectWithDocument(obj["$last"], document);
+                return res?.[res.length - 1];
+            }
+            else if (keys.includes("$concat")) {
+                const res = recalculateObjectWithDocument(obj["$concat"], document);
+                return res.join("");
+            }
+            else if (keys.includes("$plus")) {
+                const res = recalculateObjectWithDocument(obj["$plus"], document);
+                return res.reduce((accumulator, currentValue) => accumulator + Number(currentValue), 0);
+            }
+            else if (keys.includes("$minus")) {
+                const res = recalculateObjectWithDocument(obj["$minus"], document);
+                if (res?.length > 0) {
+                    const first = res.shift();
+                    return res.reduce((accumulator, currentValue) => accumulator - Number(currentValue), first);
+                }
+                return res;
+            }
+            else if (keys.includes("$times")) {
+                const res = recalculateObjectWithDocument(obj["$times"], document);
+                return res.reduce((accumulator, currentValue) => accumulator * Number(currentValue), 1);
+            }
+            else if (keys.includes("$div") || keys.includes("$divide")) {
+                const res = recalculateObjectWithDocument(obj["$div"] || obj["$divide"], document);
+                // if (res?.length >= 2) {
+                const first = res.shift();
+                return res.reduce((accumulator, currentValue) => accumulator / Number(currentValue), first);
+                // } else return false
+            }
+            else if (keys.includes("$mod")) {
+                const res = recalculateObjectWithDocument(obj["$mod"], document);
+                return res[0] % res[1];
+            }
+            else if (keys.includes("$round")) {
+                const res = recalculateObjectWithDocument(obj["$round"], document);
+                if (Array.isArray(res)) {
+                    const decimals = res[1] || 0;
+                    return Math.round(res[0] * Math.pow(10, decimals)) / Math.pow(10, decimals);
+                }
+                return Math.round(res);
+            }
+            else if (keys.includes("$ceil")) {
+                const res = recalculateObjectWithDocument(obj["$ceil"], document);
+                if (Array.isArray(res)) {
+                    const decimals = res[1] || 0;
+                    return Math.ceil(res[0] * Math.pow(10, decimals)) / Math.pow(10, decimals);
+                }
+                return Math.floor(res);
+            }
+            else if (keys.includes("$floor")) {
+                const res = recalculateObjectWithDocument(obj["$floor"], document);
+                return Math.floor(res);
+            }
+            else if (keys.includes("$gt")) {
+                const res = recalculateObjectWithDocument(obj["$gt"], document);
+                return res[0] > res[1];
+            }
+            else if (keys.includes("$gte")) {
+                const res = recalculateObjectWithDocument(obj["$gte"], document);
+                return res[0] >= res[1];
+            }
+            else if (keys.includes("$lt")) {
+                const res = recalculateObjectWithDocument(obj["$lt"], document);
+                return res[0] < res[1];
+            }
+            else if (keys.includes("$lte")) {
+                const res = recalculateObjectWithDocument(obj["$lte"], document);
+                return res[0] <= res[1];
+            }
+            else if (keys.includes("$eq")) {
+                const res = recalculateObjectWithDocument(obj["$eq"], document);
+                return res[0] === res[1];
+            }
+            else if (keys.includes("$neq")) {
+                const res = recalculateObjectWithDocument(obj["$neq"], document);
+                return res[0] !== res[1];
+            }
+            else {
+                // console.log("String obj", obj)
+                // console.log("Data:", document)
+                let data = getValueByDotPath(document, Object.keys(obj)[0].substring(1));
+                if (typeof obj === "object") {
+                    data = getObjectValue(data, obj[Object.keys(obj)[0]], document);
+                }
+                return data;
+            }
+            // const a = {
+            //     "$and": [
+            //         { "name": { "$regex": { "$neq": "LED" } } },
+            //         { "name": { "$regex": "UV" } },
+            //         { "name": { "$regex": "Lamp" } },
+            //         { "categories": "ce82bfa4-b2c7-11ec-9c66-246e96436e9c" }
+            //     ]
+            // }
+        }
+        else {
+            //   let result = {};
+            let result = {};
+            // console.log("Obj", obj)
+            // console.log("Documents", keys, JSON.stringify(document, null, 2))
+            // console.log("klic", obj, JSON.stringify(document, null, 2))
+            // console.log("KKK", getValueByDotPath("$" + keys[0], document))
+            // TODO: Zmenil jsem z:
+            // recalculateObjectWithDocument(getValueByDotPath(obj[key]), document)))
+            // Ale nevim jestli to je spravne
+            keys.forEach((key) => {
+                const value = obj[key];
+                // If value is a string starting with $, treat it as a path reference
+                if (typeof value === "string" && value.startsWith("$")) {
+                    const path = value.substring(1);
+                    result[key] = recalculateObjectWithDocument(getValueByDotPath(document, path), document);
+                }
+                else {
+                    // Otherwise treat it as an expression to evaluate
+                    result[key] = recalculateObjectWithDocument(value, document);
+                }
+            });
+            // console.log("Result je", result)
+            return result;
+        }
+    }
+    // Je to jen hodnota, vracime ji
+    else {
+        if (typeof obj === "string" && obj.startsWith("$"))
+            return getValueByDotPath(document, obj.substring(1));
+        else
+            return obj;
+    }
+}
+export default recalculateObjectWithDocument;

package/dist/typecheck.d.ts

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

package/dist/typecheck.js

@@ -0,0 +1,23 @@
+import { matchesFilter } from "./matchesFilter";
+const target = { price: 120, stock: 3, minPrice: 10 };
+const context = { minPrice: 20, maxPrice: 150 };
+matchesFilter(target, {
+    $and: [
+        { price: { $gte: "$this.minPrice" } },
+        { price: { $lte: "$ctx.maxPrice" } },
+    ],
+}, context);
+matchesFilter(target, {
+    $and: [
+        // @ts-expect-error invalid target reference path
+        { price: { $gte: "$this.nesmysl" } },
+        { price: { $lte: "$ctx.maxPrice" } },
+    ],
+}, context);
+matchesFilter(target, {
+    $and: [
+        { price: { $gte: "$this.minPrice" } },
+        // @ts-expect-error invalid context reference path
+        { price: { $lte: "$ctx.nesmysl" } },
+    ],
+}, context);

package/dist/types.d.ts

@@ -0,0 +1,137 @@
+/** Zakladni skalarny typ podporovany ve filtrech. */
+export type scalarType = string | number | boolean | null;
+/** Kontext predavany jako zdroj hodnot pro reference `$ctx.*`. */
+export type contextType = Record<string, unknown>;
+/** Cilovy JSON dokument, nad kterym se filtr vyhodnocuje. */
+export type targetType = Record<string, unknown>;
+type objectLikeType = Record<string, unknown>;
+type dotPathType<TObj> = TObj extends objectLikeType ? {
+    [K in Extract<keyof TObj, string>]: TObj[K] extends objectLikeType ? K | `${K}.${dotPathType<TObj[K]>}` : K;
+}[Extract<keyof TObj, string>] : never;
+type optionalFieldKeyType<TTarget extends targetType> = `${dotPathType<TTarget>}?`;
+type pathValueType<TObj, TPath extends string> = TPath extends `${infer THead}.${infer TTail}` ? THead extends keyof TObj ? pathValueType<TObj[THead], TTail> : unknown : TPath extends keyof TObj ? TObj[TPath] : unknown;
+type scalarFieldValueType<TValue> = Extract<TValue, scalarType>;
+type arrayElementType<TValue> = TValue extends readonly (infer TElement)[] ? TElement : never;
+type numericOrStringType<TValue> = Extract<TValue, number | string>;
+type someFilterType<TValue> = TValue extends readonly (infer TItem)[] ? TItem extends Record<string, unknown> ? filterType<TItem> : never : never;
+/** Reference na hodnotu z ciloveho dokumentu, napr. `$this.profile.type`. */
+export type targetReferenceType<TTarget extends targetType> = `$this.${dotPathType<TTarget>}`;
+/** Reference na hodnotu z kontextu, napr. `$ctx.user.role`. */
+export type contextReferenceType<TContext extends contextType = contextType> = `$ctx.${dotPathType<TContext>}`;
+export type valueReferenceType<TTarget extends targetType = targetType, TContext extends contextType = contextType> = targetReferenceType<TTarget> | contextReferenceType<TContext>;
+/**
+ * Stringová hodnota nebo reference s validací.
+ * Pokud začíná `$this.` nebo `$ctx.`, musí být validní cesta.
+ * Jinak je to libovolný string (ne-reference).
+ */
+type stringOrValidReferenceType<TTarget extends targetType, TContext extends contextType> = `$this.${dotPathType<TTarget>}` | `$ctx.${dotPathType<TContext>}` | (string & {});
+type scalarOrReferenceType<TValue, TTarget extends targetType, TContext extends contextType> = TValue extends string ? stringOrValidReferenceType<TTarget, TContext> : scalarFieldValueType<TValue> | valueReferenceType<TTarget, TContext>;
+export type conditionType<TValue = unknown, TTarget extends targetType = targetType, TContext extends contextType = contextType> = scalarType | undefined | conditionObjectType<TValue, TTarget, TContext> | Array<conditionType<TValue, TTarget, TContext>>;
+/** Objektova podoba podminky (operator -> hodnota). */
+export type conditionObjectType<TValue = unknown, TTarget extends targetType = targetType, TContext extends contextType = contextType> = {
+    /**
+     * Rovnost hodnoty (`field === value`).
+     * Pokud string začíná `$this.` nebo `$ctx.`, musí být validní cesta.
+     */
+    $eq?: TValue extends string ? (`$this.${dotPathType<TTarget>}` | `$ctx.${dotPathType<TContext>}` | (string & {})) : scalarOrReferenceType<TValue, TTarget, TContext> | [unknown, unknown];
+    /** Nerovnost hodnoty (`field !== value`). */
+    $neq?: scalarOrReferenceType<TValue, TTarget, TContext>;
+    /** Vetsi nez (`field > value`). */
+    $gt?: numericOrStringType<TValue> | valueReferenceType<TTarget, TContext>;
+    /** Vetsi nebo rovno (`field >= value`). */
+    $gte?: numericOrStringType<TValue> | valueReferenceType<TTarget, TContext>;
+    /** Mensi nez (`field < value`). */
+    $lt?: numericOrStringType<TValue> | valueReferenceType<TTarget, TContext>;
+    /** Mensi nebo rovno (`field <= value`). */
+    $lte?: numericOrStringType<TValue> | valueReferenceType<TTarget, TContext>;
+    /** Rozsah vcetne hranic (`min <= field <= max`). */
+    $between?: [unknown, unknown];
+    /** Hodnota je v seznamu (`field in list`). */
+    $in?: Array<scalarOrReferenceType<TValue, TTarget, TContext>>;
+    /** Hodnota neni v seznamu (`field not in list`). */
+    $nin?: Array<scalarOrReferenceType<TValue, TTarget, TContext>>;
+    /** Vsechny prvky pole jsou v seznamu. */
+    $ein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext>> : never;
+    /** Alespon jeden prvek pole neni v seznamu. */
+    $nein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext>> : never;
+    /** String obsahuje podretezec (case-sensitive). */
+    $has?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String neobsahuje podretezec (case-sensitive). */
+    $nhas?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String obsahuje podretezec (case-insensitive). */
+    $ihas?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String neobsahuje podretezec (case-insensitive). */
+    $nihas?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String zacina na hodnotu. */
+    $sw?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String nezacina na hodnotu. */
+    $nsw?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String konci na hodnotu. */
+    $ew?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** String nekonci na hodnotu. */
+    $new?: scalarOrReferenceType<string, TTarget, TContext>;
+    /** RegExp porovnani (case-sensitive). */
+    $regex?: string;
+    /** RegExp porovnani (case-insensitive). */
+    $iregex?: string;
+    /** Kontrola existence hodnoty (`true` = existuje, `false` = neexistuje). */
+    $exists?: boolean;
+    /** Vsechny podminky musi platit. */
+    $and?: Array<conditionType<TValue, TTarget, TContext>>;
+    /** Negace operatoru $and. */
+    $nand?: Array<conditionType<TValue, TTarget, TContext>>;
+    /** Alespon jedna podminka musi platit. */
+    $or?: Array<conditionType<TValue, TTarget, TContext>>;
+    /** Negace operatoru $or. */
+    $nor?: Array<conditionType<TValue, TTarget, TContext>>;
+    /** Negace podminky. */
+    $not?: conditionType<TValue, TTarget, TContext>;
+    /** U pole objektu: alespon jeden prvek odpovida filtru. */
+    $some?: someFilterType<TValue>;
+    /** U pole objektu: zadny prvek neodpovida filtru. */
+    $nsome?: someFilterType<TValue>;
+    /** U pole objektu: vsechny prvky odpovidaji filtru. */
+    $every?: someFilterType<TValue>;
+    /** U pole objektu: neplati, ze vsechny prvky odpovidaji filtru. */
+    $nevery?: someFilterType<TValue>;
+    /** Podminka nad delkou pole nebo stringu. */
+    $length?: conditionType<number, TTarget, TContext>;
+    /** Alias pro $length. */
+    $size?: conditionType<number, TTarget, TContext>;
+    /** Soucet prvku pole a porovnani vysledku. */
+    $sum?: conditionType<number, TTarget, TContext>;
+    /** Porovnani s aktualnim datem (YYYY-MM-DD). */
+    $date?: conditionType<string, TTarget, TContext>;
+    /** Porovnani s aktualnim casem (HH:mm:ss). */
+    $time?: conditionType<string, TTarget, TContext>;
+    /** Porovnani s aktualnim datetime. */
+    $datetime?: conditionType<string, TTarget, TContext>;
+    /** Den v tydnu (`0-6`, nedele=0). */
+    $day?: conditionType<number, TTarget, TContext>;
+};
+/** Hlavni typ filtru pouzivany ve `matchesFilter` a `filterDocuments`. */
+export type filterType<TTarget extends targetType = targetType, TContext extends contextType = contextType> = {
+    /** Vsechny podfiltry musi platit. */
+    $and?: Array<filterType<TTarget, TContext>>;
+    /** Negace operatoru $and. */
+    $nand?: Array<filterType<TTarget, TContext>>;
+    /** Alespon jeden podfiltr musi platit. */
+    $or?: Array<filterType<TTarget, TContext>>;
+    /** Negace operatoru $or. */
+    $nor?: Array<filterType<TTarget, TContext>>;
+    /** Negace jednoho podfiltru. */
+    $not?: filterType<TTarget, TContext>;
+} & {
+    [K in dotPathType<TTarget>]?: conditionType<pathValueType<TTarget, K>, TTarget, TContext>;
+} & {
+    [K in optionalFieldKeyType<TTarget>]?: conditionType<pathValueType<TTarget, K extends `${infer P}?` ? P : never>, TTarget, TContext>;
+} & {
+    [K in contextReferenceType<TContext>]?: conditionType<any, TTarget, TContext>;
+};
+/** Pole JSON dokumentu. */
+export type documentsArrayType = Array<Record<string, unknown>>;
+/** Mapa JSON dokumentu (`Record<id, document>`). */
+export type documentsMapType = Record<string, Record<string, unknown>>;
+/** Typ hodnotoveho vyrazu pro `evaluateValue` a souvisejici API. */
+export type valueExpressionType = unknown;
+export {};

package/dist/types.js

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

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mgarlik/json-filter",
+  "version": "0.1.0",
+  "description": "JSON filter engine for backend and frontend applications",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "keywords": [
+    "filter",
+    "rules",
+    "validation",
+    "typescript"
+  ],
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.5"
+  }
+}