@mgarlik/json-filter 0.1.0 → 1.0.0

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,76 @@ 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 buildSourceKey(source) {
+    if (typeof source !== "object" || source === null)
+        return String(source);
+    return JSON.stringify(source);
 }
-/**
- * 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 getCurrentDate() {
+    return new Date().toISOString().slice(0, 10);
 }
-function evalAnd(target, arr, context) {
-    return arr.every(cond => matchesFilter(target, cond, context));
+function getCurrentTime() {
+    return new Date().toTimeString().slice(0, 8);
 }
-function evalOr(target, arr, context) {
-    return arr.some(cond => matchesFilter(target, cond, context));
+function getCurrentDatetime() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+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") {
+        return compareResolvedValues(fieldVal, evaluateValue(condition, context, target));
+    }
     for (const op of keys) {
         const arg = condition[op];
         if (!evalOperator(op, fieldVal, arg, target, context))
@@ -140,114 +82,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": {
+            const resolved = evaluateValue(arg, context, target);
+            if (!Array.isArray(resolved))
+                return compareResolvedValues(fieldVal, resolved);
+            return compareResolvedValues(fieldVal, resolved);
         }
-        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 "$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 +195,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 +210,149 @@ 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") {
+        const source = obj["$source"];
+        const sourceResolver = context.sourceResolver;
+        if (!sourceResolver) {
+            throw new Error("$source requires context.sourceResolver");
+        }
+        const stack = context.sourceStack ?? [];
+        const sourceKey = buildSourceKey(source);
+        if (stack.includes(sourceKey)) {
+            throw new Error(`Cyclic $source reference detected for ${sourceKey}`);
+        }
+        return sourceResolver(source, { ...context, sourceStack: [...stack, sourceKey] });
+    }
     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

@@ -1,7 +1,12 @@
 /** 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>;
+export type contextType = Record<string, unknown> & {
+    /** Volitelny resolver pro dynamicke reference typu `$source`. */
+    sourceResolver?: (source: unknown, context: contextType) => unknown;
+    /** Interni stack pro detekci cyklu pri reseni `$source`. */
+    sourceStack?: string[];
+};
 /** Cilovy JSON dokument, nad kterym se filtr vyhodnocuje. */
 export type targetType = Record<string, unknown>;
 type objectLikeType = Record<string, unknown>;
@@ -19,14 +24,30 @@ export type targetReferenceType<TTarget extends targetType> = `$this.${dotPathTy
 /** 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>;
+/** Zdrojova reference, ktera se vyhodnoti na jednu hodnotu nebo pole hodnot. */
+export type sourceValueType<TTarget extends targetType = targetType, TContext extends contextType = contextType> = {
+    $source: {
+        dataProvider: string;
+        filter?: filterType<TTarget, TContext>;
+        val: string;
+        map?: never;
+    };
+} | {
+    $source: {
+        dataProvider: string;
+        filter?: filterType<TTarget, TContext>;
+        map: string;
+        val?: never;
+    };
+};
 /**
  * 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>>;
+type scalarOrReferenceType<TValue, TTarget extends targetType, TContext extends contextType> = TValue extends string ? stringOrValidReferenceType<TTarget, TContext> : scalarFieldValueType<TValue> | valueReferenceType<TTarget, TContext> | sourceValueType<TTarget, TContext>;
+export type conditionType<TValue = unknown, TTarget extends targetType = targetType, TContext extends contextType = contextType> = scalarType | undefined | sourceValueType<TTarget, TContext> | 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> = {
     /**
@@ -47,13 +68,13 @@ export type conditionObjectType<TValue = unknown, TTarget extends targetType = t
     /** Rozsah vcetne hranic (`min <= field <= max`). */
     $between?: [unknown, unknown];
     /** Hodnota je v seznamu (`field in list`). */
-    $in?: Array<scalarOrReferenceType<TValue, TTarget, TContext>>;
+    $in?: Array<scalarOrReferenceType<TValue, TTarget, TContext> | sourceValueType<TTarget, TContext>>;
     /** Hodnota neni v seznamu (`field not in list`). */
-    $nin?: Array<scalarOrReferenceType<TValue, TTarget, TContext>>;
+    $nin?: Array<scalarOrReferenceType<TValue, TTarget, TContext> | sourceValueType<TTarget, TContext>>;
     /** Vsechny prvky pole jsou v seznamu. */
-    $ein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext>> : never;
+    $ein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext> | sourceValueType<TTarget, TContext>> : never;
     /** Alespon jeden prvek pole neni v seznamu. */
-    $nein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext>> : never;
+    $nein?: TValue extends readonly unknown[] ? Array<scalarOrReferenceType<arrayElementType<TValue>, TTarget, TContext> | sourceValueType<TTarget, TContext>> : never;
     /** String obsahuje podretezec (case-sensitive). */
     $has?: scalarOrReferenceType<string, TTarget, TContext>;
     /** String neobsahuje podretezec (case-sensitive). */
@@ -100,7 +121,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>;

package/package.json

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