supalite 0.5.1 → 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()`: 레코드 삭제

package/dist/query-builder.js

@@ -245,6 +245,7 @@ class QueryBuilder {
             case 'SELECT': {
                 if (this.headOption) {
                     query = `SELECT COUNT(*) FROM ${schemaTable}`;
+                    query += this.buildWhereClause();
                     values = [...this.whereValues];
                     break;
                 }
@@ -258,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;
                     }
@@ -276,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':
@@ -388,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 };
     }
@@ -437,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,
@@ -466,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,
@@ -476,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/package.json

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