supalite 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.5.5] - 2025-11-26
+
+### ✨ Added
+-   `rpc()` 메서드 호출 시 `.single()` 및 `.maybeSingle()` 메서드 체이닝 지원을 추가했습니다. 이를 통해 RPC 결과에 대해 단일 행 제약 조건을 적용할 수 있습니다. (See [docs/changelog/2025-11-26-rpc-single-support.md](docs/changelog/2025-11-26-rpc-single-support.md))
+
 ## [0.5.2] - 2025-10-16
 
 ### 🐞 Fixed

package/README.md

@@ -289,7 +289,7 @@ const { data, error } = await client
 - `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')
+- `or(conditions)`: OR 조건 (예: 'status.eq.active,role.eq.admin', 'valid_until.is.null')
 
 ### 기타 메소드
 

package/dist/postgres-client.d.ts

@@ -1,3 +1,4 @@
+import { Pool } from 'pg';
 import { QueryBuilder } from './query-builder';
 import { PostgresError } from './errors';
 import { TableOrViewName, SupaliteConfig, Row, QueryResult, SingleQueryResult } from './types';
@@ -19,6 +20,27 @@ type SchemaWithTables = {
     Enums?: any;
     CompositeTypes?: any;
 };
+export declare class RpcBuilder implements Promise<any> {
+    private pool;
+    private schema;
+    private procedureName;
+    private params;
+    readonly [Symbol.toStringTag] = "RpcBuilder";
+    private singleMode;
+    constructor(pool: Pool, schema: string, procedureName: string, params?: Record<string, any>);
+    single(): this;
+    maybeSingle(): this;
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<any | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<any>;
+    execute(): Promise<{
+        data: any;
+        error: PostgresError | null;
+        count?: number | null;
+        status?: number;
+        statusText?: string;
+    }>;
+}
 export declare class SupaLitePG<T extends {
     [K: string]: SchemaWithTables;
 }> {
@@ -46,13 +68,7 @@ export declare class SupaLitePG<T extends {
         column: string;
         foreignColumn: string;
     } | null>;
-    rpc(procedureName: string, params?: Record<string, any>): Promise<{
-        data: any;
-        error: PostgresError | null;
-        count?: number | null;
-        status?: number;
-        statusText?: string;
-    }>;
+    rpc(procedureName: string, params?: Record<string, any>): RpcBuilder;
     testConnection(): Promise<boolean>;
     close(): Promise<void>;
 }

package/dist/postgres-client.js

@@ -1,12 +1,139 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.supalitePg = exports.SupaLitePG = void 0;
+exports.supalitePg = exports.SupaLitePG = exports.RpcBuilder = void 0;
 const pg_1 = require("pg"); // PoolConfig 추가
 const query_builder_1 = require("./query-builder");
 const errors_1 = require("./errors");
 const dotenv_1 = require("dotenv");
 // .env 파일 로드
 (0, dotenv_1.config)();
+class RpcBuilder {
+    constructor(pool, schema, procedureName, params = {}) {
+        this.pool = pool;
+        this.schema = schema;
+        this.procedureName = procedureName;
+        this.params = params;
+        this[_a] = 'RpcBuilder';
+        this.singleMode = null;
+    }
+    single() {
+        this.singleMode = 'strict';
+        return this;
+    }
+    maybeSingle() {
+        this.singleMode = 'maybe';
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.execute().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.execute().finally(onfinally);
+    }
+    async execute() {
+        try {
+            const paramNames = Object.keys(this.params);
+            const paramValues = Object.values(this.params);
+            const paramPlaceholders = paramNames.length > 0
+                ? paramNames.map((name, i) => `"${name}" := $${i + 1}`).join(', ')
+                : '';
+            const query = paramPlaceholders
+                ? `SELECT * FROM "${this.schema}"."${this.procedureName}"(${paramPlaceholders})`
+                : `SELECT * FROM "${this.schema}"."${this.procedureName}"()`;
+            const result = await this.pool.query(query, paramValues);
+            // Handle scalar return values (Supabase special handling)
+            // If result has 1 row and 1 column, and we are not in strict table mode (which rpc generally isn't),
+            // we check if it looks like a scalar return.
+            // However, if single() is called, we must respect row constraints.
+            let data = result.rows;
+            // Unwrapping logic for scalar functions (legacy Supabase behavior emulation)
+            // If it returns a single row with a single column, treat as scalar IF not forcing array via logic.
+            // But here we'll stick to basic row handling first, then apply singleMode.
+            // NOTE: Original logic had:
+            // if (result.rows.length === 1 && Object.keys(result.rows[0]).length === 1) { ... return single value ... }
+            // This implies unwrapping happens by default if it looks like a scalar.
+            const isScalarCandidate = result.rows.length === 1 && Object.keys(result.rows[0]).length === 1;
+            if (this.singleMode) {
+                if (result.rows.length > 1) {
+                    return {
+                        data: null,
+                        error: new errors_1.PostgresError('PGRST114: Multiple rows returned'),
+                        count: null,
+                        status: 406,
+                        statusText: 'Not Acceptable. Expected a single row but found multiple.'
+                    };
+                }
+                if (result.rows.length === 0) {
+                    if (this.singleMode === 'strict') {
+                        return {
+                            data: null,
+                            error: new errors_1.PostgresError('PGRST116: No rows found'),
+                            count: null,
+                            status: 404,
+                            statusText: 'Not Found. Expected a single row but found no rows.'
+                        };
+                    }
+                    // maybeSingle -> null data, no error
+                    return {
+                        data: null,
+                        error: null,
+                        count: 0,
+                        status: 200,
+                        statusText: 'OK'
+                    };
+                }
+                // 1 row found
+                // Check for scalar unwrapping
+                if (Object.keys(result.rows[0]).length === 1) {
+                    data = Object.values(result.rows[0])[0];
+                }
+                else {
+                    data = result.rows[0];
+                }
+                return {
+                    data,
+                    error: null,
+                    count: 1,
+                    status: 200,
+                    statusText: 'OK'
+                };
+            }
+            // Default behavior (no .single() called)
+            if (isScalarCandidate) {
+                data = Object.values(result.rows[0])[0];
+                return {
+                    data,
+                    error: null,
+                    count: 1,
+                    status: 200,
+                    statusText: 'OK'
+                };
+            }
+            return {
+                data: result.rows.length > 0 ? result.rows : null,
+                error: null,
+                count: result.rowCount,
+                status: 200,
+                statusText: 'OK'
+            };
+        }
+        catch (err) {
+            return {
+                data: null,
+                error: new errors_1.PostgresError(err.message, err.code),
+                count: null,
+                status: 500,
+                statusText: 'Internal Server Error'
+            };
+        }
+    }
+}
+exports.RpcBuilder = RpcBuilder;
+_a = Symbol.toStringTag;
 class SupaLitePG {
     constructor(config) {
         this.client = null;
@@ -220,44 +347,8 @@ class SupaLitePG {
         this.foreignKeyCache.set(cacheKey, null);
         return null;
     }
-    async rpc(procedureName, params = {}) {
-        try {
-            const paramNames = Object.keys(params);
-            const paramValues = Object.values(params);
-            const paramPlaceholders = paramNames.length > 0
-                ? paramNames.map((name, i) => `"${name}" := $${i + 1}`).join(', ')
-                : '';
-            const query = paramPlaceholders
-                ? `SELECT * FROM "${this.schema}"."${procedureName}"(${paramPlaceholders})`
-                : `SELECT * FROM "${this.schema}"."${procedureName}"()`;
-            const result = await this.pool.query(query, paramValues);
-            if (result.rows.length === 1 && Object.keys(result.rows[0]).length === 1) {
-                const singleValue = Object.values(result.rows[0])[0];
-                return {
-                    data: singleValue,
-                    error: null,
-                    count: 1,
-                    status: 200,
-                    statusText: 'OK'
-                };
-            }
-            return {
-                data: result.rows.length > 0 ? result.rows : null,
-                error: null,
-                count: result.rowCount,
-                status: 200,
-                statusText: 'OK'
-            };
-        }
-        catch (err) {
-            return {
-                data: null,
-                error: new errors_1.PostgresError(err.message, err.code),
-                count: null,
-                status: 500,
-                statusText: 'Internal Server Error'
-            };
-        }
+    rpc(procedureName, params = {}) {
+        return new RpcBuilder(this.pool, this.schema, procedureName, params);
     }
     // 연결 테스트 메서드
     async testConnection() {

package/dist/query-builder.js

@@ -171,7 +171,7 @@ class QueryBuilder {
     or(conditions) {
         const orParts = conditions.split(',').map(condition => {
             const [field, op, value] = condition.split('.');
-            const validOperators = ['eq', 'neq', 'ilike', 'like', 'gt', 'gte', 'lt', 'lte'];
+            const validOperators = ['eq', 'neq', 'ilike', 'like', 'gt', 'gte', 'lt', 'lte', 'is'];
             if (!validOperators.includes(op)) {
                 throw new Error(`Invalid operator: ${op}`);
             }
@@ -204,6 +204,13 @@ class QueryBuilder {
                     return `"${field}" < $${paramIndex}`;
                 case 'lte':
                     return `"${field}" <= $${paramIndex}`;
+                case 'is':
+                    if (processedValue === null) {
+                        // Remove the null value from whereValues since we don't need a parameter for IS NULL
+                        this.whereValues.pop();
+                        return `"${field}" IS NULL`;
+                    }
+                    return `"${field}" IS $${paramIndex}`;
                 default:
                     return '';
             }

package/docs/changelog/2025-11-21-support-is-in-or-method.md

@@ -0,0 +1,33 @@
+# 변경 보고서: `or` 메소드 내 `is` 연산자 지원
+
+**날짜:** 2025년 11월 21일
+
+## 변경 유형
+
+- [x] 기능 추가
+- [ ] 버그 수정
+- [ ] 성능 개선
+- [ ] 문서 업데이트
+- [ ] 기타
+
+## 변경 내용
+
+### `QueryBuilder`
+
+- **`or` 메소드 개선**: `or` 메소드 내부에서 `is` 연산자를 사용할 수 있도록 지원을 추가했습니다. 이제 `valid_until.is.null`과 같은 표현을 통해 `IS NULL` 조건을 `OR` 절 안에서 사용할 수 있습니다.
+
+  **사용 예시:**
+
+  ```typescript
+  const { data } = await client
+    .from('credits')
+    .select('*')
+    .or('valid_until.is.null,valid_until.gt.now()');
+  ```
+
+  위 코드는 `SELECT * FROM "public"."credits" WHERE ("valid_until" IS NULL OR "valid_until" > 'now()')` SQL 쿼리를 생성합니다.
+
+## 관련 파일
+
+- `src/query-builder.ts`
+- `README.md`

package/docs/changelog/2025-11-26-rpc-single-support.md

@@ -0,0 +1,29 @@
+# RPC .single() and .maybeSingle() Support
+
+- **Date**: 2025-11-26
+- **Author**: Cline
+- **Status**: Completed
+
+## Summary
+
+Implemented `.single()` and `.maybeSingle()` method chaining support for `rpc` calls in `SupaLitePG`. This brings the `rpc` method closer to the Supabase JS client API, allowing users to enforce single-row constraints on RPC results.
+
+## Changes
+
+1.  **Refactored `rpc` Method**:
+    - The `rpc` method in `src/postgres-client.ts` now returns an instance of `RpcBuilder` instead of a `Promise` directly.
+    - `RpcBuilder` implements the `Promise` interface, ensuring backward compatibility for `await rpc(...)` usage.
+
+2.  **Introduced `RpcBuilder` Class**:
+    - Encapsulates RPC parameters and execution logic.
+    - Adds `single()` method: Expects exactly one row. Throws `PGRST116` if 0 rows, `PGRST114` if >1 rows.
+    - Adds `maybeSingle()` method: Expects at most one row. Returns `null` if 0 rows, throws `PGRST114` if >1 rows.
+    - Preserves existing scalar unwrapping logic for single-row, single-column results.
+
+3.  **Unit Tests**:
+    - Added `src/__tests__/rpc.test.ts` covering various scenarios for standard calls, `.single()`, and `.maybeSingle()`.
+
+## Impact
+
+- Users can now use `.single()` on `rpc` calls, resolving the `TypeError: ...single is not a function` error.
+- Existing code using `await rpc(...)` continues to work without changes.

package/package.json

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