supalite 0.7.0 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.7.2] - 2026-01-17
+
+### ✨ Added
+- `--no-bigint` 옵션을 추가해 BIGINT를 `number`로 출력할 수 있습니다.
+
+### 🐞 Fixed
+- `js-yaml` 의존성을 보안 패치 버전으로 업데이트했습니다. (prototype pollution 대응)
+
+## [0.7.1] - 2026-01-17
+
+### ✨ Added
+- `supalite gen types` 기본 출력이 Supabase CLI 포맷과 최대한 동일하도록 정렬/포맷/헬퍼 타입/Constants를 추가했습니다.
+- `--format supabase|supalite`, `--bigint-type`, `--json-bigint` 옵션을 추가했습니다.
+- Supabase 포맷에서 insertable view에 `Insert`/`Update`를 포함하고, 함수 오버로드 출력 형태를 Supabase와 맞췄습니다.
+
+### 🔧 Changed
+- Supabase 포맷 기본값 기준으로 관계/복합 타입/함수 시그니처가 기본 포함됩니다. (legacy 출력은 `--format supalite`)
+
 ## [0.7.0] - 2026-01-17
 
 ### ✨ Added

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)
@@ -57,7 +63,7 @@ ORM 기능(관계 모델링/중첩 쓰기 등)이 꼭 필요하면 Prisma/Drizzl
 
 `supabase db pull`에 대해서: 이는 ORM 기능이 아니라 마이그레이션/스키마 동기화 단계입니다. SupaLite 내부에 구현하기보다 “권장 워크플로우”로 문서화하고, 필요하다면 `pg-schema-sync` + 타입 생성기를 묶는 간단한 CLI 래퍼가 현실적입니다.
 
-SupaLite용 타입 생성기가 필요하다면 `supalite gen types` CLI를 로드맵에 추가할 수 있습니다.
+SupaLite는 `supalite gen types`를 포함하며, 기본 출력은 SupaLite 포맷(Supabase CLI 출력의 상위 집합)입니다. Supabase CLI와 1:1로 맞추려면 `--format supabase`를 사용하세요.
 
 ## SupaLite vs Prisma / Drizzle
 
@@ -129,7 +135,8 @@ const data = await db
 - Node/pg 버전별 CI 매트릭스와 통합 테스트
 - 벤치마크 및 성능 가이드
 - Auth/Storage/Realtime 마이그레이션 가이드 (Cognito/GIP, S3/GCS, Realtime 대안)
-- `supalite gen types` (Supabase 호환 타입 생성기)
+- `pg-schema-sync` 기반 `supalite db pull` 스키마 동기화 래퍼
+- `supalite gen types` (SupaLite 중심 타입 생성기, Supabase 포맷 옵션 제공)
 - 기여 가이드/이슈 템플릿
 
 ## 성능 노트 (서버리스 Supabase vs 클라우드 Postgres)
