supalite 0.3.2 → 0.3.3

package/README.md

@@ -1,6 +1,6 @@
 # SupaLite
 
-[![npm version](https://img.shields.io/badge/version-0.3.2-blue.svg)](https://www.npmjs.com/package/supalite)
+[![npm version](https://img.shields.io/badge/version-0.3.3-blue.svg)](https://www.npmjs.com/package/supalite)
 
 가볍고 효율적인 PostgreSQL 클라이언트 라이브러리입니다. Supabase와 동일한 API를 제공하면서도 더 가볍고 빠른 구현을 제공합니다.
 
@@ -231,14 +231,28 @@ const { data, error } = await client
   ]);
 
 // JSONB 배열 데이터 처리
+// 중요: JSON/JSONB 컬럼에 배열을 삽입/업데이트할 경우, 사용자가 직접 JSON.stringify()를 사용해야 합니다.
+// SupaLite는 일반 객체에 대해서만 자동 stringify를 수행합니다.
+const myJsonArray = ['tag1', 2025, { active: true }];
 const { data: jsonData, error: jsonError } = await client
   .from('your_jsonb_table') // 'your_jsonb_table'을 실제 테이블명으로 변경
   .insert({ 
-    metadata_array: ['tag1', 2025, { active: true }] 
+    metadata_array: JSON.stringify(myJsonArray) // 배열은 직접 stringify
   })
   .select('metadata_array')
   .single();
 
+// 네이티브 배열(TEXT[], INTEGER[] 등) 데이터 처리
+// 이 경우, JavaScript 배열을 직접 전달하면 pg 드라이버가 올바르게 처리합니다.
+const { data: nativeArrayData, error: nativeArrayError } = await client
+  .from('your_native_array_table') // 실제 테이블명으로 변경
+  .insert({
+    tags_column: ['tech', 'event'], // TEXT[] 컬럼 예시
+    scores_column: [100, 95, 88]    // INTEGER[] 컬럼 예시
+  })
+  .select('tags_column, scores_column')
+  .single();
+
 // 다른 스키마 사용
 const { data, error } = await client
   .from('users', 'other_schema')

package/dist/postgres-client.d.ts

@@ -26,6 +26,8 @@ export declare class SupaLitePG<T extends {
     private client;
     private isTransaction;
     private schema;
+    private schemaCache;
+    verbose: boolean;
     constructor(config?: SupaliteConfig);
     begin(): Promise<void>;
     commit(): Promise<void>;
@@ -37,6 +39,7 @@ export declare class SupaLitePG<T extends {
     from<S extends keyof T, K extends TableOrViewName<T, S>>(table: K, schema: S): QueryBuilder<T, S, K> & Promise<QueryResult<Row<T, S, K>>> & {
         single(): Promise<SingleQueryResult<Row<T, S, K>>>;
     };
+    getColumnPgType(dbSchema: string, tableName: string, columnName: string): Promise<string | undefined>;
     rpc(procedureName: string, params?: Record<string, any>): Promise<{
         data: any;
         error: PostgresError | null;

package/dist/postgres-client.js

@@ -15,6 +15,9 @@ class SupaLitePG {
     constructor(config) {
         this.client = null;
         this.isTransaction = false;
+        this.schemaCache = new Map(); // schemaName.tableName -> Map<columnName, pgDataType>
+        this.verbose = false;
+        this.verbose = config?.verbose || process.env.SUPALITE_VERBOSE === 'true' || false;
         // connectionString이 제공되면 이를 우선 사용
         if (config?.connectionString || process.env.DB_CONNECTION) {
             try {
@@ -105,7 +108,58 @@ class SupaLitePG {
         }
     }
     from(table, schema) {
-        return new query_builder_1.QueryBuilder(this.pool, table, schema || 'public');
+        // QueryBuilder constructor will be updated to accept these arguments
+        return new query_builder_1.QueryBuilder(// Use 'as any' temporarily if QueryBuilder constructor not yet updated
+        this.pool, this, // Pass the SupaLitePG instance itself
+        table, schema || 'public', this.verbose // Pass verbose setting
+        );
+    }
+    async getColumnPgType(dbSchema, tableName, columnName) {
+        const tableKey = `${dbSchema}.${tableName}`;
+        if (this.verbose)
+            console.log(`[SupaLite VERBOSE] getColumnPgType called for ${tableKey}.${columnName}`);
+        let tableInfo = this.schemaCache.get(tableKey);
+        if (!tableInfo) {
+            if (this.verbose)
+                console.log(`[SupaLite VERBOSE] Cache miss for table ${tableKey}. Querying information_schema.`);
+            try {
+                const query = `
+          SELECT column_name, data_type 
+          FROM information_schema.columns 
+          WHERE table_schema = $1 AND table_name = $2;
+        `;
+                // Use a temporary client from the pool for this schema query
+                // if not in a transaction, or use the transaction client if in one.
+                const activeClient = this.isTransaction && this.client ? this.client : await this.pool.connect();
+                try {
+                    const result = await activeClient.query(query, [dbSchema, tableName]);
+                    tableInfo = new Map();
+                    result.rows.forEach((row) => {
+                        tableInfo.set(row.column_name, row.data_type.toLowerCase());
+                    });
+                    this.schemaCache.set(tableKey, tableInfo);
+                    if (this.verbose)
+                        console.log(`[SupaLite VERBOSE] Cached schema for ${tableKey}:`, tableInfo);
+                }
+                finally {
+                    if (!(this.isTransaction && this.client)) { // Only release if it's a temp client not managed by transaction
+                        activeClient.release(); // Cast to any if 'release' is not on type PoolClient from transaction
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[SupaLite ERROR] Failed to query information_schema for ${tableKey}:`, err.message);
+                return undefined;
+            }
+        }
+        else {
+            if (this.verbose)
+                console.log(`[SupaLite VERBOSE] Cache hit for table ${tableKey}.`);
+        }
+        const pgType = tableInfo?.get(columnName);
+        if (this.verbose)
+            console.log(`[SupaLite VERBOSE] pgType for ${tableKey}.${columnName}: ${pgType}`);
+        return pgType;
     }
     async rpc(procedureName, params = {}) {
         try {

package/dist/query-builder.d.ts

@@ -1,4 +1,5 @@
 import { Pool } from 'pg';
+import type { SupaLitePG } from './postgres-client';
 import { TableName, TableOrViewName, QueryResult, SingleQueryResult, DatabaseSchema, SchemaName, Row, InsertRow, UpdateRow } from './types';
 export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName<T> = 'public', K extends TableOrViewName<T, S> = TableOrViewName<T, S>> implements Promise<QueryResult<Row<T, S, K>> | SingleQueryResult<Row<T, S, K>>> {
     private pool;
@@ -19,7 +20,10 @@ export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName
     private insertData?;
     private updateData?;
     private conflictTarget?;
-    constructor(pool: Pool, table: K, schema?: S);
+    private client;
+    private verbose;
+    constructor(pool: Pool, client: SupaLitePG<T>, // Accept SupaLitePG instance
+    table: K, schema?: S, verbose?: boolean);
     then<TResult1 = QueryResult<Row<T, S, K>> | SingleQueryResult<Row<T, S, K>>, TResult2 = never>(onfulfilled?: ((value: QueryResult<Row<T, S, K>> | SingleQueryResult<Row<T, S, K>>) => 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<QueryResult<Row<T, S, K>> | SingleQueryResult<Row<T, S, K>> | TResult>;
     finally(onfinally?: (() => void) | null): Promise<QueryResult<Row<T, S, K>> | SingleQueryResult<Row<T, S, K>>>;

package/dist/query-builder.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const errors_1 = require("./errors");
 class QueryBuilder {
-    constructor(pool, table, schema = 'public') {
+    constructor(pool, client, // Accept SupaLitePG instance
+    table, schema = 'public', verbose = false // Accept verbose setting
+    ) {
         this.pool = pool;
         this[_a] = 'QueryBuilder';
         this.selectColumns = null;
@@ -14,8 +16,11 @@ class QueryBuilder {
         this.whereValues = [];
         this.singleMode = null;
         this.queryType = 'SELECT';
+        this.verbose = false;
+        this.client = client;
         this.table = table;
         this.schema = schema;
+        this.verbose = verbose;
     }
     then(onfulfilled, onrejected) {
         return this.execute().then(onfulfilled, onrejected);
@@ -195,7 +200,7 @@ class QueryBuilder {
         }
         return ' WHERE ' + conditions.join(' AND ');
     }
-    buildQuery() {
+    async buildQuery() {
         let query = '';
         let values = [];
         let insertColumns = [];
@@ -223,32 +228,45 @@ class QueryBuilder {
                     if (rows.length === 0)
                         throw new Error('Empty array provided for insert');
                     insertColumns = Object.keys(rows[0]);
-                    // Process each row for potential JSON stringification
-                    const processedRowsValues = rows.map(row => Object.values(row).map(val => {
-                        if (typeof val === 'bigint') {
-                            return val.toString();
-                        }
-                        if (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date))) {
-                            return JSON.stringify(val);
+                    const processedRowsValuesPromises = rows.map(async (row) => {
+                        const rowValues = [];
+                        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(JSON.stringify(val));
+                            }
+                            else {
+                                rowValues.push(val);
+                            }
                         }
-                        return val;
-                    }));
-                    values = processedRowsValues.flat();
+                        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}`;
                 }
                 else {
                     const insertData = this.insertData;
                     insertColumns = Object.keys(insertData);
-                    values = Object.values(insertData).map(val => {
+                    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 (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date))) {
+                        if ((pgType === 'json' || pgType === 'jsonb') &&
+                            (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date)))) {
                             return JSON.stringify(val);
                         }
                         return val;
                     });
+                    values = await Promise.all(valuePromises);
                     const insertPlaceholders = values.map((_, i) => `$${i + 1}`).join(',');
                     query = `INSERT INTO ${schemaTable} ("${insertColumns.join('","')}") VALUES (${insertPlaceholders})`;
                 }
@@ -276,16 +294,21 @@ class QueryBuilder {
                 if ('updated_at' in updateData && !updateData.updated_at) {
                     updateData.updated_at = now;
                 }
-                const processedUpdateValues = Object.values(updateData).map(val => {
+                const updateColumns = Object.keys(updateData);
+                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 (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date))) {
+                    if ((pgType === 'json' || pgType === 'jsonb') &&
+                        (Array.isArray(val) || (val !== null && typeof val === 'object' && !(val instanceof Date)))) {
                         return JSON.stringify(val);
                     }
                     return val;
                 });
-                const setColumns = Object.keys(updateData).map((key, index) => `"${String(key)}" = $${index + 1}`);
+                const processedUpdateValues = await Promise.all(processedUpdateValuesPromises);
+                const setColumns = updateColumns.map((key, index) => `"${String(key)}" = $${index + 1}`);
                 query = `UPDATE ${schemaTable} SET ${setColumns.join(', ')}`;
                 values = [...processedUpdateValues, ...this.whereValues];
                 query += this.buildWhereClause(processedUpdateValues);
@@ -316,7 +339,11 @@ class QueryBuilder {
     }
     async execute() {
         try {
-            const { query, values } = this.buildQuery();
+            const { query, values } = await this.buildQuery(); // await buildQuery
+            if (this.verbose) {
+                console.log('[SupaLite VERBOSE] SQL:', query);
+                console.log('[SupaLite VERBOSE] Values:', values);
+            }
             const result = await this.pool.query(query, values);
             if (this.queryType === 'DELETE' && !this.shouldReturnData()) {
                 return {
@@ -392,6 +419,9 @@ class QueryBuilder {
             };
         }
         catch (err) {
+            if (this.verbose) {
+                console.error('[SupaLite VERBOSE] Error:', err);
+            }
             return {
                 data: [],
                 error: new errors_1.PostgresError(err.message),

package/dist/types.d.ts

@@ -53,6 +53,7 @@ export interface SupaliteConfig {
     port?: number;
     ssl?: boolean;
     schema?: string;
+    verbose?: boolean;
 }
 export type QueryType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'UPSERT';
 export interface QueryOptions {

package/docs/changelog/2025-06-10-jsonb-array-test.md

@@ -4,9 +4,22 @@
     - Updated `JsonbTestTable` related types to use the global `Json` type.
     - Added `another_json_field` (JSONB) to `jsonb_test_table` schema and tests.
     - Modified `beforeAll` to `DROP TABLE IF EXISTS jsonb_test_table` before `CREATE TABLE` to ensure schema updates are applied, fixing a "column does not exist" error during tests.
-    - Removed explicit `JSON.stringify()` from test cases, relying on internal handling.
+    - Removed explicit `JSON.stringify()` from test cases, as this is now handled automatically by `QueryBuilder` based on schema information.
     - Added a new test case for inserting/selecting an object into `another_json_field`.
-- Modified `src/query-builder.ts` (`buildQuery` method):
-    - Implemented automatic `JSON.stringify()` for array or object values (excluding `Date` instances) when preparing data for `INSERT`, `UPSERT`, and `UPDATE` operations. This allows users to pass JavaScript objects/arrays directly for `json`/`jsonb` columns.
-    - Corrected a TypeScript error (`Cannot find name 'updateValues'`) in the `UPDATE` case of `buildQuery`.
-- Ensured `src/types.ts` contains the `Json` type definition.
+    - Added a test case for inserting an empty JavaScript array `[]` into a `jsonb` field, now handled automatically.
+- Modified `src/postgres-client.ts`:
+    - Added `schemaCache` to store column type information fetched from `information_schema.columns`.
+    - Implemented `getColumnPgType(schema, table, column)` method to retrieve (and cache) PostgreSQL data types for columns.
+    - Added `verbose` option to `SupaliteConfig` and `SupaLitePG` for logging.
+    - Modified `from()` method to pass `SupaLitePG` instance and `verbose` setting to `QueryBuilder`.
+- Modified `src/query-builder.ts`:
+    - Updated constructor to accept `SupaLitePG` client instance and `verbose` setting.
+    - Made `buildQuery()` method `async`.
+    - Implemented schema-aware value processing in `buildQuery()` for `INSERT`, `UPSERT`, and `UPDATE`:
+        - Uses `client.getColumnPgType()` to get the PostgreSQL type of each column.
+        - If `pgType` is 'json' or 'jsonb', JavaScript objects and arrays are `JSON.stringify()`'d.
+        - If `pgType` is 'bigint', JavaScript `BigInt`s are `toString()`'d.
+        - Otherwise (e.g., for `text[]`, `integer[]`), values (including JavaScript arrays) are passed as-is to the `pg` driver.
+    - Updated `execute()` method to `await buildQuery()` and include verbose logging for SQL and values if enabled.
+- Ensured `src/types.ts` contains the `Json` type and `verbose` option in `SupaliteConfig`.
+- **Outcome**: `QueryBuilder` now intelligently handles serialization for `json`/`jsonb`, `bigint`, and native array types based on runtime schema information, providing a more seamless experience similar to `supabase-js`. All related tests pass.

package/package.json

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