supalite 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.5.2] - 2025-10-16
+
+### 🐞 Fixed
+- `select()` 메서드에서 `count: 'exact'` 옵션 사용 시 `limit()` 또는 `range()`와 함께 호출될 때 전체 개수 대신 페이지네이션된 개수를 반환하는 버그를 수정했습니다. 이제 항상 정확한 전체 개수를 반환합니다.
+- `select()` 메서드에서 `count: 'exact'`와 `head: true` 옵션을 함께 사용할 때 `count`가 `null`로 반환되는 버그를 수정했습니다.
+
+## [0.5.1] - 2025-10-16
+
+### 🐞 Fixed
+- `select()` 메서드에서 `count: 'exact'` 옵션 사용 시 `limit()` 또는 `range()`와 함께 호출될 때 전체 개수 대신 페이지네이션된 개수를 반환하는 버그를 수정했습니다. 이제 항상 정확한 전체 개수를 반환합니다.
+
 ## [0.5.0] - 2025-07-01
 
 ### ✨ Added

package/README.md

@@ -268,6 +268,8 @@ const { data, error } = await client
 ### 쿼리 메소드
 
 - `select(columns?: string, options?: { count?: 'exact' | 'planned' | 'estimated', head?: boolean })`: 조회할 컬럼 지정
+  - `options.count`: `'exact'`로 설정하면 `limit`의 영향을 받지 않는 전체 결과의 개수를 `count` 속성으로 반환합니다.
+  - `options.head`: `true`로 설정하면 데이터 없이 `count`만 가져옵니다. `count` 옵션과 함께 사용하면 효율적으로 전체 개수만 조회할 수 있습니다.
 - `insert(data: T['Tables'][K]['Insert'] | T['Tables'][K]['Insert'][])`: 단일 또는 다중 레코드 삽입
 - `update(data: T['Tables'][K]['Update'])`: 레코드 업데이트
 - `delete()`: 레코드 삭제
@@ -285,6 +287,7 @@ const { data, error } = await client
 - `ilike(column, pattern)`: 대소문자 구분 없는 LIKE
 - `in(column, values)`: IN 연산자
 - `is(column, value)`: IS 연산자
+- `not(column, operator, value)`: Negates an operator (e.g., `not('column', 'is', null)`).
 - `contains(column, value)`: 배열/JSON 포함 여부
 - `or(conditions)`: OR 조건 (예: 'status.eq.active,role.eq.admin')
 

package/dist/query-builder.d.ts

@@ -38,6 +38,7 @@ export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName
     eq(column: string, value: any): this;
     neq(column: string, value: any): this;
     is(column: string, value: any): this;
+    not(column: string, operator: string, value: any): this;
     contains(column: string, value: any): this;
     in(column: string, values: any[]): this;
     gte(column: string, value: any): this;

package/dist/query-builder.js

@@ -97,6 +97,16 @@ class QueryBuilder {
         }
         return this;
     }
