@mgarlik/json-filter 0.1.0 → 1.0.1

package/dist/filterDocuments.d.ts

@@ -5,7 +5,7 @@
  * - Pokud je `documents` jeden dokument, vrati dokument nebo `null`.
  * - `null`/`undefined` na vstupu vraci beze zmeny.
  */
-import type { contextType, filterType, targetType } from "./types";
+import type { contextType, filterType, targetType } from "./types.js";
 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 };

package/dist/filterDocuments.js

@@ -5,7 +5,7 @@
  * - Pokud je `documents` jeden dokument, vrati dokument nebo `null`.
  * - `null`/`undefined` na vstupu vraci beze zmeny.
  */
-import { matchesFilter } from "./matchesFilter";
+import { matchesFilter } from "./matchesFilter.js";
 function filterDocuments(documents, filter, context = {}) {
     if (documents == null)
         return documents;

package/dist/index.d.ts

@@ -1,5 +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";
+export { matchesFilter as matchJson, defineFilter as defineJsonFilter, filterArray as filterJsonArray, filterObject as filterJsonObjectMap, evaluateValue as evaluateJsonExpression, } from "./matchesFilter.js";
+export { filterDocuments as filterJsonDocuments, } from "./filterDocuments.js";
+export { getValueByDotPath as getJsonPathValue, } from "./dotPath.js";
+export { default as transformJsonDocument, } from "./recalculateWithDocument.js";
+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.js";

package/dist/index.js

@@ -8,13 +8,13 @@ filterArray as filterJsonArray,
 // filterObject,
 filterObject as filterJsonObjectMap, 
 // evaluateValue,
-evaluateValue as evaluateJsonExpression, } from "./matchesFilter";
+evaluateValue as evaluateJsonExpression, } from "./matchesFilter.js";
 export { 
 // filterDocuments,
-filterDocuments as filterJsonDocuments, } from "./filterDocuments";
+filterDocuments as filterJsonDocuments, } from "./filterDocuments.js";
 export { 
 // getValueByDotPath,
-getValueByDotPath as getJsonPathValue, } from "./dotPath";
+getValueByDotPath as getJsonPathValue, } from "./dotPath.js";
 export { 
 // default as recalculateObjectWithDocument,
-default as transformJsonDocument, } from "./recalculateWithDocument";
+default as transformJsonDocument, } from "./recalculateWithDocument.js";

package/dist/matchesFilter.d.ts

@@ -1,28 +1,7 @@
-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.
- */
+import type { contextType, documentsArrayType, documentsMapType, filterType, targetType, valueExpressionType } from "./types.js";
+export declare function evaluateValue(expr: valueExpressionType, context?: contextType, target?: targetType): unknown;
 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;
+export declare function matchesFilter<TTarget extends targetType, TContext extends contextType = contextType>(target: TTarget, filter: filterType<TTarget, TContext> | null | undefined | boolean, context?: TContext): boolean;
 /**
  * Vyfiltruje pole JSON dokumentu podle filtru.
  */

package/dist/matchesFilter.js

