supalite 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.8.2] - 2026-02-23
+
+### ✨ Added
+- `or()`에서 중첩 `and(...)` / `or(...)` 그룹 파싱을 지원합니다. (PostgREST-style)
+- `or()`에서 `in.(...)` 연산자를 지원합니다.
+- `or()`에서 `not.*` 연산자(`not.eq`, `not.ilike`, `not.is`, `not.in` 등)를 지원합니다.
+- 중첩 `or()` 전용 회귀 테스트 파일을 추가해 복합 케이스를 대폭 확장했습니다.
+
+### 🐞 Fixed
+- `or('...,and(...)')` 구문이 `and(created_at`를 컬럼으로 오해해 SQL 에러를 내던 문제를 수정했습니다.
+- 괄호/따옴표가 깨진 `or()` 입력에서 명확한 파서 에러를 반환하도록 개선했습니다.
+
 ## [0.8.1] - 2026-02-03
 
 ### 🐞 Fixed

package/README.md

@@ -533,6 +533,18 @@ const { data: credits } = await client
   .eq('wallet_id', 123)
   .gt('amount', 0)
   .or('valid_until.is.null,valid_until.gt.now()');
+
+// Nested and(...) inside or(...) (PostgREST-style keyset pattern)
+const { data: images } = await client
+  .from('priv_images')
+  .select('id,created_at')
+  .or('created_at.lt.2026-02-13T09:09:32.000Z,and(created_at.eq.2026-02-13T09:09:32.000Z,id.lt.1462)');
+
+// in / not.* inside or()
+const { data: users } = await client
+  .from('users')
+  .select('*')
+  .or('and(id.in.(1,2,3),status.not.eq.inactive)');
 ```
 
 ### Sorting/Pagination
@@ -1032,7 +1044,11 @@ await client.close();
 - `is(column, value)`: IS
 - `not(column, operator, value)`: currently only `not('column', 'is', null)` is supported
 - `contains(column, value)`: array/JSON contains
-- `or(conditions)`: OR condition string (ops: eq/neq/like/ilike/gt/gte/lt/lte/is, `now()` is inlined as `NOW()`); quote values to include dots/commas (e.g. `name.eq."last, first"`)
+- `or(conditions)`: OR condition string (ops: eq/neq/like/ilike/gt/gte/lt/lte/is/in + `not.*`, `now()` is inlined as `NOW()`)
+  - Supports nested `and(...)` and `or(...)` groups (PostgREST-style), e.g. `created_at.lt.ts,and(created_at.eq.ts,id.lt.1462)`
+  - Supports `in.(...)` and negated ops such as `status.not.eq.inactive`, `id.not.in.(1,2,3)`, `deleted_at.not.is.null`
+  - Quote values to include dots/commas (e.g. `name.eq."last, first"`)
+  - Related table filters are not supported inside `or()`
 
 ### Other methods
 

package/SPEC.md

@@ -79,11 +79,15 @@ Notes:
 - `in(col, [..., null])` emits `("col" IN (...) OR "col" IS NULL)`; if only NULLs are provided, it emits `IS NULL`.
 - `contains` uses `@>`.
 - `or()` expects `col.op.value` segments separated by commas.
-  - Supported ops: `eq`, `neq`, `like`, `ilike`, `gt`, `gte`, `lt`, `lte`, `is`.
+  - Nested `and(...)` and `or(...)` groups are supported inside `or()` (e.g. `created_at.lt.ts,and(created_at.eq.ts,id.lt.1462)`).
+  - Supported ops: `eq`, `neq`, `like`, `ilike`, `gt`, `gte`, `lt`, `lte`, `is`, `in`.
+  - Negated forms are supported via `not.*` (e.g. `status.not.eq.inactive`, `deleted_at.not.is.null`, `id.not.in.(1,2)`).
   - `value` is treated as a literal string; `null` maps to SQL NULL; numeric strings are kept as strings.
   - `is.null` uses `IS NULL` without a placeholder.
+  - `in.(...)` values are parsed as a parenthesized list; `null` entries are handled as `IS NULL`/`IS NOT NULL` branches.
   - `now()` is inlined as `NOW()` for comparison operators (no placeholder).
   - Quote values to include dots/commas (e.g. `name.eq."last, first"`).
+  - Malformed nested expressions throw clear parser errors (for example, unbalanced parentheses).
 
 ### 4.3 Ordering and pagination
 - `order('col')` defaults to `ASC`.

package/dist/query-builder.d.ts

@@ -32,6 +32,10 @@ export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName
     private splitOrConditions;
     private splitOrCondition;
     private unescapeOrValue;
+    private normalizeOrLiteralValue;
+    private parseOrInValues;
+    private buildOrLeafClause;
+    private parseOrSegment;
     private parseSelection;
     private quoteIdentifier;
     private quoteColumn;

package/dist/query-builder.js

@@ -56,6 +56,7 @@ class QueryBuilder {
         let current = '';
         let inQuotes = false;
         let escaped = false;
+        let depth = 0;
         for (let i = 0; i < input.length; i += 1) {
             const char = input[i];
             if (escaped) {
@@ -73,7 +74,22 @@ class QueryBuilder {
                 current += char;
                 continue;
             }
-            if (char === ',' && !inQuotes) {
+            if (!inQuotes) {
+                if (char === '(') {
+                    depth += 1;
+                    current += char;
+                    continue;
+                }
+                if (char === ')') {
+                    if (depth === 0) {
+                        throw new Error('Malformed or() condition: unexpected closing parenthesis.');
+                    }
+                    depth -= 1;
+                    current += char;
+                    continue;
+                }
+            }
+            if (char === ',' && !inQuotes && depth === 0) {
                 if (current.trim()) {
                     parts.push(current.trim());
                 }
@@ -82,6 +98,12 @@ class QueryBuilder {
             }
             current += char;
         }
+        if (inQuotes) {
+            throw new Error('Malformed or() condition: unterminated double quote.');
+        }
+        if (depth !== 0) {
+            throw new Error('Malformed or() condition: unbalanced parentheses.');
+        }
         if (current.trim()) {
             parts.push(current.trim());
         }
@@ -90,8 +112,7 @@ class QueryBuilder {
     splitOrCondition(condition) {
         let inQuotes = false;
         let escaped = false;
-        let firstDot = -1;
-        let secondDot = -1;
+        const dotPositions = [];
         for (let i = 0; i < condition.length; i += 1) {
             const char = condition[i];
             if (escaped) {
@@ -107,18 +128,37 @@ class QueryBuilder {
                 continue;
             }
             if (char === '.' && !inQuotes) {
-                if (firstDot === -1) {
-                    firstDot = i;
-                }
-                else {
-                    secondDot = i;
-                    break;
-                }
+                dotPositions.push(i);
             }
         }
-        if (firstDot === -1 || secondDot === -1) {
+        if (dotPositions.length < 2) {
             return null;
         }
+        const validOperators = new Set(['eq', 'neq', 'ilike', 'like', 'gt', 'gte', 'lt', 'lte', 'is', 'in']);
+        for (let left = 0; left < dotPositions.length - 1; left += 1) {
+            for (let right = left + 1; right < dotPositions.length; right += 1) {
+                const firstDot = dotPositions[left];
+                const secondDot = dotPositions[right];
+                const field = condition.slice(0, firstDot).trim();
+                const op = condition.slice(firstDot + 1, secondDot).trim();
+                const value = condition.slice(secondDot + 1).trim();
+                if (field && op && value && validOperators.has(op)) {
+                    return { field, op, value };
+                }
+                if (op === 'not') {
+                    for (let third = right + 1; third < dotPositions.length; third += 1) {
+                        const thirdDot = dotPositions[third];
+                        const notOp = condition.slice(secondDot + 1, thirdDot).trim();
+                        const notValue = condition.slice(thirdDot + 1).trim();
+                        if (field && notOp && notValue && validOperators.has(notOp)) {
+                            return { field, op: `not.${notOp}`, value: notValue };
+                        }
+                    }
+                }
+            }
+        }
+        const firstDot = dotPositions[0];
+        const secondDot = dotPositions[1];
         const field = condition.slice(0, firstDot).trim();
         const op = condition.slice(firstDot + 1, secondDot).trim();
         const value = condition.slice(secondDot + 1).trim();
@@ -127,6 +167,180 @@ class QueryBuilder {
     unescapeOrValue(value) {
         return value.replace(/\\([\\\".,])/g, '$1');
     }
+    normalizeOrLiteralValue(value) {
+        if (value === 'null') {
+            return null;
+        }
+        if (!isNaN(Number(value))) {
+            return value;
+        }
+        if (value.match(/^\d{4}-\d{2}-\d{2}/)) {
+            return value;
+        }
+        return value;
+    }
+    parseOrInValues(value) {
+        if (!value.startsWith('(') || !value.endsWith(')')) {
+            throw new Error(`Invalid or() IN value: "${value}". Expected parenthesized list like "(a,b)".`);
+        }
+        const inner = value.slice(1, -1).trim();
+        if (!inner) {
+            return [];
+        }
+        return this.splitOrConditions(inner).map((raw) => {
+            let item = raw.trim();
+            if (item.startsWith('"') && item.endsWith('"')) {
+                item = item.slice(1, -1);
+            }
+            return this.unescapeOrValue(item);
+        });
+    }
+    buildOrLeafClause(condition) {
+        const parsed = this.splitOrCondition(condition);
+        if (!parsed) {
+            throw new Error(`Invalid or() condition segment: "${condition}". Expected "column.operator.value".`);
+        }
+        const { field, op, value } = parsed;
+        if (!field || !op) {
+            throw new Error(`Invalid or() condition segment: "${condition}". Expected "column.operator.value".`);
+        }
+        if (field.includes('.')) {
+            throw new Error('or() does not support related table filters.');
+        }
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(field)) {
+            throw new Error(`Invalid or() column: "${field}". Use "column.operator.value" or nested and(...)/or(...).`);
+        }
+        const isNegated = op.startsWith('not.');
+        const baseOp = isNegated ? op.slice(4) : op;
+        const validOperators = ['eq', 'neq', 'ilike', 'like', 'gt', 'gte', 'lt', 'lte', 'is', 'in'];
+        if (!validOperators.includes(baseOp)) {
+            throw new Error(`Invalid operator: ${baseOp}`);
+        }
+        let normalizedValue = value;
+        if (normalizedValue.startsWith('"') && normalizedValue.endsWith('"')) {
+            normalizedValue = normalizedValue.slice(1, -1);
+        }
+        normalizedValue = this.unescapeOrValue(normalizedValue);
+        const isNullValue = normalizedValue === 'null';
+        const isNowValue = typeof normalizedValue === 'string' && normalizedValue.toLowerCase() === 'now()';
+        const quotedField = this.quoteColumn(field);
+        const buildPlaceholderClause = (sqlOp) => {
+            this.whereValues.push(this.normalizeOrLiteralValue(normalizedValue));
+            const paramIndex = this.whereValues.length;
+            return `${quotedField} ${sqlOp} $${paramIndex}`;
+        };
+        const buildClause = (sqlOp) => {
+            if (isNowValue) {
+                return `${quotedField} ${sqlOp} NOW()`;
+            }
+            return buildPlaceholderClause(sqlOp);
+        };
+        if (baseOp === 'in') {
+            const parsedValues = this.parseOrInValues(normalizedValue);
+            const hasNull = parsedValues.includes('null');
+            const nonNullValues = parsedValues.filter((item) => item !== 'null');
+            const pushPlaceholders = (items) => {
+                const placeholders = items.map((item) => {
+                    this.whereValues.push(this.normalizeOrLiteralValue(item));
+                    return `$${this.whereValues.length}`;
+                });
+                return placeholders.join(',');
+            };
+            if (!isNegated) {
+                if (nonNullValues.length === 0 && hasNull) {
+                    return `${quotedField} IS NULL`;
+                }
+                if (nonNullValues.length === 0) {
+                    return 'FALSE';
+                }
+                const inList = pushPlaceholders(nonNullValues);
+                if (hasNull) {
+                    return `(${quotedField} IN (${inList}) OR ${quotedField} IS NULL)`;
+                }
+                return `${quotedField} IN (${inList})`;
+            }
+            if (nonNullValues.length === 0 && hasNull) {
+                return `${quotedField} IS NOT NULL`;
+            }
+            if (nonNullValues.length === 0) {
+                return 'TRUE';
+            }
+            const notInList = pushPlaceholders(nonNullValues);
+            if (hasNull) {
+                return `(${quotedField} NOT IN (${notInList}) AND ${quotedField} IS NOT NULL)`;
+            }
+            return `${quotedField} NOT IN (${notInList})`;
+        }
+        const resolveSqlOperator = (operator) => {
+            if (!isNegated) {
+                return operator;
+            }
+            switch (operator) {
+                case '=':
+                    return '!=';
+                case '!=':
+                    return '=';
+                case 'LIKE':
+                    return 'NOT LIKE';
+                case 'ILIKE':
+                    return 'NOT ILIKE';
+                case '>':
+                    return '<=';
+                case '>=':
+                    return '<';
+                case '<':
+                    return '>=';
+                case '<=':
+                    return '>';
+                case 'IS':
+                    return 'IS NOT';
+                default:
+                    return operator;
+            }
+        };
+        switch (baseOp) {
+            case 'eq':
+                return buildClause(resolveSqlOperator('='));
+            case 'neq':
+                return buildClause(resolveSqlOperator('!='));
+            case 'ilike':
+                return buildClause(resolveSqlOperator('ILIKE'));
+            case 'like':
+                return buildClause(resolveSqlOperator('LIKE'));
+            case 'gt':
+                return buildClause(resolveSqlOperator('>'));
+            case 'gte':
+                return buildClause(resolveSqlOperator('>='));
+            case 'lt':
+                return buildClause(resolveSqlOperator('<'));
+            case 'lte':
+                return buildClause(resolveSqlOperator('<='));
+            case 'is':
+                if (isNullValue) {
+                    return isNegated ? `${quotedField} IS NOT NULL` : `${quotedField} IS NULL`;
+                }
+                return buildPlaceholderClause(resolveSqlOperator('IS'));
+            default:
+                throw new Error(`Invalid operator: ${baseOp}`);
+        }
+    }
+    parseOrSegment(condition) {
+        const trimmed = condition.trim();
+        if (!trimmed) {
+            throw new Error('Invalid or() condition: empty segment.');
+        }
+        const lower = trimmed.toLowerCase();
+        if ((lower.startsWith('and(') || lower.startsWith('or(')) && trimmed.endsWith(')')) {
+            const useAnd = lower.startsWith('and(');
+            const inner = trimmed.slice(trimmed.indexOf('(') + 1, -1).trim();
+            const parts = this.splitOrConditions(inner).map((part) => this.parseOrSegment(part));
+            if (parts.length === 0) {
+                throw new Error(`Invalid or() condition: ${useAnd ? 'and' : 'or'}(...) requires at least one segment.`);
+            }
+            return `(${parts.join(useAnd ? ' AND ' : ' OR ')})`;
+        }
+        return this.buildOrLeafClause(trimmed);
+    }
     parseSelection(input) {
         const tokens = this.splitTopLevel(input);
         const items = [];
@@ -447,77 +661,7 @@ class QueryBuilder {
         return this;
     }
     or(conditions) {
-        const orParts = this.splitOrConditions(conditions).map(condition => {
-            const parsed = this.splitOrCondition(condition);
-            if (!parsed) {
-                return '';
-            }
-            const { field, op, value } = parsed;
-            if (!field || !op) {
-                return '';
-            }
-            if (field.includes('.')) {
-                throw new Error('or() does not support related table filters.');
-            }
-            const validOperators = ['eq', 'neq', 'ilike', 'like', 'gt', 'gte', 'lt', 'lte', 'is'];
-            if (!validOperators.includes(op)) {
-                throw new Error(`Invalid operator: ${op}`);
-            }
-            let normalizedValue = value;
-            if (normalizedValue.startsWith('"') && normalizedValue.endsWith('"')) {
-                normalizedValue = normalizedValue.slice(1, -1);
-            }
-            normalizedValue = this.unescapeOrValue(normalizedValue);
-            const isNullValue = normalizedValue === 'null';
-            const isNowValue = typeof normalizedValue === 'string' && normalizedValue.toLowerCase() === 'now()';
-            const quotedField = this.quoteColumn(field);
-            const buildPlaceholderClause = (sqlOp) => {
-                let processedValue = normalizedValue;
-                if (isNullValue) {
-                    processedValue = null;
-                }
-                else if (typeof normalizedValue === 'string' && !isNaN(Number(normalizedValue))) {
-                    processedValue = normalizedValue;
-                }
-                else if (typeof normalizedValue === 'string' && normalizedValue.match(/^\d{4}-\d{2}-\d{2}/)) {
-                    processedValue = normalizedValue;
-                }
-                this.whereValues.push(processedValue);
-                const paramIndex = this.whereValues.length;
-                return `${quotedField} ${sqlOp} $${paramIndex}`;
-            };
-            const buildClause = (sqlOp) => {
-                if (isNowValue) {
-                    return `${quotedField} ${sqlOp} NOW()`;
-                }
-                return buildPlaceholderClause(sqlOp);
-            };
-            switch (op) {
-                case 'eq':
-                    return buildClause('=');
-                case 'neq':
-                    return buildClause('!=');
-                case 'ilike':
-                    return buildClause('ILIKE');
-                case 'like':
-                    return buildClause('LIKE');
-                case 'gt':
-                    return buildClause('>');
-                case 'gte':
-                    return buildClause('>=');
-                case 'lt':
-                    return buildClause('<');
-                case 'lte':
-                    return buildClause('<=');
-                case 'is':
-                    if (isNullValue) {
-                        return `${quotedField} IS NULL`;
-                    }
-                    return buildPlaceholderClause('IS');
-                default:
-                    return '';
-            }
-        }).filter(Boolean);
+        const orParts = this.splitOrConditions(conditions).map((condition) => this.parseOrSegment(condition));
         if (orParts.length > 0) {
             this.whereConditions.push(`(${orParts.join(' OR ')})`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supalite",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "A lightweight TypeScript PostgreSQL client with Supabase-style API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",