+    not(column, operator, value) {
+        if (operator === 'is' && value === null) {
+            this.whereConditions.push(`"${column}" IS NOT NULL`);
+        }
+        else {
+            // 추후 다른 not 연산자들을 위해 남겨둠
+            throw new Error(`Operator "${operator}" is not supported for "not" operation.`);
+        }
+        return this;
+    }
     contains(column, value) {
         this.whereConditions.push(`"${column}" @> $${this.whereValues.length + 1}`);
         this.whereValues.push(value);
@@ -235,6 +245,7 @@ class QueryBuilder {
             case 'SELECT': {
                 if (this.headOption) {
                     query = `SELECT COUNT(*) FROM ${schemaTable}`;
+                    query += this.buildWhereClause();
                     values = [...this.whereValues];
                     break;
                 }
@@ -248,7 +259,6 @@ class QueryBuilder {
                 const joinSubqueries = await Promise.all(this.joinClauses.map(async (join) => {
                     const fk = await this.client.getForeignKey(String(this.schema), String(this.table), join.foreignTable);
                     if (!fk) {
-                        // In a real scenario, you might want to throw an error or handle this case
                         console.warn(`[SupaLite WARNING] No foreign key found from ${join.foreignTable} to ${String(this.table)}`);
                         return null;
                     }
@@ -266,12 +276,15 @@ class QueryBuilder {
                 if (validSubqueries) {
                     selectClause += `, ${validSubqueries}`;
                 }
-                query = `SELECT ${selectClause} FROM ${schemaTable}`;
+                let baseQuery = `SELECT ${selectClause} FROM ${schemaTable}`;
+                baseQuery += this.buildWhereClause();
+                values = [...this.whereValues];
                 if (this.countOption === 'exact') {
-                    // This part might need adjustment if subqueries are complex
-                    query = `SELECT *, COUNT(*) OVER() as exact_count FROM (${query}) subquery`;
+                    query = `SELECT *, COUNT(*) OVER() as exact_count FROM (${baseQuery}) subquery`;
+                }
+                else {
+                    query = baseQuery;
                 }
-                values = [...this.whereValues];
                 break;
             }
             case 'INSERT':
@@ -378,17 +391,19 @@ class QueryBuilder {
                 break;
             }
         }
+        // Append clauses that apply to the outermost query
         if (this.queryType === 'SELECT') {
-            query += this.buildWhereClause();
-        }
-        if (this.orderByColumns.length > 0 && this.queryType === 'SELECT') {
-            query += ` ORDER BY ${this.orderByColumns.join(', ')}`;
-        }
-        if (this.limitValue !== undefined && this.queryType === 'SELECT') {
-            query += ` LIMIT ${this.limitValue}`;
-        }
-        if (this.offsetValue !== undefined && this.queryType === 'SELECT') {
-            query += ` OFFSET ${this.offsetValue}`;
+            // WHERE is already in the query or subquery
+            // ORDER BY, LIMIT, and OFFSET always apply to the outer query
+            if (this.orderByColumns.length > 0) {
+                query += ` ORDER BY ${this.orderByColumns.join(', ')}`;
+            }
+            if (this.limitValue !== undefined) {
+                query += ` LIMIT ${this.limitValue}`;
+            }
+            if (this.offsetValue !== undefined) {
+                query += ` OFFSET ${this.offsetValue}`;
+            }
         }
         return { query, values };
     }
@@ -427,27 +442,49 @@ class QueryBuilder {
                     statusText: 'Created',
                 };
             }
+            let countResult = null;
+            let dataResult = result.rows;
+            if (this.headOption) {
+                countResult = Number(result.rows[0].count);
+                dataResult = [];
+            }
+            else if (this.countOption === 'exact') {
+                if (result.rows.length > 0) {
+                    countResult = Number(result.rows[0].exact_count);
+                    // exact_count 열을 모든 데이터 객체에서 제거
+                    dataResult = result.rows.map(row => {
+                        const newRow = { ...row };
+                        delete newRow.exact_count;
+                        return newRow;
+                    });
+                }
+                else {
+                    countResult = 0;
+                }
+            }
+            else {
+                countResult = result.rowCount;
+            }
             if (this.singleMode) {
-                if (result.rows.length > 1) {
+                if (dataResult.length > 1) {
                     return {
                         data: null,
-                        error: new errors_1.PostgresError('PGRST114: Multiple rows returned'), // PGRST114: More than one row was returned
-                        count: result.rowCount,
-                        status: 406, // Not Acceptable
+                        error: new errors_1.PostgresError('PGRST114: Multiple rows returned'),
+                        count: countResult,
+                        status: 406,
                         statusText: 'Not Acceptable. Expected a single row but found multiple.',
                     };
                 }
-                if (result.rows.length === 0) {
+                if (dataResult.length === 0) {
                     if (this.singleMode === 'strict') {
                         return {
                             data: null,
-                            error: new errors_1.PostgresError('PGRST116: No rows found'), // PGRST116: Not found
+                            error: new errors_1.PostgresError('PGRST116: No rows found'),
                             count: 0,
-                            status: 404, // Not Found (more appropriate than 200 for strict single when not found)
+                            status: 404,
                             statusText: 'Not Found. Expected a single row but found no rows.',
                         };
                     }
-                    // this.singleMode === 'maybe'
                     return {
                         data: null,
                         error: null,
@@ -456,9 +493,8 @@ class QueryBuilder {
                         statusText: 'OK',
                     };
                 }
-                // result.rows.length === 1
                 return {
-                    data: result.rows[0],
+                    data: dataResult[0],
                     error: null,
                     count: 1,
                     status: 200,
@@ -466,9 +502,9 @@ class QueryBuilder {
                 };
             }
             return {
-                data: result.rows.length > 0 ? result.rows : [],
+                data: dataResult,
                 error: null,
-                count: result.rowCount,
+                count: countResult,
                 status: 200,
                 statusText: 'OK',
             };

package/docs/changelog/2025-08-28-add-not-method.md

@@ -0,0 +1,33 @@
+# 변경 보고서: `not` 메소드 추가
+
+**날짜:** 2025년 8월 28일
+
+## 변경 유형
+
+- [x] 기능 추가
+- [ ] 버그 수정
+- [ ] 성능 개선
+- [ ] 문서 업데이트
+- [ ] 기타
+
+## 변경 내용
+
+### `QueryBuilder`
+
+- **`not` 메소드 추가**: `is` 연산자와 함께 사용하여 `IS NOT NULL` 조건을 생성할 수 있는 `not` 메소드를 추가했습니다.
+
+  **사용 예시:**
+
+  ```typescript
+  const { data } = await client
+    .from('users')
+    .select('id, name')
+    .not('email', 'is', null);
+  ```
+
+  위 코드는 `SELECT "id", "name" FROM "public"."users" WHERE "email" IS NOT NULL` SQL 쿼리를 생성합니다.
+
+## 관련 파일
+
+- `src/query-builder.ts`
+- `README.md`

package/package.json

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