@@ -254,14 +261,19 @@ npx supalite gen types --db-url "postgresql://user:pass@localhost:5432/db" --sch
 ```
 
 - `--out -`는 stdout으로 출력합니다.
-- BIGINT 컬럼은 `bigint`로 생성됩니다.
+- 기본 출력은 SupaLite 포맷(= Supabase CLI의 상위 집합)입니다. Supabase CLI와 1:1로 맞추려면 `--format supabase`를 사용하세요.
+- SupaLite 포맷은 `Constraints`/`Indexes`, `Relationships`의 `referencedSchema`, `bigint` + `Json` bigint 지원, setof RPC용 `SetofOptions`를 추가로 포함합니다.
+- BIGINT 컬럼 타입은 `--bigint-type bigint|number|string`로 제어합니다. (기본: supabase=number, supalite=bigint)
+- `--no-bigint`는 `--bigint-type number`의 간편 옵션입니다.
+- `--json-bigint`는 `Json` 타입에 `bigint`를 포함합니다. (기본: supabase=false, supalite=true)
+- `--no-json-bigint`는 `Json` 타입에서 `bigint`를 제외합니다.
 - `--date-as-date`는 `date`/`timestamp` 컬럼을 `Date`로 생성합니다.
-- `--include-relationships`는 FK 메타데이터를 `Relationships`에 포함합니다.
-- `--include-constraints`는 PK/UNIQUE/CHECK/FK 메타데이터를 포함합니다.
-- `--include-indexes`는 인덱스 메타데이터(이름/유니크/정의)를 포함합니다.
-- `--include-composite-types`는 `CompositeTypes` 정의를 포함합니다.
-- `--include-function-signatures`는 `Functions.Args/Returns`를 스키마 메타데이터로 매핑합니다.
-- `Functions`에는 감지된 함수명이 기본 포함되며, `--include-function-signatures`로 RPC Args/Returns 참고가 가능합니다.
+- `--include-relationships`는 FK 메타데이터를 `Relationships`에 포함합니다. (기본: true)
+- `--include-constraints`는 PK/UNIQUE/CHECK/FK 메타데이터를 포함합니다. (기본: supabase=false, supalite=true)
+- `--include-indexes`는 인덱스 메타데이터(이름/유니크/정의)를 포함합니다. (기본: supabase=false, supalite=true)
+- `--include-composite-types`는 `CompositeTypes` 정의를 포함합니다. (기본: true)
+- `--include-function-signatures`는 `Functions.Args/Returns`를 스키마 메타데이터로 매핑합니다. (기본: true)
+- `Functions`에는 감지된 함수명이 기본 포함되며, 시그니처도 기본 포함됩니다.
 - `--type-case`는 enum/composite 타입 키의 케이스를 제어합니다 (`preserve` | `snake` | `camel` | `pascal`)
 - `--function-case`는 함수 키의 케이스를 제어합니다 (`preserve` | `snake` | `camel` | `pascal`)
 - `--dump-functions-sql [path]`는 `pg_get_functiondef` 기반의 `CREATE FUNCTION/PROCEDURE` 정의를 로컬 파일로 저장합니다.
@@ -302,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
@@ -1026,7 +1053,7 @@ await client.close();
 ### 클라이언트 메소드
 
 - `testConnection()`: 데이터베이스 연결 확인
-- `close()`: 커넥션 풀 종료
+- `close()`: 내부 커넥션 풀 종료 (외부 `pool` 사용 시 no-op)
 
 ## 환경 변수 설정
 
@@ -1046,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)
@@ -58,7 +64,7 @@ ORM features (relations, nested writes, etc.) are best handled by Prisma/Drizzle
 
 About `supabase db pull`: it is a schema/migration sync step, not an ORM feature. Rather than implementing it inside SupaLite, we recommend documenting the workflow and optionally providing a lightweight CLI wrapper that combines `pg-schema-sync` + type generation.
 
-If a SupaLite-native type generator makes sense, we can add a `supalite gen types` CLI in the roadmap.
+SupaLite now includes `supalite gen types`, which defaults to the SupaLite format (a superset of Supabase CLI output). Use `--format supabase` for byte-for-byte Supabase CLI output.
 
 ## SupaLite vs Prisma / Drizzle
 
@@ -130,7 +136,8 @@ 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 gen types` (Supabase-compatible type generator)
+- `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
 
 ## Performance notes (serverless Supabase vs cloud Postgres)
@@ -255,14 +262,19 @@ npx supalite gen types --db-url "postgresql://user:pass@localhost:5432/db" --sch
 ```
 
 - `--out -` prints to stdout
-- BIGINT columns map to `bigint`
+- Default output is SupaLite format (superset of Supabase CLI). Use `--format supabase` for byte-for-byte Supabase CLI output.
+- SupaLite format also includes `Constraints`/`Indexes`, `referencedSchema` in `Relationships`, `bigint` + `Json` bigint support, and `SetofOptions` for setof RPCs.
+- BIGINT type mapping is controlled by `--bigint-type bigint|number|string` (default: supabase=number, supalite=bigint)
+- `--no-bigint` is a shortcut for `--bigint-type number`
+- `--json-bigint` includes `bigint` in the `Json` union (default: supabase=false, supalite=true)
+- `--no-json-bigint` disables bigint in the `Json` union
 - `--date-as-date` maps `date`/`timestamp` columns to `Date`
-- `--include-relationships` emits foreign-key metadata into `Relationships`
-- `--include-constraints` emits primary/unique/check/foreign key metadata
-- `--include-indexes` emits index metadata (name, uniqueness, definition)
-- `--include-composite-types` emits `CompositeTypes` definitions
-- `--include-function-signatures` maps `Functions.Args/Returns` from schema metadata
-- `Functions` always lists detected function names; use `--include-function-signatures` for RPC Args/Returns reference
+- `--include-relationships` emits foreign-key metadata into `Relationships` (default: true)
+- `--include-constraints` emits primary/unique/check/foreign key metadata (default: supabase=false, supalite=true)
+- `--include-indexes` emits index metadata (name, uniqueness, definition) (default: supabase=false, supalite=true)
+- `--include-composite-types` emits `CompositeTypes` definitions (default: true)
+- `--include-function-signatures` maps `Functions.Args/Returns` from schema metadata (default: true)
+- `Functions` always lists detected function names; signatures are included by default
 - `--type-case` controls enum/composite type key casing (`preserve` | `snake` | `camel` | `pascal`)
 - `--function-case` controls function key casing (`preserve` | `snake` | `camel` | `pascal`)
 - `--dump-functions-sql [path]` writes `CREATE FUNCTION/PROCEDURE` definitions (from `pg_get_functiondef`) to a local file
@@ -302,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
@@ -1042,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
 
@@ -155,7 +156,11 @@ Notes:
 - `supalite gen types --db-url <postgres_url> [--schema public,analytics] [--out supalite.types.ts]`
 - Reads schema metadata from `information_schema` and `pg_catalog`.
 - Emits `Json` and a `Database` type with `Tables`, `Views`, `Functions`, `Enums`, and `CompositeTypes`.
