@vbnz/conditions 0.0.1

package/README.md

@@ -0,0 +1,259 @@
+# @vbnz/conditions
+
+TypeScript библиотека для проверки условий по данным.
+
+## Установка
+
+```bash
+npm install @vbnz/conditions
+```
+
+## Базовое использование
+
+```ts
+import { check } from "@vbnz/conditions";
+
+const result = check(
+  { "{{ profile.uuid }}": { $eq: "some uuid" } },
+  { profile: { uuid: "some uuid" } }
+);
+
+console.log(result); // true
+```
+
+Библиотека поддерживает шаблонные ключи вида `{{ path.to.value }}` для доступа к вложенным полям.
+
+## Операторы сравнения
+
+### `$eq` — равно
+
+```ts
+check({ status: { $eq: "active" } }, { status: "active" }); // true
+check({ "{{ user.age }}": { $eq: 25 } }, { user: { age: 25 } }); // true
+```
+
+### `$ne` — не равно
+
+```ts
+check({ status: { $ne: "blocked" } }, { status: "active" }); // true
+check({ "{{ user.age }}": { $ne: 18 } }, { user: { age: 25 } }); // true
+```
+
+### `$gt` — больше
+
+```ts
+check({ "{{ user.age }}": { $gt: 18 } }, { user: { age: 25 } }); // true
+check({ "{{ score }}": { $gt: 100 } }, { score: 50 }); // false
+```
+
+### `$gte` — больше или равно
+
+```ts
+check({ "{{ user.age }}": { $gte: 18 } }, { user: { age: 18 } }); // true
+check({ "{{ user.age }}": { $gte: 21 } }, { user: { age: 18 } }); // false
+```
+
+### `$lt` — меньше
+
+```ts
+check({ "{{ user.age }}": { $lt: 30 } }, { user: { age: 25 } }); // true
+check({ "{{ score }}": { $lt: 50 } }, { score: 50 }); // false
+```
+
+### `$lte` — меньше или равно
+
+```ts
+check({ "{{ user.age }}": { $lte: 30 } }, { user: { age: 30 } }); // true
+check({ "{{ user.age }}": { $lte: 20 } }, { user: { age: 25 } }); // false
+```
+
+### `$between` — в диапазоне (включительно)
+
+```ts
+check({ "{{ score }}": { $between: [0, 100] } }, { score: 75 }); // true
+check({ "{{ score }}": { $between: [0, 50] } }, { score: 75 }); // false
+```
+
+### `$notBetween` — вне диапазона
+
+```ts
+check({ "{{ score }}": { $notBetween: [0, 50] } }, { score: 75 }); // true
+check({ "{{ score }}": { $notBetween: [0, 100] } }, { score: 75 }); // false
+```
+
+## Операторы включения
+
+### `$in` — значение в массиве
+
+```ts
+check({ status: { $in: ["active", "pending"] } }, { status: "active" }); // true
+check({ status: { $in: ["blocked"] } }, { status: "active" }); // false
+```
+
+### `$notIn` — значение не в массиве
+
+```ts
+check({ status: { $notIn: ["blocked", "deleted"] } }, { status: "active" }); // true
+check({ status: { $notIn: ["active"] } }, { status: "active" }); // false
+```
+
+## Строковые операторы
+
+### `$like` — шаблон SQL LIKE (`%` — любые символы, `_` — один символ)
+
+```ts
+check({ name: { $like: "John%" } }, { name: "John Doe" }); // true
+check({ name: { $like: "%Doe" } }, { name: "John Doe" }); // true
+check({ name: { $like: "J_hn" } }, { name: "John" }); // true
+check({ name: { $like: "john%" } }, { name: "John Doe" }); // false (регистрозависимый)
+```
+
+### `$iLike` — регистронезависимый LIKE
+
+```ts
+check({ name: { $iLike: "john%" } }, { name: "John Doe" }); // true
+check({ name: { $iLike: "%DOE" } }, { name: "John Doe" }); // true
+```
+
+### `$startsWith` — начинается с
+
+```ts
+check({ name: { $startsWith: "John" } }, { name: "John Doe" }); // true
+check({ name: { $startsWith: "Doe" } }, { name: "John Doe" }); // false
+```
+
+### `$endsWith` — заканчивается на
+
+```ts
+check({ name: { $endsWith: "Doe" } }, { name: "John Doe" }); // true
+check({ name: { $endsWith: "John" } }, { name: "John Doe" }); // false
+```
+
+### `$substring` — содержит подстроку
+
+```ts
+check({ name: { $substring: "hn D" } }, { name: "John Doe" }); // true
+check({ name: { $substring: "xyz" } }, { name: "John Doe" }); // false
+```
+
+### `$regexp` — соответствует регулярному выражению
+
+```ts
+check({ email: { $regexp: "^.+@.+\\.com$" } }, { email: "test@example.com" }); // true
+check({ email: { $regexp: /^.+@.+\.com$/ } }, { email: "test@example.com" }); // true (RegExp объект)
+check({ email: { $regexp: "\\.org$" } }, { email: "test@example.com" }); // false
+```
+
+### `$notRegexp` — не соответствует регулярному выражению
+
+```ts
+check({ email: { $notRegexp: "\\.org$" } }, { email: "test@example.com" }); // true
+check({ email: { $notRegexp: "\\.com$" } }, { email: "test@example.com" }); // false
+```
+
+## Операторы для массивов и объектов
+
+### `$contains` — содержит элемент / подстроку / подобъект
+
+Для строк:
+
+```ts
+check({ bio: { $contains: "developer" } }, { bio: "I am a developer" }); // true
+```
+
+Для массивов:
+
+```ts
+check({ tags: { $contains: "typescript" } }, { tags: ["js", "ts", "typescript"] }); // true
+check({ tags: { $contains: ["js", "ts"] } }, { tags: ["js", "ts", "node"] }); // true (все элементы)
+```
+
+Для объектов:
+
+```ts
+check(
+  { profile: { $contains: { role: "admin" } } },
+  { profile: { role: "admin", name: "John" } }
+); // true
+```
+
+### `$overlap` — пересечение массивов
+
+```ts
+check({ tags: { $overlap: ["ts", "python"] } }, { tags: ["js", "ts", "node"] }); // true (есть "ts")
+check({ tags: { $overlap: ["go", "rust"] } }, { tags: ["js", "ts"] }); // false
+```
+
+## Специальные операторы
+
+### `$is` — точное совпадение (аналог `$eq`, для явности)
+
+```ts
+check({ value: { $is: null } }, { value: null }); // true
+check({ value: { $is: undefined } }, { value: undefined }); // true
+```
+
+### `$not` — отрицание условия
+
+```ts
+check({ status: { $not: { $eq: "blocked" } } }, { status: "active" }); // true
+check({ "{{ user.age }}": { $not: { $lt: 18 } } }, { user: { age: 25 } }); // true
+```
+
+## Логические операторы
+
+### `$and` — логическое И
+
+```ts
+check(
+  {
+    $and: [
+      { "{{ user.age }}": { $gte: 18 } },
+      { "{{ user.verified }}": { $eq: true } }
+    ]
+  },
+  { user: { age: 25, verified: true } }
+); // true
+```
+
+### `$or` — логическое ИЛИ
+
+```ts
+check(
+  {
+    $or: [
+      { role: { $eq: "admin" } },
+      { role: { $eq: "moderator" } }
+    ]
+  },
+  { role: "moderator" }
+); // true
+```
+
+### `$not` на уровне условия — отрицание всего блока
+
+```ts
+check(
+  { $not: { status: { $eq: "blocked" } } },
+  { status: "active" }
+); // true
+```
+
+## Комбинирование операторов
+
+Операторы можно комбинировать в одном условии:
+
+```ts
+check(
+  {
+    "{{ user.age }}": { $gte: 18, $lte: 65 },
+    status: { $in: ["active", "pending"] },
+    name: { $iLike: "%john%" }
+  },
+  {
+    user: { age: 25 },
+    status: "active",
+    name: "John Doe"
+  }
+); // true
+```

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export type Primitive = string | number | boolean | null | undefined;
+export type OperatorCondition = {
+    $eq?: unknown;
+    $ne?: unknown;
+    $gt?: number;
+    $gte?: number;
+    $lt?: number;
+    $lte?: number;
+    $in?: unknown[];
+    $notIn?: unknown[];
+    $between?: [number, number];
+    $notBetween?: [number, number];
+    $like?: string;
+    $iLike?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+    $substring?: string;
+    $regexp?: string | RegExp;
+    $notRegexp?: string | RegExp;
+    $contains?: unknown;
+    $overlap?: unknown[];
+    $is?: unknown;
+    $not?: FieldCondition;
+};
+export type FieldCondition = Primitive | OperatorCondition;
+export type Condition = {
+    [key: string]: FieldCondition | Condition[] | Condition;
+} & {
+    $and?: Condition[];
+    $or?: Condition[];
+    $not?: Condition;
+};
+export declare function check(condition: Condition, payload: unknown): boolean;

