aurabase-js 0.2.1 → 0.4.0

package/src/QueryBuilder.ts

@@ -1,6 +1,7 @@
+import { AuraBaseApiError } from './errors';
 import { PostgrestResponse, AuraBaseError } from './types';
 
-type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE';
+type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
 
 export class QueryBuilder<T> {
   private url: string;
@@ -11,13 +12,6 @@ export class QueryBuilder<T> {
   private headers: Record<string, string>;
   private isSingle: boolean = false;
 
-  // CUD state — stored so filters can be chained AFTER insert/update/delete
-  private _method: HttpMethod = 'GET';
-  private _body: unknown = undefined;
-  private _isUpsert: boolean = false;
-  private _onConflict: string | undefined = undefined;
-  private _idValue: unknown = undefined; // .eq('id', x) → URL path for PATCH/DELETE
-
   constructor(
     url: string,
     anonKey: string,
@@ -33,167 +27,173 @@ export class QueryBuilder<T> {
     this.headers = { ...headers };
   }
 
-  // ── SELECT ────────────────────────────────────────────────────────────────
-  // .select('id, title') → ?select=id,title
+  /**
+   * Select columns
+   * @example
+   * .select('id, name, email')
+   * .select('*')
+   */
   select(columns: string = '*'): this {
-    if (columns !== '*') this.queryParams.set('select', columns.replace(/\s/g, ''));
+    this.queryParams.set('select', columns);
     return this;
   }
 
-  // ── FILTERS ───────────────────────────────────────────────────────────────
-  // .eq('id', 1) → ?eq=id:1  (id 컬럼이면 URL path용으로도 저장)
+  /**
+   * Filter by column equality
+   * @example
+   * .eq('id', 1)
+   * .eq('status', 'active')
+   */
   eq(column: string, value: unknown): this {
-    if (column === 'id') this._idValue = value;
-    this.queryParams.append('eq', `${column}:${value}`);
+    this.queryParams.append(column, `eq.${value}`);
     return this;
   }
 
+  /**
+   * Filter by column inequality
+   */
   neq(column: string, value: unknown): this {
-    this.queryParams.append('neq', `${column}:${value}`);
+    this.queryParams.append(column, `neq.${value}`);
     return this;
   }
 
+  /**
+   * Filter by greater than
+   */
   gt(column: string, value: unknown): this {
-    this.queryParams.append('gt', `${column}:${value}`);
+    this.queryParams.append(column, `gt.${value}`);
     return this;
   }
 
+  /**
+   * Filter by greater than or equal
+   */
   gte(column: string, value: unknown): this {
-    this.queryParams.append('gte', `${column}:${value}`);
+    this.queryParams.append(column, `gte.${value}`);
     return this;
   }
 
+  /**
+   * Filter by less than
+   */
   lt(column: string, value: unknown): this {
-    this.queryParams.append('lt', `${column}:${value}`);
+    this.queryParams.append(column, `lt.${value}`);
     return this;
   }
 
+  /**
+   * Filter by less than or equal
+   */
   lte(column: string, value: unknown): this {
-    this.queryParams.append('lte', `${column}:${value}`);
+    this.queryParams.append(column, `lte.${value}`);
     return this;
   }
 
+  /**
+   * Filter by like pattern
+   */
   like(column: string, pattern: string): this {
-    this.queryParams.append('like', `${column}:${pattern}`);
+    this.queryParams.append(column, `like.${pattern}`);
     return this;
   }
 
+  /**
+   * Filter by case-insensitive like pattern
+   */
   ilike(column: string, pattern: string): this {
-    this.queryParams.append('ilike', `${column}:${pattern}`);
-    return this;
-  }
-
-  in(column: string, values: unknown[]): this {
-    this.queryParams.append('in', `${column}:${values.join(',')}`);
+    this.queryParams.append(column, `ilike.${pattern}`);
     return this;
   }
 
+  /**
+   * Filter by array contains
+   */
   contains(column: string, value: unknown[]): this {
-    this.queryParams.append('contains', `${column}:${JSON.stringify(value)}`);
+    this.queryParams.append(column, `cs.{${value.join(',')}}`);
     return this;
   }
 
-  containedBy(column: string, value: unknown[]): this {
-    this.queryParams.append('contained_by', `${column}:${JSON.stringify(value)}`);
+  /**
+   * Filter by value in array
+   */
+  in(column: string, values: unknown[]): this {
+    this.queryParams.append(column, `in.(${values.join(',')})`);
     return this;
   }
 
+  /**
+   * Filter for null values
+   */
   isNull(column: string): this {
-    this.queryParams.append('is_null', `${column}:true`);
+    this.queryParams.append(column, 'is.null');
     return this;
   }
 
+  /**
+   * Filter for non-null values
+   */
   isNotNull(column: string): this {
-    this.queryParams.append('is_null', `${column}:false`);
-    return this;
-  }
-
-  search(query: string): this {
-    this.queryParams.set('search', query);
-    return this;
-  }
-
-  not(operator: string, column: string, value: unknown): this {
-    this.queryParams.append('not', `${operator}:${column}:${value}`);
-    return this;
-  }
-
-  or(conditions: string): this {
-    this.queryParams.set('or', conditions);
+    this.queryParams.append(column, 'is.not.null');
     return this;
   }
 
-  // ── ORDER / PAGINATION ────────────────────────────────────────────────────
-  // .order('created_at', { ascending: false }) → ?order=created_at.desc
-  // 다중 호출 시 comma 연결 → ?order=price.desc,name.asc
+  /**
+   * Order results
+   * @example
+   * .order('created_at', { ascending: false })
+   */
   order(column: string, options: { ascending?: boolean; nullsFirst?: boolean } = {}): this {
     const { ascending = true, nullsFirst } = options;
-    let str = ascending ? column : `${column}.desc`;
-    if (nullsFirst !== undefined) str += nullsFirst ? '.nullsfirst' : '.nullslast';
-    const existing = this.queryParams.get('order');
-    this.queryParams.set('order', existing ? `${existing},${str}` : str);
+    let orderStr = column;
+    if (!ascending) orderStr += '.desc';
+    if (nullsFirst !== undefined) {
+      orderStr += nullsFirst ? '.nullsfirst' : '.nullslast';
+    }
+    this.queryParams.append('order', orderStr);
     return this;
   }
 
+  /**
+   * Limit results
+   */
   limit(count: number): this {
     this.queryParams.set('limit', String(count));
     return this;
   }
 
+  /**
+   * Offset results
+   */
   offset(count: number): this {
     this.queryParams.set('offset', String(count));
     return this;
   }
 
+  /**
+   * Range of results (offset + limit)
+   */
   range(from: number, to: number): this {
     this.queryParams.set('offset', String(from));
     this.queryParams.set('limit', String(to - from + 1));
     return this;
   }
 
+  /**
+   * Return single result
+   */
   single(): this {
     this.isSingle = true;
     return this;
   }
 
+  /**
+   * Return single result or null
+   */
   maybeSingle(): this {
     this.isSingle = true;
     return this;
   }
 
-  // ── CUD — Supabase 스타일: 모두 this 반환 → .eq() 체이닝 가능 ─────────────
-  // await client.from('todos').insert({ title: '할일' })
-  insert(row: Partial<T> | Partial<T>[]): this {
-    this._method = 'POST';
-    const rows = Array.isArray(row) ? row : [row];
-    this._body = rows.length === 1 ? rows[0] : rows;
-    return this;
-  }
-
-  // await client.from('todos').update({ completed: true }).eq('id', 1)
-  update(data: Partial<T>): this {
-    this._method = 'PATCH';
-    this._body = data;
-    return this;
-  }
-
-  // await client.from('todos').upsert({ id: 1, title: '수정됨' }, { onConflict: 'id' })
-  upsert(row: Partial<T> | Partial<T>[], options: { onConflict?: string } = {}): this {
-    this._method = 'POST';
-    this._isUpsert = true;
-    this._onConflict = options.onConflict;
-    const rows = Array.isArray(row) ? row : [row];
-    this._body = rows.length === 1 ? rows[0] : rows;
-    return this;
-  }
-
-  // await client.from('todos').delete().eq('id', 1)
-  delete(): this {
-    this._method = 'DELETE';
-    return this;
-  }
-
-  // ── INTERNALS ─────────────────────────────────────────────────────────────
   private getHeaders(): Record<string, string> {
     const token = this.accessToken || this.anonKey;
     return {
@@ -204,77 +204,116 @@ export class QueryBuilder<T> {
     };
   }
 
-  private buildUrl(): string {
-    // upsert: POST /api/{table}/upsert?on_conflict=col
-    if (this._isUpsert) {
-      const qs = this._onConflict ? `?on_conflict=${this._onConflict}` : '';
-      return `${this.url}/api/${this.tableName}/upsert${qs}`;
-    }
-
-    // PATCH/DELETE with id: /api/{table}/{id}/  (query params 제외)
-    if ((this._method === 'PATCH' || this._method === 'DELETE') && this._idValue !== undefined) {
-      return `${this.url}/api/${this.tableName}/${this._idValue}/`;
-    }
-
-    // GET/POST: /api/{table}/?...params
-    const qs = this.queryParams.toString();
-    return `${this.url}/api/${this.tableName}/${qs ? `?${qs}` : ''}`;
-  }
+  private async request<TResponse>(
+    method: HttpMethod,
+    body?: unknown
+  ): Promise<PostgrestResponse<TResponse>> {
+    const queryString = this.queryParams.toString();
+    const fullUrl = `${this.url}/rest/v1/${this.tableName}${queryString ? `?${queryString}` : ''}`;
 
-  private async execute(): Promise<PostgrestResponse<T>> {
-    const fullUrl = this.buildUrl();
-    const reqHeaders = this.getHeaders();
-    const options: RequestInit = { method: this._method, headers: reqHeaders };
+    const options: RequestInit = {
+      method,
+      headers: this.getHeaders(),
+    };
 
-    if (this._body !== undefined && this._method !== 'GET') {
-      options.body = JSON.stringify(this._body);
-      (reqHeaders as Record<string, string>)['Prefer'] = 'return=representation';
+    if (body && method !== 'GET') {
+      options.body = JSON.stringify(body);
+      (options.headers as Record<string, string>)['Prefer'] = 'return=representation';
     }
 
     try {
       const response = await fetch(fullUrl, options);
-      const text = await response.text();
-      let data: T | T[] | null = null;
+
+      let data: TResponse | null = null;
       let error: AuraBaseError | null = null;
 
+      const text = await response.text();
+
       if (text) {
         try {
           const parsed = JSON.parse(text);
+
           if (!response.ok) {
             error = {
-              message: parsed.message || parsed.error || parsed.detail || `HTTP ${response.status}`,
+              message: parsed.message || parsed.error || `HTTP ${response.status}`,
               code: parsed.code,
               details: parsed.details,
             };
           } else {
-            data = this.isSingle && Array.isArray(parsed) ? (parsed[0] ?? null) : parsed;
+            data = this.isSingle && Array.isArray(parsed) ? parsed[0] ?? null : parsed;
           }
         } catch {
-          if (!response.ok) error = { message: text || `HTTP ${response.status}` };
+          if (!response.ok) {
+            error = {
+              message: text || `HTTP ${response.status}`,
+            };
+          }
         }
       }
 
-      return { data, error, status: response.status, statusText: response.statusText };
+      return {
+        data,
+        error,
+        status: response.status,
+        statusText: response.statusText,
+      };
     } catch (err) {
       return {
         data: null,
-        error: { message: err instanceof Error ? err.message : 'Network error' },
+        error: {
+          message: err instanceof Error ? err.message : 'Network error',
+        },
         status: 0,
         statusText: 'Network Error',
       };
     }
   }
 
-  // then() — await 시 자동 실행
-  async then(
-    resolve: (value: PostgrestResponse<T>) => void | PromiseLike<void>,
+  /**
+   * Execute SELECT query
+   */
+  async then<TResult = T[]>(
+    resolve: (value: PostgrestResponse<TResult>) => void | PromiseLike<void>,
     reject?: (reason: unknown) => void | PromiseLike<void>
   ): Promise<void> {
     try {
-      const result = await this.execute();
+      const result = await this.request<TResult>('GET');
       await resolve(result);
     } catch (err) {
-      if (reject) await reject(err);
+      if (reject) {
+        await reject(err);
+      }
     }
   }
+
+  /**
+   * Insert row(s)
+   */
+  async insert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>> {
+    const rows = Array.isArray(row) ? row : [row];
+    return this.request<T>('POST', rows.length === 1 ? rows[0] : rows);
+  }
+
+  /**
+   * Update row(s)
+   */
+  async update(data: Partial<T>): Promise<PostgrestResponse<T>> {
+    return this.request<T>('PATCH', data);
+  }
+
+  /**
+   * Upsert row(s)
+   */
+  async upsert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>> {
+    const rows = Array.isArray(row) ? row : [row];
+    this.headers['Prefer'] = 'resolution=merge-duplicates,return=representation';
+    return this.request<T>('POST', rows.length === 1 ? rows[0] : rows);
+  }
+
+  /**
+   * Delete row(s)
+   */
+  async delete(): Promise<PostgrestResponse<T>> {
+    return this.request<T>('DELETE');
+  }
 }