supalite 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.5.0] - 2025-07-01
+
+### ✨ Added
+-   **Join Query Support**: Implemented support for PostgREST-style join queries in the `.select()` method. You can now fetch related data from foreign tables using the syntax `related_table(*)` or `related_table(column1, column2)`. This is achieved by dynamically generating `json_agg` subqueries.
+
+### 🛠 Changed
+-   `SupaLitePG` client now includes a `getForeignKey` method to resolve foreign key relationships, with caching for better performance.
+-   `QueryBuilder`'s `select` and `buildQuery` methods were enhanced to parse the new syntax and construct the appropriate SQL queries.
+
 ## [0.4.0] - 2025-06-10
 
 ### ✨ Added

package/dist/postgres-client.d.ts

@@ -27,6 +27,7 @@ export declare class SupaLitePG<T extends {
     private isTransaction;
     private schema;
     private schemaCache;
+    private foreignKeyCache;
     verbose: boolean;
     private bigintTransform;
     constructor(config?: SupaliteConfig);
@@ -41,6 +42,10 @@ export declare class SupaLitePG<T extends {
         single(): Promise<SingleQueryResult<Row<T, S, K>>>;
     };
     getColumnPgType(dbSchema: string, tableName: string, columnName: string): Promise<string | undefined>;
+    getForeignKey(schema: string, table: string, foreignTable: string): Promise<{
+        column: string;
+        foreignColumn: string;
+    } | null>;
     rpc(procedureName: string, params?: Record<string, any>): Promise<{
         data: any;
         error: PostgresError | null;

package/dist/postgres-client.js

@@ -12,6 +12,7 @@ class SupaLitePG {
         this.client = null;
         this.isTransaction = false;
         this.schemaCache = new Map(); // schemaName.tableName -> Map<columnName, pgDataType>
+        this.foreignKeyCache = new Map();
         this.verbose = false;
         this.verbose = config?.verbose || process.env.SUPALITE_VERBOSE === 'true' || false;
         this.bigintTransform = config?.bigintTransform || 'bigint'; // 기본값 'bigint'
@@ -178,6 +179,47 @@ class SupaLitePG {
             console.log(`[SupaLite VERBOSE] pgType for ${tableKey}.${columnName}: ${pgType}`);
         return pgType;
     }
+    async getForeignKey(schema, table, foreignTable) {
+        const cacheKey = `${schema}.${table}.${foreignTable}`;
+        if (this.foreignKeyCache.has(cacheKey)) {
+            return this.foreignKeyCache.get(cacheKey);
+        }
+        const query = `
+      SELECT
+        kcu.column_name,
+        ccu.column_name AS foreign_column_name
+      FROM
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = $1
+        AND tc.table_name = $2
+        AND ccu.table_name = $3;
+    `;
+        const activeClient = this.isTransaction && this.client ? this.client : await this.pool.connect();
+        try {
+            const result = await activeClient.query(query, [schema, foreignTable, table]);
+            if (result.rows.length > 0) {
+                const relationship = {
+                    column: result.rows[0].foreign_column_name,
+                    foreignColumn: result.rows[0].column_name,
+                };
+                this.foreignKeyCache.set(cacheKey, relationship);
+                return relationship;
+            }
+        }
+        finally {
+            if (!(this.isTransaction && this.client)) {
+                activeClient.release();
+            }
+        }
+        this.foreignKeyCache.set(cacheKey, null);
+        return null;
+    }
     async rpc(procedureName, params = {}) {
         try {
             const paramNames = Object.keys(params);

package/dist/query-builder.d.ts

@@ -7,6 +7,7 @@ export declare class QueryBuilder<T extends DatabaseSchema, S extends SchemaName
     private table;
     private schema;
     private selectColumns;
+    private joinClauses;
     private whereConditions;
     private orConditions;
     private countOption?;

package/dist/query-builder.js

@@ -10,6 +10,7 @@ class QueryBuilder {
         this.pool = pool;
         this[_a] = 'QueryBuilder';
         this.selectColumns = null;
+        this.joinClauses = [];
         this.whereConditions = [];
         this.orConditions = [];
         this.orderByColumns = [];
@@ -32,17 +33,41 @@ class QueryBuilder {
         return this.execute().finally(onfinally);
     }
     select(columns = '*', options) {
-        if (columns && columns !== '*') {
-            this.selectColumns = columns.split(',')
-                .map(col => col.trim())
-                .map(col => col.startsWith('"') && col.endsWith('"') ? col : `"${col}"`)
-                .join(', ');
-        }
-        else {
-            this.selectColumns = columns;
-        }
         this.countOption = options?.count;
         this.headOption = options?.head;
+        if (!columns || columns === '*') {
+            this.selectColumns = '*';
+            return this;
+        }
+        const joinRegex = /(\w+)\(([^)]+)\)/g;
+        let match;
+        const regularColumns = [];
+        let lastIndex = 0;
+        while ((match = joinRegex.exec(columns)) !== null) {
+            const foreignTable = match[1];
+            const innerColumns = match[2];
+            this.joinClauses.push({ foreignTable, columns: innerColumns });
+            // Add the part of the string before this match to regular columns, if any
+            const preceding = columns.substring(lastIndex, match.index).trim();
+            if (preceding) {
+                regularColumns.push(...preceding.split(',').filter(c => c.trim()));
+            }
+            lastIndex = joinRegex.lastIndex;
+        }
+        // Add the rest of the string after the last match
+        const remaining = columns.substring(lastIndex).trim();
+        if (remaining) {
+            regularColumns.push(...remaining.split(',').filter(c => c.trim()));
+        }
+        const processedColumns = regularColumns
+            .map(col => col.trim())
+            .filter(col => col)
+            .map(col => {
+            if (col === '*')
+                return '*';
+            return col.startsWith('"') && col.endsWith('"') ? col : `"${col}"`;
+        });
+        this.selectColumns = processedColumns.length > 0 ? processedColumns.join(', ') : null;
         return this;
     }
     match(conditions) {
@@ -207,18 +232,48 @@ class QueryBuilder {
         const returning = this.shouldReturnData() ? ` RETURNING ${this.selectColumns || '*'}` : '';
         const schemaTable = `"${String(this.schema)}"."${String(this.table)}"`;
         switch (this.queryType) {
-            case 'SELECT':
+            case 'SELECT': {
                 if (this.headOption) {
                     query = `SELECT COUNT(*) FROM ${schemaTable}`;
+                    values = [...this.whereValues];
+                    break;
                 }
-                else {
-                    query = `SELECT ${this.selectColumns || '*'} FROM ${schemaTable}`;
-                    if (this.countOption === 'exact') {
-                        query = `SELECT *, COUNT(*) OVER() as exact_count FROM (${query}) subquery`;
+                let selectClause = this.selectColumns;
+                if (!selectClause) {
+                    selectClause = this.joinClauses.length > 0 ? `${schemaTable}.*` : '*';
+                }
+                else if (selectClause.includes('*') && this.joinClauses.length > 0) {
+                    selectClause = selectClause.replace('*', `${schemaTable}.*`);
+                }
+                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;
                     }
+                    const foreignSchemaTable = `"${String(this.schema)}"."${join.foreignTable}"`;
+                    return `(
+              SELECT json_agg(j)
+              FROM (
+                SELECT ${join.columns}
+                FROM ${foreignSchemaTable}
+                WHERE "${fk.foreignColumn}" = ${schemaTable}."${fk.column}"
+              ) as j
+            ) as "${join.foreignTable}"`;
+                }));
+                const validSubqueries = joinSubqueries.filter(Boolean).join(', ');
+                if (validSubqueries) {
+                    selectClause += `, ${validSubqueries}`;
+                }
+                query = `SELECT ${selectClause} FROM ${schemaTable}`;
+                if (this.countOption === 'exact') {
+                    // This part might need adjustment if subqueries are complex
+                    query = `SELECT *, COUNT(*) OVER() as exact_count FROM (${query}) subquery`;
                 }
                 values = [...this.whereValues];
                 break;
+            }
             case 'INSERT':
             case 'UPSERT': {
                 if (!this.insertData)

package/package.json

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