node-condition-builder 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luca Rainone (luca.rainone@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,223 @@
+# ConditionBuilder
+
+A lightweight TypeScript library for building parameterized SQL WHERE clauses. It generates safe, injection-free condition strings with proper placeholder indexing for PostgreSQL and MySQL.
+
+## What it is
+
+A **condition builder** -- it takes your filter parameters and produces a SQL condition string plus an ordered array of values, ready to be passed to any database driver's parameterized query.
+
+## What it is NOT
+
+- Not an ORM
+- Not a query builder -- it only handles the WHERE clause
+- Not a database driver -- it produces strings, you execute them
+
+## Use cases
+
+- Building dynamic filters where conditions are optional
+- APIs with search/filter endpoints where any combination of parameters may be present
+- Anywhere you need safe, parameterized SQL conditions without string concatenation
+
+## Install
+
+```
+npm install node-condition-builder
+```
+
+## Quick start
+
+```typescript
+import { ConditionBuilder } from 'node-condition-builder';
+
+const condition = new ConditionBuilder('AND')
+  .isEqual('status', 'active')
+  .isGreater('age', 18)
+  .isNull('deleted_at', true);
+
+condition.build();     // (status = $1 AND age > $2 AND deleted_at IS NULL)
+condition.getValues(); // ['active', 18]
+```
+
+## Undefined values are ignored
+
+This is the key feature. When a value is `undefined`, the condition is silently skipped. This makes it trivial to build dynamic filters from optional parameters:
+
+```typescript
+interface UserFilters {
+  name?: string;
+  email?: string;
+  role?: string;
+  minAge?: number;
+  maxAge?: number;
+  isVerified?: boolean;
+  excludeRoles?: string[];
+}
+
+function filterUsers(filters: UserFilters) {
+  const condition = new ConditionBuilder('AND')
+    .isLike('name', filters.name ? `%${filters.name}%` : undefined)
+    .isEqual('email', filters.email)
+    .isEqual('role', filters.role)
+    .isGreaterOrEqual('age', filters.minAge)
+    .isLessOrEqual('age', filters.maxAge)
+    .isNotNull('verified_at', filters.isVerified)
+    .isNotIn('role', filters.excludeRoles);
+
+  const sql = `SELECT * FROM users WHERE ${condition.build()}`;
+  const values = condition.getValues();
+
+  return db.query(sql, values);
+}
+
+// Only name and minAge provided:
+filterUsers({ name: 'john', minAge: 18 });
+// SELECT * FROM users WHERE (name LIKE $1 AND age >= $2)
+// values: ['%john%', 18]
+
+// No filters at all:
+filterUsers({});
+// SELECT * FROM users WHERE (TRUE)
+// values: []
+```
+
+## API
+
+Every method is chainable and returns `this`.
+
+### Equality
+
+| Method | SQL |
+|---|---|
+| `isEqual(field, value)` | `field = $1` |
+| `isNotEqual(field, value)` | `field != $1` |
+
+### Comparison
+
+| Method | SQL |
+|---|---|
+| `isGreater(field, value)` | `field > $1` |
+| `isGreaterOrEqual(field, value)` | `field >= $1` |
+| `isLess(field, value)` | `field < $1` |
+| `isLessOrEqual(field, value)` | `field <= $1` |
+| `isNotGreater(field, value)` | `field <= $1` |
+| `isNotGreaterOrEqual(field, value)` | `field < $1` |
+| `isNotLess(field, value)` | `field >= $1` |
+| `isNotLessOrEqual(field, value)` | `field > $1` |
+
+### Range
+
+| Method | SQL |
+|---|---|
+| `isBetween(field, from, to)` | `(field BETWEEN $1 AND $2)` |
+| `isNotBetween(field, from, to)` | `(field NOT BETWEEN $1 AND $2)` |
+
+`isBetween` supports partial bounds: if only `from` is provided it becomes `>=`, if only `to` it becomes `<=`. Passing `null` throws an error (use `undefined` to skip a bound).
+
+### Inclusion
+
+| Method | SQL |
+|---|---|
+| `isIn(field, values)` | `field IN ($1, $2, ...)` |
+| `isNotIn(field, values)` | `field NOT IN ($1, $2, ...)` |
+
+### Pattern matching
+
+| Method | SQL |
+|---|---|
+| `isLike(field, value)` | `field LIKE $1` |
+| `isNotLike(field, value)` | `field NOT LIKE $1` |
+| `isILike(field, value)` | `field ILIKE $1` |
+| `isNotILike(field, value)` | `field NOT ILIKE $1` |
+
+`ILIKE` is PostgreSQL-specific (case-insensitive LIKE).
+
+### Null checks
+
+| Method | SQL |
+|---|---|
+| `isNull(field, true)` | `field IS NULL` |
+| `isNotNull(field, true)` | `field IS NOT NULL` |
+
+The boolean parameter controls whether the condition is added. `isNull('f', false)` is a no-op.
+
+### Raw expressions
+
+Use `expression()` to inject raw SQL where a value is expected. No placeholder is generated and no value is added to the parameter array:
+
+```typescript
+const condition = new ConditionBuilder('AND')
+  .isEqual('created_at', condition.expression('NOW()'))
+  .isGreater('updated_at', condition.expression("NOW() - INTERVAL '1 day'"));
+
+condition.build();     // (created_at = NOW() AND updated_at > NOW() - INTERVAL '1 day')
+condition.getValues(); // []
+```
+
+### Raw conditions
+
+Use `raw()` to inject an arbitrary SQL fragment as a condition. Use `?` as placeholder markers -- they will be replaced with the dialect's placeholders and values will be tracked:
+
+```typescript
+const condition = new ConditionBuilder('AND')
+  .isEqual('name', 'test')
+  .raw('ST_Distance(point, ?) < ?', [somePoint, 100]);
+
+condition.build();     // (name = $1 AND ST_Distance(point, $2) < $3)
+condition.getValues(); // ['test', somePoint, 100]
+```
+
+You can also use `raw()` without values for static fragments:
+
+```typescript
+condition.raw('active IS TRUE');
+```
+
+`raw()` follows the same `undefined` philosophy as the rest of the builder. When all values in the array are `undefined`, the condition is skipped. When some are `undefined` and some are not, it throws an error (since partial replacement in arbitrary SQL is ambiguous). Static calls without values (or with an empty array) are always added:
+
+```typescript
+condition.raw('? BETWEEN col1 AND col2', [undefined]); // skipped (all undefined)
+condition.raw('? BETWEEN col1 AND ?', [42, undefined]); // throws Error
+condition.raw('active IS TRUE');                         // always added (no values)
+```
+
+Use `\?` to include a literal `?` without it being treated as a placeholder (useful for PostgreSQL's jsonb `?` operator):
+
+```typescript
+condition.raw('data::jsonb \\? ? AND active = ?', ['key', true]);
+// → data::jsonb ? $1 AND active = $2
+```
+
+### Nesting with `append`
+
+Use `append()` to nest a ConditionBuilder inside another, mixing AND/OR logic:
+
+```typescript
+const condition = new ConditionBuilder('AND')
+  .isEqual('active', true)
+  .append(
+    new ConditionBuilder('OR')
+      .isEqual('role', 'admin')
+      .isEqual('role', 'editor')
+  );
+
+condition.build();     // (active = $1 AND (role = $2 OR role = $3))
+condition.getValues(); // [true, 'admin', 'editor']
+```
+
+Nesting is recursive -- you can nest as deep as you need.
+
+## Dialects
+
+PostgreSQL (`$1, $2, ...`) is the default. You can switch to MySQL (`?`) globally or per instance:
+
+```typescript
+// Global
+ConditionBuilder.DIALECT = 'mysql';
+
+// Per instance (overrides global)
+const condition = new ConditionBuilder('AND', 'mysql');
+```
+
+## Empty conditions
+
+An empty AND evaluates to `(TRUE)`, an empty OR to `(FALSE)`. This is safe to include in any query.

package/dist/ConditionBuilder.d.ts

@@ -0,0 +1,39 @@
+import type { DialectName } from './types.ts';
+import { Expression } from './Expression.ts';
+import { Condition } from './conditions/Condition.ts';
+export declare class ConditionBuilder extends Condition {
+    static DIALECT: DialectName;
+    private conditions;
+    private mode;
+    private dialect;
+    constructor(mode: 'AND' | 'OR', dialect?: DialectName);
+    expression(value: string): Expression;
+    private addComparison;
+    isEqual(field: string, value: unknown): this;
+    isNotEqual(field: string, value: unknown): this;
+    isGreater(field: string, value: unknown): this;
+    isNotGreater(field: string, value: unknown): this;
+    isGreaterOrEqual(field: string, value: unknown): this;
+    isNotGreaterOrEqual(field: string, value: unknown): this;
+    isLess(field: string, value: unknown): this;
+    isNotLess(field: string, value: unknown): this;
+    isLessOrEqual(field: string, value: unknown): this;
+    isNotLessOrEqual(field: string, value: unknown): this;
+    isLike(field: string, value: unknown): this;
+    isNotLike(field: string, value: unknown): this;
+    isILike(field: string, value: unknown): this;
+    isNotILike(field: string, value: unknown): this;
+    raw(sql: string, values?: unknown[]): this;
+    private addBetween;
+    isBetween(field: string, from: unknown, to: unknown): this;
+    isNotBetween(field: string, from: unknown, to: unknown): this;
+    isIn(field: string, values: unknown[] | undefined): this;
+    isNotIn(field: string, values: unknown[] | undefined): this;
+    isNull(field: string, isNull?: boolean): this;
+    isNotNull(field: string, isNotNull?: boolean): this;
+    append(builder: ConditionBuilder): this;
+    build(): string;
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=ConditionBuilder.d.ts.map

package/dist/ConditionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.d.ts","sourceRoot":"","sources":["../src/ConditionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAQtD,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,MAAM,CAAC,OAAO,EAAE,WAAW,CAAc;IAEzC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,OAAO,CAAc;gBAEjB,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,WAAW;IAMrD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAIrC,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAM5C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAM/C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI9C,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIjD,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIrD,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIxD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI3C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI9C,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIlD,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIrD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI3C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI9C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI5C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI/C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI;IAY1C,OAAO,CAAC,UAAU;IAiBlB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI;IAI1D,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI;IAI7D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,IAAI;IAMxD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,IAAI;IAM3D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAM7C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI;IAMnD,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAKvC,KAAK,IAAI,MAAM;IACf,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAkBzE,SAAS,IAAI,OAAO,EAAE;CAGvB"}

package/dist/ConditionBuilder.js

@@ -0,0 +1,156 @@
+import { Expression } from "./Expression.js";
+import { getPlaceholder } from "./dialects.js";
+import { Condition } from "./conditions/Condition.js";
+import { EqualCondition } from "./conditions/EqualCondition.js";
+import { ComparisonCondition } from "./conditions/ComparisonCondition.js";
+import { BetweenCondition } from "./conditions/BetweenCondition.js";
+import { InCondition } from "./conditions/InCondition.js";
+import { NullCondition } from "./conditions/NullCondition.js";
+import { RawCondition } from "./conditions/RawCondition.js";
+export class ConditionBuilder extends Condition {
+    static DIALECT = 'postgres';
+    conditions = [];
+    mode;
+    dialect;
+    constructor(mode, dialect) {
+        super();
+        this.mode = mode;
+        this.dialect = dialect ?? ConditionBuilder.DIALECT;
+    }
+    expression(value) {
+        return new Expression(value);
+    }
+    addComparison(field, operator, value) {
+        if (value === undefined)
+            return this;
+        this.conditions.push(new ComparisonCondition(field, operator, value));
+        return this;
+    }
+    isEqual(field, value) {
+        if (value === undefined)
+            return this;
+        this.conditions.push(new EqualCondition(field, value));
+        return this;
+    }
+    isNotEqual(field, value) {
+        if (value === undefined)
+            return this;
+        this.conditions.push(new EqualCondition(field, value, true));
+        return this;
+    }
+    isGreater(field, value) {
+        return this.addComparison(field, '>', value);
+    }
+    isNotGreater(field, value) {
+        return this.addComparison(field, '<=', value);
+    }
+    isGreaterOrEqual(field, value) {
+        return this.addComparison(field, '>=', value);
+    }
+    isNotGreaterOrEqual(field, value) {
+        return this.addComparison(field, '<', value);
+    }
+    isLess(field, value) {
+        return this.addComparison(field, '<', value);
+    }
+    isNotLess(field, value) {
+        return this.addComparison(field, '>=', value);
+    }
+    isLessOrEqual(field, value) {
+        return this.addComparison(field, '<=', value);
+    }
+    isNotLessOrEqual(field, value) {
+        return this.addComparison(field, '>', value);
+    }
+    isLike(field, value) {
+        return this.addComparison(field, 'LIKE', value);
+    }
+    isNotLike(field, value) {
+        return this.addComparison(field, 'NOT LIKE', value);
+    }
+    isILike(field, value) {
+        return this.addComparison(field, 'ILIKE', value);
+    }
+    isNotILike(field, value) {
+        return this.addComparison(field, 'NOT ILIKE', value);
+    }
+    raw(sql, values) {
+        if (values !== undefined && values.length > 0) {
+            const undefinedCount = values.filter(v => v === undefined).length;
+            if (undefinedCount === values.length)
+                return this;
+            if (undefinedCount > 0) {
+                throw new Error('raw() does not accept a mix of undefined and defined values');
+            }
+        }
+        this.conditions.push(new RawCondition(sql, values));
+        return this;
+    }
+    addBetween(field, from, to, negated) {
+        if (from === null || to === null) {
+            throw new Error('isBetween does not accept null values, use undefined to skip a bound');
+        }
+        if (from === undefined && to === undefined)
+            return this;
+        if (to === undefined) {
+            this.conditions.push(new ComparisonCondition(field, negated ? '<' : '>=', from));
+            return this;
+        }
+        if (from === undefined) {
+            this.conditions.push(new ComparisonCondition(field, negated ? '>' : '<=', to));
+            return this;
+        }
+        this.conditions.push(new BetweenCondition(field, from, to, negated));
+        return this;
+    }
+    isBetween(field, from, to) {
+        return this.addBetween(field, from, to, false);
+    }
+    isNotBetween(field, from, to) {
+        return this.addBetween(field, from, to, true);
+    }
+    isIn(field, values) {
+        if (values === undefined)
+            return this;
+        this.conditions.push(new InCondition(field, values));
+        return this;
+    }
+    isNotIn(field, values) {
+        if (values === undefined)
+            return this;
+        this.conditions.push(new InCondition(field, values, true));
+        return this;
+    }
+    isNull(field, isNull) {
+        if (!isNull)
+            return this;
+        this.conditions.push(new NullCondition(field));
+        return this;
+    }
+    isNotNull(field, isNotNull) {
+        if (!isNotNull)
+            return this;
+        this.conditions.push(new NullCondition(field, true));
+        return this;
+    }
+    append(builder) {
+        this.conditions.push(builder);
+        return this;
+    }
+    build(startIndex, placeholder) {
+        if (this.conditions.length === 0) {
+            return this.mode === 'AND' ? '(TRUE)' : '(FALSE)';
+        }
+        const ph = placeholder ?? getPlaceholder(this.dialect);
+        let currentIndex = startIndex ?? 1;
+        const parts = [];
+        for (const condition of this.conditions) {
+            parts.push(condition.build(currentIndex, ph));
+            currentIndex += condition.getValues().length;
+        }
+        return `(${parts.join(` ${this.mode} `)})`;
+    }
+    getValues() {
+        return this.conditions.flatMap(c => c.getValues());
+    }
+}

package/dist/Expression.d.ts

@@ -0,0 +1,5 @@
+export declare class Expression {
+    readonly value: string;
+    constructor(value: string);
+}
+//# sourceMappingURL=Expression.d.ts.map

package/dist/Expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.d.ts","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,MAAM;CAG1B"}

package/dist/Expression.js

@@ -0,0 +1,6 @@
+export class Expression {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}

package/dist/conditions/BetweenCondition.d.ts

@@ -0,0 +1,11 @@
+import { Condition } from './Condition.ts';
+export declare class BetweenCondition extends Condition {
+    private field;
+    private from;
+    private to;
+    private negated;
+    constructor(field: string, from: unknown, to: unknown, negated?: boolean);
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=BetweenCondition.d.ts.map

package/dist/conditions/BetweenCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BetweenCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/BetweenCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,EAAE,CAAU;IACpB,OAAO,CAAC,OAAO,CAAU;gBAEb,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,GAAE,OAAe;IAQ/E,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAYzE,SAAS,IAAI,OAAO,EAAE;CAMvB"}

package/dist/conditions/BetweenCondition.js

@@ -0,0 +1,34 @@
+import { Condition } from "./Condition.js";
+import { Expression } from "../Expression.js";
+export class BetweenCondition extends Condition {
+    field;
+    from;
+    to;
+    negated;
+    constructor(field, from, to, negated = false) {
+        super();
+        this.field = field;
+        this.from = from;
+        this.to = to;
+        this.negated = negated;
+    }
+    build(startIndex, placeholder) {
+        const fromStr = this.from instanceof Expression
+            ? this.from.value
+            : placeholder(startIndex);
+        const toIndex = this.from instanceof Expression ? startIndex : startIndex + 1;
+        const toStr = this.to instanceof Expression
+            ? this.to.value
+            : placeholder(toIndex);
+        const op = this.negated ? 'NOT BETWEEN' : 'BETWEEN';
+        return `(${this.field} ${op} ${fromStr} AND ${toStr})`;
+    }
+    getValues() {
+        const values = [];
+        if (!(this.from instanceof Expression))
+            values.push(this.from);
+        if (!(this.to instanceof Expression))
+            values.push(this.to);
+        return values;
+    }
+}

package/dist/conditions/ComparisonCondition.d.ts

@@ -0,0 +1,10 @@
+import { Condition } from './Condition.ts';
+export declare class ComparisonCondition extends Condition {
+    private field;
+    private operator;
+    private value;
+    constructor(field: string, operator: string, value: unknown);
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=ComparisonCondition.d.ts.map

package/dist/conditions/ComparisonCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComparisonCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/ComparisonCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAU;gBAEX,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAO3D,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAOzE,SAAS,IAAI,OAAO,EAAE;CAMvB"}

package/dist/conditions/ComparisonCondition.js

@@ -0,0 +1,25 @@
+import { Condition } from "./Condition.js";
+import { Expression } from "../Expression.js";
+export class ComparisonCondition extends Condition {
+    field;
+    operator;
+    value;
+    constructor(field, operator, value) {
+        super();
+        this.field = field;
+        this.operator = operator;
+        this.value = value;
+    }
+    build(startIndex, placeholder) {
+        if (this.value instanceof Expression) {
+            return `${this.field} ${this.operator} ${this.value.value}`;
+        }
+        return `${this.field} ${this.operator} ${placeholder(startIndex)}`;
+    }
+    getValues() {
+        if (this.value instanceof Expression) {
+            return [];
+        }
+        return [this.value];
+    }
+}

package/dist/conditions/Condition.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class Condition {
+    abstract build(startIndex: number, placeholder: (index: number) => string): string;
+    abstract getValues(): unknown[];
+}
+//# sourceMappingURL=Condition.d.ts.map

package/dist/conditions/Condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Condition.d.ts","sourceRoot":"","sources":["../../src/conditions/Condition.ts"],"names":[],"mappings":"AAAA,8BAAsB,SAAS;IAC7B,QAAQ,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAClF,QAAQ,CAAC,SAAS,IAAI,OAAO,EAAE;CAChC"}

package/dist/conditions/Condition.js

@@ -0,0 +1,2 @@
+export class Condition {
+}

package/dist/conditions/EqualCondition.d.ts

@@ -0,0 +1,10 @@
+import { Condition } from './Condition.ts';
+export declare class EqualCondition extends Condition {
+    private field;
+    private value;
+    private negated;
+    constructor(field: string, value: unknown, negated?: boolean);
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=EqualCondition.d.ts.map

package/dist/conditions/EqualCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EqualCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/EqualCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,qBAAa,cAAe,SAAQ,SAAS;IAC3C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,OAAO,CAAU;gBAEb,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,OAAe;IAOnE,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAQzE,SAAS,IAAI,OAAO,EAAE;CAMvB"}

package/dist/conditions/EqualCondition.js

@@ -0,0 +1,26 @@
+import { Condition } from "./Condition.js";
+import { Expression } from "../Expression.js";
+export class EqualCondition extends Condition {
+    field;
+    value;
+    negated;
+    constructor(field, value, negated = false) {
+        super();
+        this.field = field;
+        this.value = value;
+        this.negated = negated;
+    }
+    build(startIndex, placeholder) {
+        const op = this.negated ? '!=' : '=';
+        if (this.value instanceof Expression) {
+            return `${this.field} ${op} ${this.value.value}`;
+        }
+        return `${this.field} ${op} ${placeholder(startIndex)}`;
+    }
+    getValues() {
+        if (this.value instanceof Expression) {
+            return [];
+        }
+        return [this.value];
+    }
+}

package/dist/conditions/InCondition.d.ts

@@ -0,0 +1,10 @@
+import { Condition } from './Condition.ts';
+export declare class InCondition extends Condition {
+    private field;
+    private values;
+    private negated;
+    constructor(field: string, values: unknown[], negated?: boolean);
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=InCondition.d.ts.map

package/dist/conditions/InCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/InCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,OAAO,CAAU;gBAEb,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,GAAE,OAAe;IAOtE,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAezE,SAAS,IAAI,OAAO,EAAE;CAGvB"}

package/dist/conditions/InCondition.js

@@ -0,0 +1,31 @@
+import { Condition } from "./Condition.js";
+import { Expression } from "../Expression.js";
+export class InCondition extends Condition {
+    field;
+    values;
+    negated;
+    constructor(field, values, negated = false) {
+        super();
+        this.field = field;
+        this.values = values;
+        this.negated = negated;
+    }
+    build(startIndex, placeholder) {
+        let currentIndex = startIndex;
+        const parts = [];
+        for (const value of this.values) {
+            if (value instanceof Expression) {
+                parts.push(value.value);
+            }
+            else {
+                parts.push(placeholder(currentIndex));
+                currentIndex++;
+            }
+        }
+        const op = this.negated ? 'NOT IN' : 'IN';
+        return `${this.field} ${op} (${parts.join(', ')})`;
+    }
+    getValues() {
+        return this.values.filter(v => !(v instanceof Expression));
+    }
+}

package/dist/conditions/NullCondition.d.ts

@@ -0,0 +1,9 @@
+import { Condition } from './Condition.ts';
+export declare class NullCondition extends Condition {
+    private field;
+    private negated;
+    constructor(field: string, negated?: boolean);
+    build(_startIndex: number, _placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=NullCondition.d.ts.map

package/dist/conditions/NullCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NullCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/NullCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,qBAAa,aAAc,SAAQ,SAAS;IAC1C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAU;gBAEb,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe;IAMnD,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAI3E,SAAS,IAAI,OAAO,EAAE;CAGvB"}

package/dist/conditions/NullCondition.js

@@ -0,0 +1,16 @@
+import { Condition } from "./Condition.js";
+export class NullCondition extends Condition {
+    field;
+    negated;
+    constructor(field, negated = false) {
+        super();
+        this.field = field;
+        this.negated = negated;
+    }
+    build(_startIndex, _placeholder) {
+        return `${this.field} IS ${this.negated ? 'NOT ' : ''}NULL`;
+    }
+    getValues() {
+        return [];
+    }
+}

package/dist/conditions/RawCondition.d.ts

@@ -0,0 +1,9 @@
+import { Condition } from './Condition.ts';
+export declare class RawCondition extends Condition {
+    private sql;
+    private params;
+    constructor(sql: string, params?: unknown[]);
+    build(startIndex: number, placeholder: (index: number) => string): string;
+    getValues(): unknown[];
+}
+//# sourceMappingURL=RawCondition.d.ts.map

package/dist/conditions/RawCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RawCondition.d.ts","sourceRoot":"","sources":["../../src/conditions/RawCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,qBAAa,YAAa,SAAQ,SAAS;IACzC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAY;gBAEd,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,EAAO;IAM/C,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM;IAQzE,SAAS,IAAI,OAAO,EAAE;CAGvB"}

package/dist/conditions/RawCondition.js

@@ -0,0 +1,21 @@
+import { Condition } from "./Condition.js";
+export class RawCondition extends Condition {
+    sql;
+    params;
+    constructor(sql, params = []) {
+        super();
+        this.sql = sql;
+        this.params = params;
+    }
+    build(startIndex, placeholder) {
+        let currentIndex = startIndex;
+        return this.sql.replace(/\\\?|\?/g, (match) => {
+            if (match === '\\?')
+                return '?';
+            return placeholder(currentIndex++);
+        });
+    }
+    getValues() {
+        return this.params;
+    }
+}

package/dist/dialects.d.ts

@@ -0,0 +1,3 @@
+import type { DialectName } from './types.ts';
+export declare function getPlaceholder(dialect: DialectName): (index: number) => string;
+//# sourceMappingURL=dialects.d.ts.map

package/dist/dialects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialects.d.ts","sourceRoot":"","sources":["../src/dialects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAO9E"}

package/dist/dialects.js

@@ -0,0 +1,8 @@
+export function getPlaceholder(dialect) {
+    switch (dialect) {
+        case 'postgres':
+            return (i) => `$${i}`;
+        case 'mysql':
+            return (_i) => '?';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ConditionBuilder } from './ConditionBuilder.ts';
+export { Expression } from './Expression.ts';
+export type { DialectName } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { ConditionBuilder } from "./ConditionBuilder.js";
+export { Expression } from "./Expression.js";

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export type DialectName = 'postgres' | 'mysql';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "node-condition-builder",
+  "version": "1.0.0",
+  "description": "A lightweight TypeScript library for building parameterized SQL WHERE clauses. It generates safe, injection-free condition strings with proper placeholder indexing for PostgreSQL and MySQL",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run lint && npm test && npm run build",
+    "test": "node --test 'tests/**/*.test.ts'",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "keywords": [
+    "sql",
+    "query-builder",
+    "where-clause",
+    "condition-builder",
+    "parameterized-queries",
+    "no-dependencies",
+    "postgresql",
+    "mysql",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "eslint": "^9.39.2",
+    "jiti": "^2.6.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.55.0"
+  }
+}