-- `BIGINT` maps to `bigint`; `json/jsonb` map to `Json`.
+- `--format supalite|supabase` (default: supalite).
+- `--format supabase` matches Supabase CLI output (including formatting).
+- SupaLite format is a superset of Supabase: `Constraints`/`Indexes`, `referencedSchema` in `Relationships`, `bigint` defaults, `Json` bigint, and `SetofOptions` for setof RPCs.
+- `BIGINT` maps to `bigint` by default (`--format supabase` defaults to `number`); `--no-bigint` is a shorthand for `--bigint-type number`.
+- `json/jsonb` map to `Json` with optional `bigint` (`--json-bigint` default: supalite=true, supabase=false; disable via `--no-json-bigint`).
 - `--date-as-date` maps `date`/`timestamp` columns to `Date`.
 - `--include-relationships` emits FK metadata in `Relationships`.
 - `--include-constraints` emits PK/UNIQUE/CHECK/FK metadata per table.

package/dist/cli.js

@@ -11,6 +11,11 @@ const printUsage = () => {
   --db-url <postgres_url> \\
   [--schema public,analytics] \\
   [--out supalite.types.ts] \\
+  [--format supabase|supalite] \\
+  [--bigint-type bigint|number|string] \\
+  [--no-bigint] \\
+  [--json-bigint] \\
+  [--no-json-bigint] \\
   [--date-as-date] \\
   [--include-relationships] \\
   [--include-constraints] \\
@@ -24,12 +29,16 @@ const printUsage = () => {
 Defaults:
 - schema: public
 - out: supalite.types.ts (use --out - to print to stdout)
+- format: supalite
 - dateAsDate: false
-- includeRelationships: false
-- includeConstraints: false
-- includeIndexes: false
-- includeCompositeTypes: false
-- includeFunctionSignatures: false
+- includeRelationships: true
+- includeConstraints: false (supabase), true (supalite)
+- includeIndexes: false (supabase), true (supalite)
+- includeCompositeTypes: true
+- includeFunctionSignatures: true
+- bigintType: number (supabase), bigint (supalite)
+- noBigint: false
+- jsonBigint: false (supabase), true (supalite)
 - typeCase: preserve
 - functionCase: preserve
 - dumpFunctionsSql: false
@@ -44,16 +53,37 @@ const parseCase = (value) => {
     }
     return undefined;
 };
+const parseFormat = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'supabase' || value === 'supalite') {
+        return value;
+    }
+    return undefined;
+};
+const parseBigintType = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'bigint' || value === 'number' || value === 'string') {
+        return value;
+    }
+    return undefined;
+};
 const parseArgs = (args) => {
     const result = {
         schemas: [],
         out: 'supalite.types.ts',
+        format: undefined,
+        bigintType: undefined,
+        jsonBigint: undefined,
         dateAsDate: false,
-        includeRelationships: false,
-        includeConstraints: false,
-        includeIndexes: false,
-        includeCompositeTypes: false,
-        includeFunctionSignatures: false,
+        includeRelationships: undefined,
+        includeConstraints: undefined,
+        includeIndexes: undefined,
+        includeCompositeTypes: undefined,
+        includeFunctionSignatures: undefined,
         dumpFunctionsSql: false,
         help: false,
     };
@@ -83,6 +113,28 @@ const parseArgs = (args) => {
             i += 1;
             continue;
         }
+        if (arg === '--format') {
+            result.format = parseFormat(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg === '--bigint-type') {
+            result.bigintType = parseBigintType(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg === '--no-bigint') {
+            result.bigintType = 'number';
+            continue;
+        }
+        if (arg === '--json-bigint') {
+            result.jsonBigint = true;
+            continue;
+        }
+        if (arg === '--no-json-bigint') {
+            result.jsonBigint = false;
+            continue;
+        }
         if (arg === '--date-as-date') {
             result.dateAsDate = true;
             continue;
@@ -150,6 +202,9 @@ const run = async () => {
     const output = await (0, gen_types_1.generateTypes)({
         dbUrl,
         schemas,
+        format: parsed.format,
+        bigintType: parsed.bigintType,
+        jsonBigint: parsed.jsonBigint,
         dateAsDate: parsed.dateAsDate,
         includeRelationships: parsed.includeRelationships,
         includeConstraints: parsed.includeConstraints,

package/dist/gen-types.d.ts

@@ -1,4 +1,6 @@
 type NameCase = 'preserve' | 'snake' | 'camel' | 'pascal';
+type OutputFormat = 'supalite' | 'supabase';
+type BigintType = 'bigint' | 'number' | 'string';
 export type GenTypesOptions = {
     dbUrl: string;
     schemas?: string[];
@@ -10,6 +12,9 @@ export type GenTypesOptions = {
     includeFunctionSignatures?: boolean;
     typeCase?: NameCase;
     functionCase?: NameCase;
+    format?: OutputFormat;
+    bigintType?: BigintType;
+    jsonBigint?: boolean;
 };
 export type DumpFunctionsSqlOptions = {
     dbUrl: string;