supalite 0.7.2 → 0.7.5

package/README.ko.md

@@ -21,6 +21,12 @@ Supabase 쿼리 빌더에 집중한 가벼운 PostgreSQL 클라이언트입니
 - ✅ RPC (`single`/`maybeSingle` 포함)
 - ❌ Auth/Storage/Realtime
 
+## 0.7.2 하이라이트
+
+- `supalite gen types --format supabase`가 Supabase CLI 출력과 바이트까지 완전히 일치합니다. (정렬/포맷 포함)
+- 기본값인 `--format supalite`는 Supabase 포맷을 확장한 상위 호환 출력으로, 제약/인덱스, 관계의 `referencedSchema`, SETOF 반환 RPC 옵션을 제공합니다.
+- 타입 생성 BigInt 옵션을 추가했습니다: `--no-bigint`, `--no-json-bigint`.
+
 클라우드 마이그레이션 안내 (GCP/AWS):
 Supabase에서 완전히 분리하려면 SupaLite는 **DB 쿼리 계층만** 대체합니다. Auth/Storage/Realtime은 별도 대안이 필요합니다.
 - Auth: 관리형 인증(AWS Cognito / Google Identity Platform) 또는 자체 호스팅(GoTrue/Keycloak)
@@ -129,6 +135,7 @@ const data = await db
 - Node/pg 버전별 CI 매트릭스와 통합 테스트
 - 벤치마크 및 성능 가이드
 - Auth/Storage/Realtime 마이그레이션 가이드 (Cognito/GIP, S3/GCS, Realtime 대안)
+- `pg-schema-sync` 기반 `supalite db pull` 스키마 동기화 래퍼
 - `supalite gen types` (SupaLite 중심 타입 생성기, Supabase 포맷 옵션 제공)
 - 기여 가이드/이슈 템플릿
 
@@ -307,6 +314,21 @@ const client = new SupaliteClient<Database>({
 });
 ```
 
+```typescript
+import { Pool } from 'pg';
+import { SupaLitePG } from 'supalite';
+import { Database } from './types/database';
+
+const pool = new Pool({
+  connectionString: process.env.DB_CONNECTION || 'postgresql://user:pass@localhost:5432/db',
+  max: 5,
+});
+
+const client = new SupaLitePG<Database>({
+  pool,
+});
+```
+
 ### 기본 CRUD 작업
 
 ```typescript
@@ -1031,7 +1053,7 @@ await client.close();
 ### 클라이언트 메소드
 
 - `testConnection()`: 데이터베이스 연결 확인
-- `close()`: 커넥션 풀 종료
+- `close()`: 내부 커넥션 풀 종료 (외부 `pool` 사용 시 no-op)
 
 ## 환경 변수 설정
 
@@ -1051,6 +1073,7 @@ DB_SSL=true
 
 `SupaLitePG` 생성자는 다음 옵션을 받을 수 있습니다:
 
+- `pool?: Pool`: 외부 `pg` Pool 인스턴스를 사용합니다. 이 경우 다른 연결 옵션은 무시되고, 풀의 생성/종료는 호출자가 관리합니다.
 - `connectionString?: string`: PostgreSQL 연결 문자열 (예: `postgresql://user:password@host:port/database`). 제공되면 다른 연결 매개변수보다 우선합니다.
 - `user?: string`: 데이터베이스 사용자 이름 (환경 변수: `DB_USER`).
 - `host?: string`: 데이터베이스 호스트 (환경 변수: `DB_HOST`).

package/README.md

@@ -22,6 +22,12 @@ Compatibility at a glance:
 - ✅ RPC (including `single`/`maybeSingle`)
 - ❌ Auth/Storage/Realtime
 