@@ -1,7 +1,3 @@
-/**
- * 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")
@@ -9,130 +5,71 @@ function resolvePath(obj, path) {
         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.")) {
+    if (ref.startsWith("$ctx."))
         return resolvePath(context, ref.slice(5));
-    }
-    const path = ref.slice(1);
-    return resolvePath(context, path);
+    return resolvePath(context, ref.slice(1));
 }
 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);
+function compareResolvedValues(fieldVal, resolved) {
+    if (Array.isArray(fieldVal)) {
+        if (Array.isArray(resolved))
+            return resolved.some((item) => fieldVal.includes(item));
+        return fieldVal.includes(resolved);
     }
-    return val;
+    if (Array.isArray(resolved))
+        return resolved.includes(fieldVal);
+    return fieldVal === resolved;
 }
-/**
- * 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;
+function getCurrentDate() {
+    return new Date().toISOString().slice(0, 10);
 }
-/**
- * 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 getCurrentTime() {
+    return new Date().toTimeString().slice(0, 8);
 }
-function evalAnd(target, arr, context) {
-    return arr.every(cond => matchesFilter(target, cond, context));
+function getCurrentDatetime() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
 }
-function evalOr(target, arr, context) {
-    return arr.some(cond => matchesFilter(target, cond, context));
+function evalFirst(arr, context, target) {
+    if (!Array.isArray(arr))
+        return undefined;
+    for (const item of arr) {
+        const result = evaluateValue(item, context, target);
+        if (result !== undefined)
+            return result;
+    }
+    return undefined;
+}
+function evalRule(rule, context, target) {
+    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, target, context);
+        }
+    }
+    return matchesFilter(target, rule, 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;
+        return compareResolvedValues(fieldVal, evaluateValue(condition, context, target));
     }
     if (Array.isArray(condition)) {
-        return fieldVal === condition;
+        return compareResolvedValues(fieldVal, evaluateValue(condition, context, target));
     }
     const keys = Object.keys(condition);
+    if (keys.length === 1 && keys[0] === "$source") {
+        throw new Error("Unresolved $source in filter condition. Resolve $source before calling json-filter.");
+    }
     for (const op of keys) {
         const arg = condition[op];
         if (!evalOperator(op, fieldVal, arg, target, context))
@@ -140,114 +77,112 @@ function evalCondition(fieldVal, condition, target, context) {
     }
     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);
+                const left = evaluateValue(arg[0], context, target);
+                const right = evaluateValue(arg[1], context, target);
                 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;
+            return compareResolvedValues(fieldVal, evaluateValue(arg, context, target));
         }
+        case "$neq":
+            return !compareResolvedValues(fieldVal, evaluateValue(arg, context, target));
         case "$gt":
-            return fieldVal > resolveValue(arg, target, context);
+            return fieldVal > evaluateValue(arg, context, target);
         case "$gte":
-            return fieldVal >= resolveValue(arg, target, context);
+            return fieldVal >= evaluateValue(arg, context, target);
         case "$lt":
-            return fieldVal < resolveValue(arg, target, context);
+            return fieldVal < evaluateValue(arg, context, target);
         case "$lte":
-            return fieldVal <= resolveValue(arg, target, context);
+            return fieldVal <= evaluateValue(arg, context, target);
         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];
+            return fieldVal >= evaluateValue(arg[0], context, target)
+                && fieldVal <= evaluateValue(arg[1], context, target);
         }
-        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))
+        case "$in": {
+            const resolved = evaluateValue(arg, context, target);
+            if (!Array.isArray(resolved))
+                return compareResolvedValues(fieldVal, resolved);
+            return compareResolvedValues(fieldVal, resolved);
+        }
+        case "$nin": {
+            const resolved = evaluateValue(arg, context, target);
+            if (!Array.isArray(resolved))
+                return !compareResolvedValues(fieldVal, resolved);
+            return !compareResolvedValues(fieldVal, resolved);
+        }
+        case "$ein": {
+            const resolved = evaluateValue(arg, context, target);
+            if (!Array.isArray(fieldVal) || !Array.isArray(resolved))
                 return false;
-            return fieldVal.every(v => arg.includes(v));
-        case "$nein":
-            if (!Array.isArray(fieldVal) || !Array.isArray(arg))
+            return fieldVal.every((v) => resolved.includes(v));
+        }
+        case "$nein": {
+            const resolved = evaluateValue(arg, context, target);
+            if (!Array.isArray(fieldVal) || !Array.isArray(resolved))
                 return false;
-            return fieldVal.some(v => !arg.includes(v));
+            return fieldVal.some((v) => !resolved.includes(v));
+        }
         case "$has":
-            return typeof fieldVal === "string"
-                && fieldVal.includes(String(resolveValue(arg, target, context)));
+            return typeof fieldVal === "string" && fieldVal.includes(String(evaluateValue(arg, context, target)));
         case "$nhas":
-            return typeof fieldVal === "string"
-                && !fieldVal.includes(String(resolveValue(arg, target, context)));
+            return typeof fieldVal === "string" && !fieldVal.includes(String(evaluateValue(arg, context, target)));
         case "$ihas": {
-            const needle = String(resolveValue(arg, target, context)).toLowerCase();
+            const needle = String(evaluateValue(arg, context, target)).toLowerCase();
             return typeof fieldVal === "string" && fieldVal.toLowerCase().includes(needle);
         }
         case "$nihas": {
-            const needle = String(resolveValue(arg, target, context)).toLowerCase();
+            const needle = String(evaluateValue(arg, context, target)).toLowerCase();
             return typeof fieldVal === "string" && !fieldVal.toLowerCase().includes(needle);
         }
         case "$sw":
-            return typeof fieldVal === "string" && fieldVal.startsWith(String(arg));
+            return typeof fieldVal === "string" && fieldVal.startsWith(String(evaluateValue(arg, context, target)));
         case "$nsw":
-            return typeof fieldVal === "string" && !fieldVal.startsWith(String(arg));
+            return typeof fieldVal === "string" && !fieldVal.startsWith(String(evaluateValue(arg, context, target)));
         case "$ew":
-            return typeof fieldVal === "string" && fieldVal.endsWith(String(arg));
+            return typeof fieldVal === "string" && fieldVal.endsWith(String(evaluateValue(arg, context, target)));
         case "$new":
-            return typeof fieldVal === "string" && !fieldVal.endsWith(String(arg));
+            return typeof fieldVal === "string" && !fieldVal.endsWith(String(evaluateValue(arg, context, target)));
         case "$regex":
-            return new RegExp(String(arg)).test(String(fieldVal));
+            return new RegExp(String(evaluateValue(arg, context, target))).test(String(fieldVal));
         case "$iregex":
-            return new RegExp(String(arg), "i").test(String(fieldVal));
+            return new RegExp(String(evaluateValue(arg, context, target)), "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));
+            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));
+            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));
+            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));
+            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));
+            return fieldVal.some((item) => matchesFilter((item ?? {}), (arg ?? {}), context));
         case "$nsome":
             if (!Array.isArray(fieldVal))
                 return true;
-            return !fieldVal.some(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+            return !fieldVal.some((item) => matchesFilter((item ?? {}), (arg ?? {}), context));
         case "$every":
             if (!Array.isArray(fieldVal))
                 return false;
-            return fieldVal.every(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+            return fieldVal.every((item) => matchesFilter((item ?? {}), (arg ?? {}), context));
         case "$nevery":
             if (!Array.isArray(fieldVal))
                 return false;
-            return !fieldVal.every(item => matchesFilter((item ?? {}), (arg ?? {}), context));
+            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);
+            const len = Array.isArray(fieldVal) ? fieldVal.length : (typeof fieldVal === "string" ? fieldVal.length : undefined);
             if (len === undefined)
                 return false;
             return evalCondition(len, arg, target, context);
@@ -255,7 +190,7 @@ function evalOperator(op, fieldVal, arg, target, context) {
         case "$sum": {
             if (!Array.isArray(fieldVal))
                 return false;
-            const sum = fieldVal.reduce((a, b) => (Number(a) || 0) + (Number(b) || 0), 0);
+            const sum = fieldVal.reduce((acc, item) => (Number(acc) || 0) + (Number(item) || 0), 0);
             return evalCondition(sum, arg, target, context);
         }
         case "$date":
@@ -270,121 +205,139 @@ function evalOperator(op, fieldVal, arg, target, context) {
             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 = {}) {
+export function evaluateValue(expr, context = {}, target = {}) {
     if (expr === null || expr === undefined)
         return expr;
-    if (typeof expr !== "object") {
-        return resolveValue(expr, {}, context);
+    if (typeof expr === "string") {
+        return resolveContextRef(resolveTargetRef(expr, target), context);
     }
+    if (typeof expr !== "object")
+        return expr;
     if (Array.isArray(expr)) {
-        return expr.map(e => evaluateValue(e, context));
+        return expr.map((item) => evaluateValue(item, context, target));
     }
     const obj = expr;
     const keys = Object.keys(obj);
+    if (keys.length === 1 && keys[0] === "$source") {
+        throw new Error("Unresolved $source expression. Resolve $source before calling json-filter.");
+    }
     if (keys.includes("$first")) {
-        return evalFirst(obj["$first"], context);
+        return evalFirst(obj["$first"], context, target);
     }
     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))
+        if (rule !== undefined && !evalRule(rule, context, target))
             return undefined;
-        return evaluateValue(val, context);
+        return evaluateValue(val, context, target);
     }
     if (keys.includes("$concat")) {
         const list = obj["$concat"] || [];
-        return list.map(s => String(evaluateValue(s, context))).join("");
+        return list.map((item) => String(evaluateValue(item, context, target))).join("");
     }
     if (keys.includes("$plus")) {
         const list = obj["$plus"] || [];
-        return list.reduce((acc, v) => Number(acc) + Number(evaluateValue(v, context)), 0);
+        return list.reduce((acc, item) => Number(acc) + Number(evaluateValue(item, context, target)), 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]);
+        const vals = (obj["$minus"] || []).map((item) => Number(evaluateValue(item, context, target)));
+        return vals.slice(1).reduce((acc, item) => acc - item, vals[0]);
     }
     if (keys.includes("$times")) {
         const list = obj["$times"] || [];
-        return list.reduce((acc, v) => Number(acc) * Number(evaluateValue(v, context)), 1);
+        return list.reduce((acc, item) => Number(acc) * Number(evaluateValue(item, context, target)), 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("$div") || keys.includes("$divide")) {
+        const list = (obj["$div"] || obj["$divide"]) || [];
+        const vals = list.map((item) => Number(evaluateValue(item, context, target)));
+        return vals.slice(1).reduce((acc, item) => acc / item, vals[0]);
     }
     if (keys.includes("$min")) {
-        const vals = (obj["$min"] || []).map(v => Number(evaluateValue(v, context)));
+        const vals = (obj["$min"] || []).map((item) => Number(evaluateValue(item, context, target)));
         return Math.min(...vals);
     }
     if (keys.includes("$max")) {
-        const vals = (obj["$max"] || []).map(v => Number(evaluateValue(v, context)));
+        const vals = (obj["$max"] || []).map((item) => Number(evaluateValue(item, context, target)));
         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;
+        const vals = (obj["$avg"] || []).map((item) => Number(evaluateValue(item, context, target)));
+        return vals.reduce((acc, item) => acc + item, 0) / vals.length;
     }
     if (keys.includes("$median")) {
-        const sorted = [...(obj["$median"] || []).map(v => Number(evaluateValue(v, context)))]
-            .sort((a, b) => a - b);
+        const sorted = [...(obj["$median"] || []).map((item) => Number(evaluateValue(item, context, target)))].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;
+        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 Array.isArray(arr) ? evaluateValue(arr[arr.length - 1], context, target) : evaluateValue(arr, context, target);
     }
-    return expr;
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, evaluateValue(value, context, target)]));
 }
-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;
+export function defineFilter(filter) {
+    return filter;
 }
-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);
+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 (!Array.isArray(val) || !val.every((condition) => matchesFilter(target, condition, context)))
+                return false;
+            continue;
+        }
+        if (key === "$nand") {
+            if (Array.isArray(val) && val.every((condition) => matchesFilter(target, condition, context)))
+                return false;
+            continue;
+        }
+        if (key === "$or") {
+            if (!Array.isArray(val) || !val.some((condition) => matchesFilter(target, condition, context)))
+                return false;
+            continue;
+        }
+        if (key === "$nor") {
+            if (Array.isArray(val) && val.some((condition) => matchesFilter(target, condition, context)))
+                return false;
+            continue;
+        }
+        if (key === "$not") {
+            if (matchesFilter(target, val, context))
+                return false;
+            continue;
         }
+        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;
+        }
+        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 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);
+    return true;
 }
 /**
  * Vyfiltruje pole JSON dokumentu podle filtru.
  */
 export function filterArray(documents, filter, context = {}) {
-    return documents.filter(doc => matchesFilter(doc, filter, context));
+    return documents.filter((doc) => matchesFilter(doc, filter, context));
 }
 /**
  * Vyfiltruje mapu JSON dokumentu (`Record<string, doc>`) podle filtru.

package/dist/typecheck.js

@@ -1,4 +1,4 @@
-import { matchesFilter } from "./matchesFilter";
+import { matchesFilter } from "./matchesFilter.js";
 const target = { price: 120, stock: 3, minPrice: 10 };
 const context = { minPrice: 20, maxPrice: 150 };
 matchesFilter(target, {

package/dist/types.d.ts

@@ -100,7 +100,13 @@ export type conditionObjectType<TValue = unknown, TTarget extends targetType = t
     $size?: conditionType<number, TTarget, TContext>;
     /** Soucet prvku pole a porovnani vysledku. */
     $sum?: conditionType<number, TTarget, TContext>;
-    /** Porovnani s aktualnim datem (YYYY-MM-DD). */
+    /** Porovnani s aktualnim datem (YYYY-MM-DD).
+     * @example
+     * // Porovná, jestli pole `dateFinish` je dříve než dnešní datum:
+     * {
+     *   dateFinish: { $lte: { $date: {} } as any },
+     * }
+    */
     $date?: conditionType<string, TTarget, TContext>;
     /** Porovnani s aktualnim casem (HH:mm:ss). */
     $time?: conditionType<string, TTarget, TContext>;
@@ -127,6 +133,8 @@ export type filterType<TTarget extends targetType = targetType, TContext extends
     [K in optionalFieldKeyType<TTarget>]?: conditionType<pathValueType<TTarget, K extends `${infer P}?` ? P : never>, TTarget, TContext>;
 } & {
     [K in contextReferenceType<TContext>]?: conditionType<any, TTarget, TContext>;
+} & {
+    [key: string]: conditionType<any, TTarget, TContext> | undefined;
 };
 /** Pole JSON dokumentu. */
 export type documentsArrayType = Array<Record<string, unknown>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mgarlik/json-filter",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "description": "JSON filter engine for backend and frontend applications",
   "type": "module",
   "main": "dist/index.js",