aurabase-js 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -2,6 +2,11 @@
 var QueryBuilder = class {
   constructor(url, anonKey, accessToken, tableName, headers = {}) {
     this.isSingle = false;
+    this._method = "GET";
+    this._body = void 0;
+    this._isUpsert = false;
+    this._onConflict = void 0;
+    this._idValue = void 0;
     this.url = url;
     this.anonKey = anonKey;
     this.accessToken = accessToken;
@@ -9,101 +14,120 @@ var QueryBuilder = class {
     this.queryParams = new URLSearchParams();
     this.headers = { ...headers };
   }
-  /**
-   * Select columns
-   * @example
-   * .select('id, name, email')
-   * .select('*')
-   */
   select(columns = "*") {
-    this.queryParams.set("select", columns);
+    if (columns !== "*") this.queryParams.set("select", columns.replace(/\s/g, ""));
     return this;
   }
-  /**
-   * Filter by column equality
-   * @example
-   * .eq('id', 1)
-   * .eq('status', 'active')
-   */
   eq(column, value) {
-    this.queryParams.append(column, `eq.${value}`);
+    if (column === "id") this._idValue = value;
+    this.queryParams.append("eq", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by column inequality
    */
   neq(column, value) {
-    this.queryParams.append(column, `neq.${value}`);
+    this.queryParams.append("neq", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by greater than
    */
   gt(column, value) {
-    this.queryParams.append(column, `gt.${value}`);
+    this.queryParams.append("gt", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by greater than or equal
    */
   gte(column, value) {
-    this.queryParams.append(column, `gte.${value}`);
+    this.queryParams.append("gte", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by less than
    */
   lt(column, value) {
-    this.queryParams.append(column, `lt.${value}`);
+    this.queryParams.append("lt", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by less than or equal
    */
   lte(column, value) {
-    this.queryParams.append(column, `lte.${value}`);
+    this.queryParams.append("lte", `${column}:${value}`);
     return this;
   }
   /**
    * Filter by like pattern
    */
   like(column, pattern) {
-    this.queryParams.append(column, `like.${pattern}`);
+    this.queryParams.append("like", `${column}:${pattern}`);
     return this;
   }
   /**
    * Filter by case-insensitive like pattern
    */
   ilike(column, pattern) {
-    this.queryParams.append(column, `ilike.${pattern}`);
+    this.queryParams.append("ilike", `${column}:${pattern}`);
     return this;
   }
   /**
    * Filter by array contains
    */
   contains(column, value) {
-    this.queryParams.append(column, `cs.{${value.join(",")}}`);
+    this.queryParams.append("contains", `${column}:${JSON.stringify(value)}`);
     return this;
   }
   /**
    * Filter by value in array
    */
   in(column, values) {
-    this.queryParams.append(column, `in.(${values.join(",")})`);
+    this.queryParams.append("in", `${column}:${values.join(",")}`);
     return this;
   }
   /**
    * Filter for null values
    */
   isNull(column) {
-    this.queryParams.append(column, "is.null");
+    this.queryParams.append("is_null", `${column}:true`);
     return this;
   }
   /**
    * Filter for non-null values
    */
   isNotNull(column) {
-    this.queryParams.append(column, "is.not.null");
+    this.queryParams.append("is_null", `${column}:false`);
+    return this;
+  }
+  /**
+   * Full-text search across all columns
+   */
+  search(query) {
+    this.queryParams.set("search", query);
+    return this;
+  }
+  /**
+   * Negate a filter
+   * @example .not('eq', 'category', 'Electronics')
+   */
+  not(operator, column, value) {
+    this.queryParams.append("not", `${operator}:${column}:${value}`);
+    return this;
+  }
+  /**
+   * OR conditions
+   * @example .or('category.eq.Electronics,price.lt.100000')
+   */
+  or(conditions) {
+    this.queryParams.set("or", conditions);
+    return this;
+  }
+  /**
+   * Filter by array contained by
+   */
+  containedBy(column, value) {
+    this.queryParams.append("contained_by", `${column}:${JSON.stringify(value)}`);
     return this;
   }
   /**
@@ -118,7 +142,8 @@ var QueryBuilder = class {
     if (nullsFirst !== void 0) {
       orderStr += nullsFirst ? ".nullsfirst" : ".nullslast";
     }
-    this.queryParams.append("order", orderStr);
+    const existing = this.queryParams.get("order");
+    this.queryParams.set("order", existing ? `${existing},${orderStr}` : orderStr);
     return this;
   }
   /**
@@ -166,28 +191,36 @@ var QueryBuilder = class {
       ...this.headers
     };
   }
-  async request(method, body) {
-    const queryString = this.queryParams.toString();
-    const fullUrl = `${this.url}/rest/v1/${this.tableName}${queryString ? `?${queryString}` : ""}`;
-    const options = {
-      method,
-      headers: this.getHeaders()
-    };
-    if (body && method !== "GET") {
-      options.body = JSON.stringify(body);
-      options.headers["Prefer"] = "return=representation";
+  buildUrl() {
+    const qs = this.queryParams.toString();
+    if (this._isUpsert) {
+      const conflict = this._onConflict ? `?on_conflict=${this._onConflict}` : "";
+      return `${this.url}/api/${this.tableName}/upsert${conflict}`;
+    }
+    if ((this._method === "PATCH" || this._method === "DELETE") && this._idValue !== void 0) {
+      return `${this.url}/api/${this.tableName}/${this._idValue}/`;
+    }
+    return `${this.url}/api/${this.tableName}/${qs ? `?${qs}` : ""}`;
+  }
+  async execute() {
+    const fullUrl = this.buildUrl();
+    const reqHeaders = this.getHeaders();
+    const options = { method: this._method, headers: reqHeaders };
+    if (this._body !== void 0 && this._method !== "GET") {
+      options.body = JSON.stringify(this._body);
+      reqHeaders["Prefer"] = "return=representation";
     }
     try {
       const response = await fetch(fullUrl, options);
+      const text = await response.text();
       let data = null;
       let error = null;
-      const text = await response.text();
       if (text) {
         try {
           const parsed = JSON.parse(text);
           if (!response.ok) {
             error = {
-              message: parsed.message || parsed.error || `HTTP ${response.status}`,
+              message: parsed.message || parsed.error || parsed.detail || `HTTP ${response.status}`,
               code: parsed.code,
               details: parsed.details
             };
@@ -195,69 +228,49 @@ var QueryBuilder = class {
             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"
       };
     }
   }
-  /**
-   * Execute SELECT query
-   */
   async then(resolve, reject) {
     try {
-      const result = await this.request("GET");
+      const result = await this.execute();
       await resolve(result);
     } catch (err) {
-      if (reject) {
-        await reject(err);
-      }
+      if (reject) await reject(err);
     }
   }
-  /**
-   * Insert row(s)
-   */
-  async insert(row) {
+  insert(row) {
+    this._method = "POST";
     const rows = Array.isArray(row) ? row : [row];
-    return this.request("POST", rows.length === 1 ? rows[0] : rows);
+    this._body = rows.length === 1 ? rows[0] : rows;
+    return this;
   }
-  /**
-   * Update row(s)
-   */
-  async update(data) {
-    return this.request("PATCH", data);
+  update(data) {
+    this._method = "PATCH";
+    this._body = data;
+    return this;
   }
-  /**
-   * Upsert row(s)
-   */
-  async upsert(row) {
+  upsert(row, options = {}) {
+    this._method = "POST";
+    this._isUpsert = true;
+    this._onConflict = options.onConflict;
     const rows = Array.isArray(row) ? row : [row];
-    this.headers["Prefer"] = "resolution=merge-duplicates,return=representation";
-    return this.request("POST", rows.length === 1 ? rows[0] : rows);
+    this._body = rows.length === 1 ? rows[0] : rows;
+    return this;
   }
-  /**
-   * Delete row(s)
-   */
-  async delete() {
-    return this.request("DELETE");
+  delete() {
+    this._method = "DELETE";
+    return this;
   }
 };
 
@@ -557,7 +570,7 @@ var AuraBaseClient = class {
   async rpc(functionName, params) {
     const token = this.accessToken || this.anonKey;
     try {
-      const response = await fetch(`${this.url}/rpc/v1/${functionName}`, {
+      const response = await fetch(`${this.url}/api/${functionName}/`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -731,6 +744,23 @@ var StorageBucket = class {
 
 // src/index.ts
 function createClient(options) {
+  if (!options.url) {
+    console.warn(
+      "[aurabase-js] NEXT_PUBLIC_AURABASE_URL이 설정되지 않았습니다.\n" +
+      ".env.local 파일에 다음 항목을 추가하세요:\n\n" +
+      "  NEXT_PUBLIC_AURABASE_URL=https://your-project.cloudfront.net\n" +
+      "  NEXT_PUBLIC_AURABASE_ANON_KEY=your-anon-key\n" +
+      "  NEXT_PUBLIC_AURABASE_SERVICE_ROLE_KEY=your-service-role-key\n"
+    );
+  }
+  if (!options.anonKey) {
+    console.warn(
+      "[aurabase-js] anonKey가 설정되지 않았습니다.\n" +
+      ".env.local 파일에 다음 항목을 추가하세요:\n\n" +
+      "  NEXT_PUBLIC_AURABASE_ANON_KEY=your-anon-key          (클라이언트용)\n" +
+      "  NEXT_PUBLIC_AURABASE_SERVICE_ROLE_KEY=your-service-role-key  (서버/admin용)\n"
+    );
+  }
   return new AuraBaseClient(options);
 }
 var index_default = createClient;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "aurabase-js",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AuraBase client library - Supabase-style SDK for AuraBase",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "bin": {
+    "aurabase-js": "./dist/cli.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -13,16 +16,17 @@
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-    "prepublishOnly": "npm run build"
+    "build": "tsup src/index.ts --format cjs,esm --dts && tsup src/cli.ts --format cjs --no-dts",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "echo 'skipping build - dist already compiled'"
   },
   "keywords": [
     "aurabase",
     "database",
     "rest",
     "client",
-    "supabase-like"
+    "supabase-like",
+    "cli"
   ],
   "author": "",
   "license": "MIT",

package/src/AuraBaseClient.ts

@@ -46,18 +46,16 @@ export class AuraBaseClient {
   }
 
   /**
-   * Execute raw SQL (RPC function call)
-   * @example
-   * const { data, error } = await client.rpc('my_function', { arg1: 'value' })
+   * Call a serverless function
+   * POST /api/{functionName}/
    */
   async rpc<T = unknown>(
     functionName: string,
     params?: Record<string, unknown>
   ): Promise<{ data: T | null; error: { message: string } | null }> {
     const token = this.accessToken || this.anonKey;
-
     try {
-      const response = await fetch(`${this.url}/rpc/v1/${functionName}`, {
+      const response = await fetch(`${this.url}/api/${functionName}/`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -67,32 +65,24 @@ export class AuraBaseClient {
         },
         body: JSON.stringify(params || {}),
       });
-
       const text = await response.text();
       let data: T | null = null;
       let error: { message: string } | null = null;
-
       if (text) {
         try {
           const parsed = JSON.parse(text);
           if (!response.ok) {
-            error = { message: parsed.message || parsed.error || `HTTP ${response.status}` };
+            error = { message: parsed.message || parsed.error || parsed.detail || `HTTP ${response.status}` };
           } else {
             data = parsed;
           }
         } catch {
-          if (!response.ok) {
-            error = { message: text || `HTTP ${response.status}` };
-          }
+          if (!response.ok) error = { message: text || `HTTP ${response.status}` };
         }
       }
-
       return { data, error };
     } catch (err) {
-      return {
-        data: null,
-        error: { message: err instanceof Error ? err.message : 'Network error' },
-      };
+      return { data: null, error: { message: err instanceof Error ? err.message : 'Network error' } };
     }
   }