+## 0.7.2 Highlights
+
+- `supalite gen types --format supabase` now matches Supabase CLI output byte-for-byte (ordering + formatting).
+- Default `--format supalite` is a superset with extra schema metadata (constraints/indexes, referenced schema in relationships, set-returning RPC options).
+- New BigInt controls for generated types: `--no-bigint` and `--no-json-bigint`.
+
 Cloud migration note (GCP/AWS):
 If you are moving off Supabase, SupaLite replaces only the **DB query layer**. You still need alternatives for Auth/Storage/Realtime. Typical choices are:
 - Auth: managed identity (AWS Cognito / Google Identity Platform) or self-hosted (GoTrue/Keycloak)
@@ -130,6 +136,7 @@ const data = await db
 - CI matrix for Node/pg versions with integration tests
 - Benchmarks and performance guidance
 - Auth/Storage/Realtime migration guidance (Cognito/GIP, S3/GCS, Realtime options)
+- `supalite db pull` wrapper around `pg-schema-sync` for schema sync
 - `supalite gen types` (SupaLite-first generator with Supabase-compatible output)
 - Contribution guide and issue templates
 
@@ -307,6 +314,21 @@ const client = new SupaliteClient<Database>({
 });
 ```
 
+```typescript
+import { Pool } from 'pg';
+import { SupaLitePG } from 'supalite';
+import { Database } from './types/database';
+
+const pool = new Pool({
+  connectionString: process.env.DB_CONNECTION || 'postgresql://user:pass@localhost:5432/db',
+  max: 5,
+});
+
+const client = new SupaLitePG<Database>({
+  pool,
+});
+```
+
 ### Basic CRUD
 
 ```typescript
@@ -1047,6 +1069,7 @@ DB_SSL=true
 
 ### SupaLitePG constructor options
 
+- `pool?: Pool`: use an external `pg` Pool instance (other connection options are ignored; pool lifecycle is managed by the caller)
 - `connectionString?: string`: connection string (e.g. `postgresql://user:password@host:port/database`)
 - `user?: string`: DB user (env: `DB_USER`)
 - `host?: string`: DB host (env: `DB_HOST`)

package/SPEC.md

@@ -13,6 +13,7 @@ SupaLite is a lightweight TypeScript PostgreSQL client that mirrors a subset of
 
 #### Construction
 - Accepts either `connectionString` or discrete connection params.
+- Optional `pool` lets callers inject an existing `pg` Pool (SupaLite does not create or close the pool).
 - Env vars supported: `DB_CONNECTION`, `DB_USER`, `DB_HOST`, `DB_NAME`, `DB_PASS`, `DB_PORT`, `DB_SSL`.
 - `bigintTransform`: `'bigint' | 'string' | 'number'` controls how BIGINT values are parsed.
 - `verbose`: logs SQL, values, and warnings for risky bigint-to-number conversions.
@@ -40,7 +41,7 @@ Notes:
 
 ### 2.4 Utilities
 - `testConnection()` to validate connectivity.
-- `close()` to shut down the pool.
+- `close()` to shut down the internal pool (no-op when using an external `pool`).
 
 ## 3. Result Shapes
 

package/dist/gen-types.js

@@ -590,7 +590,7 @@ const renderIndexesProperty = (indexes, level, style) => {
     const items = indexes.map((index) => [
         `name: ${style.quote}${escapeStringLiteral(index.name, style.quote)}${style.quote}`,
         `isUnique: ${index.isUnique ? 'true' : 'false'}`,
-        `definition: ${style.quote}${escapeStringLiteral(index.definition, style.quote)}${style.quote}`,
+        `definition: ${style.quote}${escapeStringLiteral(index.definition ?? '', style.quote)}${style.quote}`,
     ]);
     return renderObjectArrayProperty('Indexes', items, level, style);
 };
