supalite 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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
+- insert/update/upsert에서 `undefined` 필드를 제외하도록 수정했습니다.
+- multi-row insert에서 누락/undefined 값을 `DEFAULT`로 처리합니다.
+- 단일 insert에 정의된 필드가 없으면 `DEFAULT VALUES`를 사용합니다.
+
 ## [0.8.0] - 2026-01-19
 
 ### ✨ Added

package/README.ko.md

@@ -814,6 +814,7 @@ await client
 ```
 
 빈 배열 `insert([])`는 `Empty array provided for insert` 에러가 발생합니다.
+`undefined` 필드는 insert/update/upsert에서 제외됩니다. multi-row insert에서 누락/undefined는 `DEFAULT`로 처리되며, 단일 insert에서 정의된 필드가 없으면 `DEFAULT VALUES`가 사용됩니다.
 
 ### 데이터 타입 (JSONB/배열/BigInt)
 

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
@@ -814,6 +826,7 @@ await client
 ```
 
 Empty array `insert([])` throws `Empty array provided for insert`.
+`undefined` fields in insert/update/upsert payloads are omitted. For multi-row inserts, missing/undefined values emit `DEFAULT`. Single-row inserts with no defined fields emit `DEFAULT VALUES`.
 
 ### Data Types (JSONB/Arrays/BigInt)
 
@@ -1031,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`.
@@ -100,7 +104,10 @@ Notes:
 - `select()` appends `RETURNING` with the selected columns.
 - Without `select()`, no `RETURNING` is added.
 - `insert([])` throws `Empty array provided for insert`.
-- Multi-row inserts use the first row's keys as column order.
+- `undefined` fields are omitted from insert/update/upsert payloads.
+- Single-row inserts with no defined fields emit `DEFAULT VALUES`.
+- Multi-row inserts use the union of defined keys (first-seen order).
+- Missing/undefined values in multi-row inserts emit `DEFAULT`.
 - `upsert`:
   - `onConflict` can be a string or array.
   - String targets are quoted unless already quoted or parenthesized.

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;
@@ -79,6 +83,8 @@ export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName
     private quoteConflictTargetColumn;
     private shouldReturnData;
     private stringifyJsonValue;
+    private filterUndefinedEntries;
+    private normalizeColumnValue;
     private buildWhereClause;
     private buildQuery;
     private parseExplainPlanRows;

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 ')})`);
         }
@@ -582,6 +726,40 @@ class QueryBuilder {
             return val;
         });
     }