package/dist/index.js

@@ -0,0 +1,136 @@
+"use strict";
+// ==================== Types ====================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+// ==================== Utils ====================
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getByPath(source, path) {
+    if (!path)
+        return undefined;
+    return path.split(".").reduce((acc, key) => {
+        return isObject(acc) ? acc[key] : undefined;
+    }, source);
+}
+function extractPath(key) {
+    const match = key.match(/^\{\{\s*(.+?)\s*\}\}$/);
+    return match ? match[1].trim() : key;
+}
+function toRegExp(pattern, flags) {
+    return pattern instanceof RegExp
+        ? new RegExp(pattern.source, flags !== null && flags !== void 0 ? flags : pattern.flags)
+        : new RegExp(pattern, flags);
+}
+function likeToRegExp(pattern, insensitive = false) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = `^${escaped.replace(/%/g, ".*").replace(/_/g, ".")}$`;
+    return new RegExp(regex, insensitive ? "i" : "");
+}
+const operators = {
+    $eq: (actual, expected) => actual === expected,
+    $ne: (actual, expected) => actual !== expected,
+    $is: (actual, expected) => actual === expected,
+    $gt: (actual, expected) => typeof actual === "number" && actual > expected,
+    $gte: (actual, expected) => typeof actual === "number" && actual >= expected,
+    $lt: (actual, expected) => typeof actual === "number" && actual < expected,
+    $lte: (actual, expected) => typeof actual === "number" && actual <= expected,
+    $in: (actual, expected) => Array.isArray(expected) && expected.includes(actual),
+    $notIn: (actual, expected) => Array.isArray(expected) && !expected.includes(actual),
+    $between: (actual, expected) => {
+        if (typeof actual !== "number" || !Array.isArray(expected))
+            return false;
+        const [min, max] = expected;
+        return actual >= min && actual <= max;
+    },
+    $notBetween: (actual, expected) => {
+        if (typeof actual !== "number" || !Array.isArray(expected))
+            return false;
+        const [min, max] = expected;
+        return actual < min || actual > max;
+    },
+    $like: (actual, expected) => typeof actual === "string" && likeToRegExp(expected).test(actual),
+    $iLike: (actual, expected) => typeof actual === "string" && likeToRegExp(expected, true).test(actual),
+    $startsWith: (actual, expected) => typeof actual === "string" && actual.startsWith(expected),
+    $endsWith: (actual, expected) => typeof actual === "string" && actual.endsWith(expected),
+    $substring: (actual, expected) => typeof actual === "string" && actual.includes(expected),
+    $regexp: (actual, expected) => typeof actual === "string" && toRegExp(expected).test(actual),
+    $notRegexp: (actual, expected) => typeof actual === "string" && !toRegExp(expected).test(actual),
+    $contains: (actual, expected) => {
+        if (typeof actual === "string") {
+            return typeof expected === "string" && actual.includes(expected);
+        }
+        if (Array.isArray(actual)) {
+            return Array.isArray(expected)
+                ? expected.every(item => actual.includes(item))
+                : actual.includes(expected);
+        }
+        if (isObject(actual) && isObject(expected)) {
+            return Object.entries(expected).every(([k, v]) => actual[k] === v);
+        }
+        return false;
+    },
+    $overlap: (actual, expected) => {
+        if (!Array.isArray(actual) || !Array.isArray(expected))
+            return false;
+        return expected.some(item => actual.includes(item));
+    },
+};
+// ==================== Evaluation ====================
+function evaluateOperators(actual, condition) {
+    for (const [op, expected] of Object.entries(condition)) {
+        if (op === "$not") {
+            if (evaluateField(actual, expected))
+                return false;
+            continue;
+        }
+        const fn = operators[op];
+        if (!fn)
+            continue;
+        if (!fn(actual, expected))
+            return false;
+    }
+    return true;
+}
+function evaluateField(actual, condition) {
+    if (!isObject(condition)) {
+        return actual === condition;
+    }
+    const hasOperator = Object.keys(condition).some(key => key.startsWith("$"));
+    if (!hasOperator) {
+        return actual === condition;
+    }
+    return evaluateOperators(actual, condition);
+}
+// ==================== Logical Operators ====================
+function evaluateLogical(condition, payload) {
+    if (condition.$and) {
+        if (!condition.$and.every(c => check(c, payload)))
+            return false;
+    }
+    if (condition.$or) {
+        if (!condition.$or.some(c => check(c, payload)))
+            return false;
+    }
+    if (condition.$not) {
+        if (check(condition.$not, payload))
+            return false;
+    }
+    return true;
+}
+// ==================== Main API ====================
+function check(condition, payload) {
+    // Logical operators
+    if (!evaluateLogical(condition, payload))
+        return false;
+    // Field conditions
+    for (const [rawKey, rule] of Object.entries(condition)) {
+        if (rawKey.startsWith("$"))
+            continue;
+        const path = extractPath(rawKey);
+        const actual = getByPath(payload, path);
+        if (!evaluateField(actual, rule))
+            return false;
+    }
+    return true;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vbnz/conditions",
+  "version": "0.0.1",
+  "description": "Lightweight condition checker",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "conditions",
+    "rules",
+    "typescript"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,195 @@
+// ==================== Types ====================
+
+export type Primitive = string | number | boolean | null | undefined;
+
+export type OperatorCondition = {
+    $eq?: unknown;
+    $ne?: unknown;
+    $gt?: number;
+    $gte?: number;
+    $lt?: number;
+    $lte?: number;
+    $in?: unknown[];
+    $notIn?: unknown[];
+    $between?: [number, number];
+    $notBetween?: [number, number];
+    $like?: string;
+    $iLike?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+    $substring?: string;
+    $regexp?: string | RegExp;
+    $notRegexp?: string | RegExp;
+    $contains?: unknown;
+    $overlap?: unknown[];
+    $is?: unknown;
+    $not?: FieldCondition;
+};
+
+export type FieldCondition = Primitive | OperatorCondition;
+
+export type Condition = {
+    [key: string]: FieldCondition | Condition[] | Condition;
+} & {
+    $and?: Condition[];
+    $or?: Condition[];
+    $not?: Condition;
+};
+
+// ==================== Utils ====================
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getByPath(source: unknown, path: string): unknown {
+    if (!path) return undefined;
+
+    return path.split(".").reduce<unknown>((acc, key) => {
+        return isObject(acc) ? acc[key] : undefined;
+    }, source);
+}
+
+function extractPath(key: string): string {
+    const match = key.match(/^\{\{\s*(.+?)\s*\}\}$/);
+    return match ? match[1].trim() : key;
+}
+
+function toRegExp(pattern: string | RegExp, flags?: string): RegExp {
+    return pattern instanceof RegExp 
+        ? new RegExp(pattern.source, flags ?? pattern.flags)
+        : new RegExp(pattern, flags);
+}
+
+function likeToRegExp(pattern: string, insensitive = false): RegExp {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = `^${escaped.replace(/%/g, ".*").replace(/_/g, ".")}$`;
+    return new RegExp(regex, insensitive ? "i" : "");
+}
+
+// ==================== Operators ====================
+
+type OperatorFn = (actual: unknown, expected: unknown) => boolean;
+
+const operators: Record<string, OperatorFn> = {
+    $eq: (actual, expected) => actual === expected,
+    $ne: (actual, expected) => actual !== expected,
+    $is: (actual, expected) => actual === expected,
+    
+    $gt: (actual, expected) => typeof actual === "number" && actual > (expected as number),
+    $gte: (actual, expected) => typeof actual === "number" && actual >= (expected as number),
+    $lt: (actual, expected) => typeof actual === "number" && actual < (expected as number),
+    $lte: (actual, expected) => typeof actual === "number" && actual <= (expected as number),
+    
+    $in: (actual, expected) => Array.isArray(expected) && expected.includes(actual),
+    $notIn: (actual, expected) => Array.isArray(expected) && !expected.includes(actual),
+    
+    $between: (actual, expected) => {
+        if (typeof actual !== "number" || !Array.isArray(expected)) return false;
+        const [min, max] = expected as [number, number];
+        return actual >= min && actual <= max;
+    },
+    
+    $notBetween: (actual, expected) => {
+        if (typeof actual !== "number" || !Array.isArray(expected)) return false;
+        const [min, max] = expected as [number, number];
+        return actual < min || actual > max;
+    },
+    
+    $like: (actual, expected) => typeof actual === "string" && likeToRegExp(expected as string).test(actual),
+    $iLike: (actual, expected) => typeof actual === "string" && likeToRegExp(expected as string, true).test(actual),
+    
+    $startsWith: (actual, expected) => typeof actual === "string" && actual.startsWith(expected as string),
+    $endsWith: (actual, expected) => typeof actual === "string" && actual.endsWith(expected as string),
+    $substring: (actual, expected) => typeof actual === "string" && actual.includes(expected as string),
+    
+    $regexp: (actual, expected) => typeof actual === "string" && toRegExp(expected as string | RegExp).test(actual),
+    $notRegexp: (actual, expected) => typeof actual === "string" && !toRegExp(expected as string | RegExp).test(actual),
+    
+    $contains: (actual, expected) => {
+        if (typeof actual === "string") {
+            return typeof expected === "string" && actual.includes(expected);
+        }
+        if (Array.isArray(actual)) {
+            return Array.isArray(expected)
+                ? expected.every(item => actual.includes(item))
+                : actual.includes(expected);
+        }
+        if (isObject(actual) && isObject(expected)) {
+            return Object.entries(expected).every(([k, v]) => actual[k] === v);
+        }
+        return false;
+    },
+    
+    $overlap: (actual, expected) => {
+        if (!Array.isArray(actual) || !Array.isArray(expected)) return false;
+        return expected.some(item => actual.includes(item));
+    },
+};
+
+// ==================== Evaluation ====================
+
+function evaluateOperators(actual: unknown, condition: OperatorCondition): boolean {
+    for (const [op, expected] of Object.entries(condition)) {
+        if (op === "$not") {
+            if (evaluateField(actual, expected as FieldCondition)) return false;
+            continue;
+        }
+        
+        const fn = operators[op];
+        if (!fn) continue;
+        
+        if (!fn(actual, expected)) return false;
+    }
+    return true;
+}
+
+function evaluateField(actual: unknown, condition: FieldCondition): boolean {
+    if (!isObject(condition)) {
+        return actual === condition;
+    }
+    
+    const hasOperator = Object.keys(condition).some(key => key.startsWith("$"));
+    if (!hasOperator) {
+        return actual === condition;
+    }
+    
+    return evaluateOperators(actual, condition as OperatorCondition);
+}
+
+// ==================== Logical Operators ====================
+
+function evaluateLogical(condition: Condition, payload: unknown): boolean {
+    if (condition.$and) {
+        if (!condition.$and.every(c => check(c, payload))) return false;
+    }
+
+    if (condition.$or) {
+        if (!condition.$or.some(c => check(c, payload))) return false;
+    }
+
+    if (condition.$not) {
+        if (check(condition.$not, payload)) return false;
+    }
+
+    return true;
+}
+
+// ==================== Main API ====================
+
+export function check(condition: Condition, payload: unknown): boolean {
+    // Logical operators
+    if (!evaluateLogical(condition, payload)) return false;
+    
+    // Field conditions
+    for (const [rawKey, rule] of Object.entries(condition)) {
+        if (rawKey.startsWith("$")) continue;
+        
+        const path = extractPath(rawKey);
+        const actual = getByPath(payload, path);
+        
+        if (!evaluateField(actual, rule as FieldCondition)) return false;
+    }
+    
+    return true;
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}