@@ -1405,18 +1405,41 @@ const generateTypes = async (options) => {
             });
         }
         if (includeIndexes) {
-            const { rows: indexRows } = await client.query(`SELECT n.nspname AS schema,
-                t.relname AS table,
-                i.relname AS name,
-                ix.indisunique AS "isUnique",
-                pg_get_indexdef(ix.indexrelid) AS definition
-         FROM pg_class t
-         JOIN pg_namespace n ON n.oid = t.relnamespace
-         JOIN pg_index ix ON t.oid = ix.indrelid
-         JOIN pg_class i ON i.oid = ix.indexrelid
-         WHERE n.nspname = ANY($1)
-           AND t.relkind = 'r'
-         ORDER BY n.nspname, t.relname, i.relname`, [schemas]);
+            let indexRows = [];
+            try {
+                const { rows } = await client.query(`SELECT n.nspname AS schema,
+                  t.relname AS table,
+                  i.relname AS name,
+                  ix.indisunique AS "isUnique",
+                  pg_get_indexdef(ix.indexrelid) AS definition
+           FROM pg_class t
+           JOIN pg_namespace n ON n.oid = t.relnamespace
+           JOIN pg_index ix ON t.oid = ix.indrelid
+           JOIN pg_class i ON i.oid = ix.indexrelid
+           WHERE n.nspname = ANY($1)
+             AND t.relkind = 'r'
+           ORDER BY n.nspname, t.relname, i.relname`, [schemas]);
+                indexRows = rows;
+            }
+            catch (err) {
+                const message = String(err?.message ?? '');
+                if (!message.includes('could not open relation')) {
+                    throw err;
+                }
+                const { rows } = await client.query(`SELECT n.nspname AS schema,
+                  t.relname AS table,
+                  i.relname AS name,
+                  ix.indisunique AS "isUnique",
+                  NULL::text AS definition
+           FROM pg_class t
+           JOIN pg_namespace n ON n.oid = t.relnamespace
+           JOIN pg_index ix ON t.oid = ix.indrelid
+           JOIN pg_class i ON i.oid = ix.indexrelid
+           WHERE n.nspname = ANY($1)
+             AND t.relkind = 'r'
+           ORDER BY n.nspname, t.relname, i.relname`, [schemas]);
+                indexRows = rows;
+            }
             indexRows.forEach((row) => {
                 const tableKey = `${row.schema}.${row.table}`;
                 const existing = indexesByTable.get(tableKey) ?? [];

package/dist/postgres-client.d.ts

@@ -54,6 +54,7 @@ export declare class SupaLitePG<T extends {
     private foreignKeyCache;
     verbose: boolean;
     private bigintTransform;
+    private ownsPool;
     constructor(config?: SupaliteConfig);
     begin(): Promise<void>;
     commit(): Promise<void>;

package/dist/postgres-client.js

@@ -172,6 +172,7 @@ class SupaLitePG {
         this.schemaCache = new Map(); // schemaName.tableName -> Map<columnName, pgDataType>
         this.foreignKeyCache = new Map();
         this.verbose = false;
+        this.ownsPool = true;
         this.verbose = config?.verbose || process.env.SUPALITE_VERBOSE === 'true' || false;
         this.bigintTransform = config?.bigintTransform || 'bigint'; // 기본값 'bigint'
         if (this.verbose) {
@@ -199,44 +200,53 @@ class SupaLitePG {
                 pg_1.types.setTypeParser(20, (val) => val === null ? null : BigInt(val));
                 break;
         }
-        let poolConfigOptions = {};
-        // connectionString이 제공되면 이를 우선 사용
-        if (config?.connectionString || process.env.DB_CONNECTION) {
-            try {
-                const connectionString = config?.connectionString || process.env.DB_CONNECTION || '';
-                if (!connectionString.startsWith('postgresql://')) {
-                    throw new Error('Invalid PostgreSQL connection string format. Must start with postgresql://');
-                }
-                poolConfigOptions.connectionString = connectionString;
-                poolConfigOptions.ssl = config?.ssl !== undefined ? config.ssl : process.env.DB_SSL === 'true';
-                if (this.verbose) {
-                    console.log('[SupaLite VERBOSE] Database connection using connection string');
-                }
-            }
-            catch (err) {
-                console.error('[SupaLite ERROR] Database connection error:', err.message);
-                throw new Error(`Failed to establish database connection: ${err.message}`);
+        this.schema = config?.schema || 'public';
+        if (config?.pool) {
+            this.pool = config.pool;
+            this.ownsPool = false;
+            if (this.verbose) {
+                console.log('[SupaLite VERBOSE] Using external Pool instance');
             }
         }
         else {
-            // 기존 코드: 개별 매개변수 사용
-            poolConfigOptions = {
-                user: config?.user || process.env.DB_USER,
-                host: config?.host || process.env.DB_HOST,
-                database: config?.database || process.env.DB_NAME,
-                password: config?.password || process.env.DB_PASS,
-                port: config?.port || Number(process.env.DB_PORT) || 5432,
-                ssl: config?.ssl !== undefined ? config.ssl : process.env.DB_SSL === 'true', // ssl 설정 명시적 처리
-            };
-            if (this.verbose) {
-                console.log('[SupaLite VERBOSE] Database connection using individual parameters:', {
-                    ...poolConfigOptions,
-                    password: '********'
-                });
+            let poolConfigOptions = {};
+            // connectionString이 제공되면 이를 우선 사용
+            if (config?.connectionString || process.env.DB_CONNECTION) {
+                try {
+                    const connectionString = config?.connectionString || process.env.DB_CONNECTION || '';
+                    if (!connectionString.startsWith('postgresql://')) {
+                        throw new Error('Invalid PostgreSQL connection string format. Must start with postgresql://');
+                    }
+                    poolConfigOptions.connectionString = connectionString;
+                    poolConfigOptions.ssl = config?.ssl !== undefined ? config.ssl : process.env.DB_SSL === 'true';
+                    if (this.verbose) {
+                        console.log('[SupaLite VERBOSE] Database connection using connection string');
+                    }
+                }
+                catch (err) {
+                    console.error('[SupaLite ERROR] Database connection error:', err.message);
+                    throw new Error(`Failed to establish database connection: ${err.message}`);
+                }
             }
+            else {
+                // 기존 코드: 개별 매개변수 사용
+                poolConfigOptions = {
+                    user: config?.user || process.env.DB_USER,
+                    host: config?.host || process.env.DB_HOST,
+                    database: config?.database || process.env.DB_NAME,
+                    password: config?.password || process.env.DB_PASS,
+                    port: config?.port || Number(process.env.DB_PORT) || 5432,
+                    ssl: config?.ssl !== undefined ? config.ssl : process.env.DB_SSL === 'true', // ssl 설정 명시적 처리
+                };
+                if (this.verbose) {
+                    console.log('[SupaLite VERBOSE] Database connection using individual parameters:', {
+                        ...poolConfigOptions,
+                        password: '********'
+                    });
+                }
+            }
+            this.pool = new pg_1.Pool(poolConfigOptions);
         }
-        this.pool = new pg_1.Pool(poolConfigOptions);
-        this.schema = config?.schema || 'public';
         // Error handling
         this.pool.on('error', (err) => {
             console.error('[SupaLite ERROR] Unexpected error on idle client', err);
@@ -415,6 +425,9 @@ class SupaLitePG {
         }
     }
     async close() {
+        if (!this.ownsPool) {
+            return;
+        }
         await this.pool.end();
     }
 }

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { Pool } from 'pg';
 import { PostgresError } from './errors';
 export type Json = string | number | bigint | boolean | null | {
     [key: string]: Json | undefined;
@@ -46,6 +47,7 @@ export type UpdateRow<T extends DatabaseSchema, S extends SchemaName<T>, K exten
 export type EnumType<T extends DatabaseSchema, S extends SchemaName<T>, E extends keyof NonNullable<T[S]['Enums']>> = NonNullable<T[S]['Enums']>[E];
 export type BigintTransformType = 'bigint' | 'string' | 'number';
 export interface SupaliteConfig {
+    pool?: Pool;
     connectionString?: string;
     bigintTransform?: BigintTransformType;
     user?: string;

package/package.json

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