+    filterUndefinedEntries(data) {
+        const filtered = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value !== undefined) {
+                filtered[key] = value;
+            }
+        }
+        return filtered;
+    }
+    async normalizeColumnValue(column, value, pgTypeCache) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        let pgType;
+        if (pgTypeCache) {
+            if (pgTypeCache.has(column)) {
+                const cached = pgTypeCache.get(column);
+                pgType = cached || undefined;
+            }
+            else {
+                const fetched = await this.client.getColumnPgType(String(this.schema), String(this.table), column);
+                pgTypeCache.set(column, fetched ?? '');
+                pgType = fetched;
+            }
+        }
+        else {
+            pgType = await this.client.getColumnPgType(String(this.schema), String(this.table), column);
+        }
+        if ((pgType === 'json' || pgType === 'jsonb') &&
+            (Array.isArray(value) || (value !== null && typeof value === 'object' && !(value instanceof Date)))) {
+            return this.stringifyJsonValue(value);
+        }
+        return value;
+    }
     buildWhereClause(updateValues, conditionsOverride) {
         const baseConditions = conditionsOverride ? [...conditionsOverride] : [...this.whereConditions];
         if (baseConditions.length === 0 && this.orConditions.length === 0) {
@@ -645,48 +823,50 @@ class QueryBuilder {
                     const rows = this.insertData;
                     if (rows.length === 0)
                         throw new Error('Empty array provided for insert');
-                    insertColumns = Object.keys(rows[0]);
-                    const processedRowsValuesPromises = rows.map(async (row) => {
-                        const rowValues = [];
+                    const sanitizedRows = rows.map((row) => this.filterUndefinedEntries(row));
+                    insertColumns = [];
+                    for (const row of sanitizedRows) {
+                        for (const colName of Object.keys(row)) {
+                            if (!insertColumns.includes(colName)) {
+                                insertColumns.push(colName);
+                            }
+                        }
+                    }
+                    if (insertColumns.length === 0) {
+                        throw new Error('No data provided for insert/upsert');
+                    }
+                    const pgTypeCache = new Map();
+                    const rowPlaceholders = [];
+                    for (const row of sanitizedRows) {
+                        const placeholders = [];
                         for (const colName of insertColumns) { // Ensure order of values matches order of columns
                             const val = row[colName];
-                            const pgType = await this.client.getColumnPgType(String(this.schema), String(this.table), colName);
-                            if (typeof val === 'bigint') {
-                                rowValues.push(val.toString());
-                            }
-                            else if ((pgType === 'json' || pgType === 'jsonb') &&
-                                (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date)))) {
-                                rowValues.push(this.stringifyJsonValue(val));
-                            }
-                            else {
-                                rowValues.push(val);
+                            if (val === undefined) {
+                                placeholders.push('DEFAULT');
+                                continue;
                             }
+                            const normalizedValue = await this.normalizeColumnValue(colName, val, pgTypeCache);
+                            values.push(normalizedValue);
+                            placeholders.push(`$${values.length}`);
                         }
-                        return rowValues;
-                    });
-                    const processedRowsValuesArrays = await Promise.all(processedRowsValuesPromises);
-                    values = processedRowsValuesArrays.flat();
-                    const placeholders = rows.map((_, i) => `(${insertColumns.map((_, j) => `$${i * insertColumns.length + j + 1}`).join(',')})`).join(',');
-                    query = `INSERT INTO ${schemaTable} ("${insertColumns.join('","')}") VALUES ${placeholders}`;
+                        rowPlaceholders.push(`(${placeholders.join(',')})`);
+                    }
+                    query = `INSERT INTO ${schemaTable} ("${insertColumns.join('","')}") VALUES ${rowPlaceholders.join(',')}`;
                 }
                 else {
-                    const insertData = this.insertData;
+                    const insertData = this.filterUndefinedEntries(this.insertData);
                     insertColumns = Object.keys(insertData);
-                    const valuePromises = insertColumns.map(async (colName) => {
-                        const val = insertData[colName];
-                        const pgType = await this.client.getColumnPgType(String(this.schema), String(this.table), colName);
-                        if (typeof val === 'bigint') {
-                            return val.toString();
-                        }
-                        if ((pgType === 'json' || pgType === 'jsonb') &&
-                            (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date)))) {
-                            return this.stringifyJsonValue(val);
-                        }
-                        return val;
-                    });
-                    values = await Promise.all(valuePromises);
-                    const insertPlaceholders = values.map((_, i) => `$${i + 1}`).join(',');
-                    query = `INSERT INTO ${schemaTable} ("${insertColumns.join('","')}") VALUES (${insertPlaceholders})`;
+                    if (insertColumns.length === 0) {
+                        query = `INSERT INTO ${schemaTable} DEFAULT VALUES`;
+                    }
+                    else {
+                        const pgTypeCache = new Map();
+                        const valuePromises = insertColumns.map((colName) => // Iterate by column name to get pgType
+                         this.normalizeColumnValue(colName, insertData[colName], pgTypeCache));
+                        values = await Promise.all(valuePromises);
+                        const insertPlaceholders = values.map((_, i) => `$${i + 1}`).join(',');
+                        query = `INSERT INTO ${schemaTable} ("${insertColumns.join('","')}") VALUES (${insertPlaceholders})`;
+                    }
                 }
                 if ((this.queryType === 'UPSERT' || this.queryType === 'INSERT') && (this.conflictTarget || this.ignoreDuplicates)) {
                     const conflictTargetSQL = this.conflictTarget
@@ -697,6 +877,9 @@ class QueryBuilder {
                     if (!isUpsert && this.conflictTarget && !this.ignoreDuplicates) {
                         throw new Error('insert() only supports onConflict with ignoreDuplicates: true; use upsert() for updates.');
                     }
+                    if (isUpsert && !this.ignoreDuplicates && insertColumns.length === 0) {
+                        throw new Error('upsert() requires at least one defined column to update.');
+                    }
                     query += ' ON CONFLICT';
                     if (hasTarget) {
                         query += ` (${conflictTargetSQL})`;
@@ -717,7 +900,10 @@ class QueryBuilder {
             case 'UPDATE': {
                 if (!this.updateData)
                     throw new Error('No data provided for update');
-                const updateData = { ...this.updateData };
+                const updateData = this.filterUndefinedEntries({ ...this.updateData });
+                if (Object.keys(updateData).length === 0) {
+                    throw new Error('No data provided for update');
+                }
                 const now = new Date().toISOString();
                 if ('modified_at' in updateData && !updateData.modified_at) {
                     updateData.modified_at = now;
@@ -726,17 +912,10 @@ class QueryBuilder {
                     updateData.updated_at = now;
                 }
                 const updateColumns = Object.keys(updateData);
+                const pgTypeCache = new Map();
                 const processedUpdateValuesPromises = updateColumns.map(async (colName) => {
                     const val = updateData[colName];
-                    const pgType = await this.client.getColumnPgType(String(this.schema), String(this.table), colName);
-                    if (typeof val === 'bigint') {
-                        return val.toString();
-                    }
-                    if ((pgType === 'json' || pgType === 'jsonb') &&
-                        (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date)))) {
-                        return this.stringifyJsonValue(val);
-                    }
-                    return val;
+                    return this.normalizeColumnValue(colName, val, pgTypeCache);
                 });
                 const processedUpdateValues = await Promise.all(processedUpdateValuesPromises);
                 const setColumns = updateColumns.map((key, index) => `"${String(key)}" = $${index + 1}`);

package/package.json

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