@blinkdotnew/sdk 0.13.2 → 0.14.0

package/README.md

@@ -195,23 +195,31 @@ const unsubscribe = blink.auth.onAuthStateChanged((state) => {
 
 ### Database Operations
 
+**🎉 NEW: Automatic Case Conversion!**  
+The SDK now automatically converts between JavaScript camelCase and SQL snake_case:
+- **Write code in camelCase**: `userId`, `createdAt`, `isCompleted`
+- **Stored as snake_case**: `user_id`, `created_at`, `is_completed`
+- **No manual conversion needed!**
+
 ```typescript
 // Create (ID auto-generated if not provided)
 const todo = await blink.db.todos.create({
   id: 'todo_12345', // Optional - auto-generated if not provided
   title: 'Learn Blink SDK',
-  user_id: user.id
+  userId: user.id,        // camelCase in code
+  createdAt: new Date(),  // camelCase in code
+  isCompleted: false      // camelCase in code
 })
 
-// Read with filtering - returns a plain array of records
+// Read with filtering - returns camelCase fields
 const todos = await blink.db.todos.list({
   where: {
     AND: [
-      { user_id: user.id },
+      { userId: user.id },                    // camelCase in filters
       { OR: [{ status: 'open' }, { priority: 'high' }] }
     ]
   },
-  orderBy: { created_at: 'desc' },
+  orderBy: { createdAt: 'desc' },           // camelCase in orderBy
   limit: 20
 })
 // `todos` is a direct array: Todo[]

package/dist/index.js

@@ -67,6 +67,28 @@ var BlinkNotificationsError = class extends BlinkError {
 };
 
 // ../core/src/query-builder.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function convertFilterKeysToSnakeCase(condition) {
+  if (!condition) return condition;
+  if ("AND" in condition) {
+    return {
+      AND: condition.AND?.map(convertFilterKeysToSnakeCase)
+    };
+  }
+  if ("OR" in condition) {
+    return {
+      OR: condition.OR?.map(convertFilterKeysToSnakeCase)
+    };
+  }
+  const converted = {};
+  for (const [field, value] of Object.entries(condition)) {
+    const snakeField = camelToSnake(field);
+    converted[snakeField] = value;
+  }
+  return converted;
+}
 function buildFilterQuery(condition) {
   if (!condition) return "";
   if ("AND" in condition) {
@@ -140,12 +162,14 @@ function encodeQueryValue(value) {
 function buildQuery(options = {}) {
   const params = {};
   if (options.select && options.select.length > 0) {
-    params.select = options.select.join(",");
+    const snakeFields = options.select.map(camelToSnake);
+    params.select = snakeFields.join(",");
   } else {
     params.select = "*";
   }
   if (options.where) {
-    const filterQuery = buildFilterQuery(options.where);
+    const convertedWhere = convertFilterKeysToSnakeCase(options.where);
+    const filterQuery = buildFilterQuery(convertedWhere);
     if (filterQuery) {
       const filterParams = filterQuery.split("&");
       for (const param of filterParams) {
@@ -160,7 +184,7 @@ function buildQuery(options = {}) {
     if (typeof options.orderBy === "string") {
       params.order = options.orderBy;
     } else {
-      const orderClauses = Object.entries(options.orderBy).map(([field, direction]) => `${field}.${direction}`);
+      const orderClauses = Object.entries(options.orderBy).map(([field, direction]) => `${camelToSnake(field)}.${direction}`);
       params.order = orderClauses.join(",");
     }
   }
@@ -177,6 +201,34 @@ function buildQuery(options = {}) {
 }
 
 // ../core/src/http-client.ts
+function camelToSnake2(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(convertKeysToSnakeCase);
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake2(key);
+    converted[snakeKey] = convertKeysToSnakeCase(value);
+  }
+  return converted;
+}
+function convertKeysToCamelCase(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(convertKeysToCamelCase);
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel(key);
+    converted[camelKey] = convertKeysToCamelCase(value);
+  }
+  return converted;
+}
 var HttpClient = class {
   authUrl = "https://blink.new";
   coreUrl = "https://core.blink.new";
@@ -260,45 +312,86 @@ var HttpClient = class {
    */
   // Table operations (PostgREST-compatible)
   async dbGet(table, searchParams) {
-    return this.get(`/api/db/${this.projectId}/rest/v1/${table}`, searchParams);
+    const response = await this.get(`/api/db/${this.projectId}/rest/v1/${table}`, searchParams);
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbPost(table, body, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.post(`/api/db/${this.projectId}/rest/v1/${table}`, body, headers);
+    const convertedBody = convertKeysToSnakeCase(body);
+    const response = await this.post(`/api/db/${this.projectId}/rest/v1/${table}`, convertedBody, headers);
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbPatch(table, body, searchParams, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+    const convertedBody = convertKeysToSnakeCase(body);
+    const response = await this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
       method: "PATCH",
-      body,
+      body: convertedBody,
       headers,
       searchParams
     });
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbDelete(table, searchParams, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+    const response = await this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
       method: "DELETE",
       headers,
       searchParams
     });
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   // Raw SQL operations
   async dbSql(query, params) {
-    return this.post(`/api/db/${this.projectId}/sql`, { query, params });
+    const response = await this.post(`/api/db/${this.projectId}/sql`, { query, params });
+    const convertedData = {
+      ...response.data,
+      rows: convertKeysToCamelCase(response.data.rows)
+    };
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   // Batch SQL operations
   async dbBatch(statements, mode = "write") {
-    return this.post(`/api/db/${this.projectId}/batch`, { statements, mode });
+    const response = await this.post(`/api/db/${this.projectId}/batch`, { statements, mode });
+    const convertedData = {
+      ...response.data,
+      results: response.data.results.map((result) => ({
+        ...result,
+        rows: convertKeysToCamelCase(result.rows)
+      }))
+    };
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   /**
    * Upload file with progress tracking

package/dist/index.mjs

@@ -65,6 +65,28 @@ var BlinkNotificationsError = class extends BlinkError {
 };
 
 // ../core/src/query-builder.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function convertFilterKeysToSnakeCase(condition) {
+  if (!condition) return condition;
+  if ("AND" in condition) {
+    return {
+      AND: condition.AND?.map(convertFilterKeysToSnakeCase)
+    };
+  }
+  if ("OR" in condition) {
+    return {
+      OR: condition.OR?.map(convertFilterKeysToSnakeCase)
+    };
+  }
+  const converted = {};
+  for (const [field, value] of Object.entries(condition)) {
+    const snakeField = camelToSnake(field);
+    converted[snakeField] = value;
+  }
+  return converted;
+}
 function buildFilterQuery(condition) {
   if (!condition) return "";
   if ("AND" in condition) {
@@ -138,12 +160,14 @@ function encodeQueryValue(value) {
 function buildQuery(options = {}) {
   const params = {};
   if (options.select && options.select.length > 0) {
-    params.select = options.select.join(",");
+    const snakeFields = options.select.map(camelToSnake);
+    params.select = snakeFields.join(",");
   } else {
     params.select = "*";
   }
   if (options.where) {
-    const filterQuery = buildFilterQuery(options.where);
+    const convertedWhere = convertFilterKeysToSnakeCase(options.where);
+    const filterQuery = buildFilterQuery(convertedWhere);
     if (filterQuery) {
       const filterParams = filterQuery.split("&");
       for (const param of filterParams) {
@@ -158,7 +182,7 @@ function buildQuery(options = {}) {
     if (typeof options.orderBy === "string") {
       params.order = options.orderBy;
     } else {
-      const orderClauses = Object.entries(options.orderBy).map(([field, direction]) => `${field}.${direction}`);
+      const orderClauses = Object.entries(options.orderBy).map(([field, direction]) => `${camelToSnake(field)}.${direction}`);
       params.order = orderClauses.join(",");
     }
   }
@@ -175,6 +199,34 @@ function buildQuery(options = {}) {
 }
 
 // ../core/src/http-client.ts
+function camelToSnake2(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(convertKeysToSnakeCase);
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake2(key);
+    converted[snakeKey] = convertKeysToSnakeCase(value);
+  }
+  return converted;
+}
+function convertKeysToCamelCase(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(convertKeysToCamelCase);
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel(key);
+    converted[camelKey] = convertKeysToCamelCase(value);
+  }
+  return converted;
+}
 var HttpClient = class {
   authUrl = "https://blink.new";
   coreUrl = "https://core.blink.new";
@@ -258,45 +310,86 @@ var HttpClient = class {
    */
   // Table operations (PostgREST-compatible)
   async dbGet(table, searchParams) {
-    return this.get(`/api/db/${this.projectId}/rest/v1/${table}`, searchParams);
+    const response = await this.get(`/api/db/${this.projectId}/rest/v1/${table}`, searchParams);
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbPost(table, body, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.post(`/api/db/${this.projectId}/rest/v1/${table}`, body, headers);
+    const convertedBody = convertKeysToSnakeCase(body);
+    const response = await this.post(`/api/db/${this.projectId}/rest/v1/${table}`, convertedBody, headers);
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbPatch(table, body, searchParams, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+    const convertedBody = convertKeysToSnakeCase(body);
+    const response = await this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
       method: "PATCH",
-      body,
+      body: convertedBody,
       headers,
       searchParams
     });
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   async dbDelete(table, searchParams, options = {}) {
     const headers = {};
     if (options.returning) {
       headers.Prefer = "return=representation";
     }
-    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+    const response = await this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
       method: "DELETE",
       headers,
       searchParams
     });
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   // Raw SQL operations
   async dbSql(query, params) {
-    return this.post(`/api/db/${this.projectId}/sql`, { query, params });
+    const response = await this.post(`/api/db/${this.projectId}/sql`, { query, params });
+    const convertedData = {
+      ...response.data,
+      rows: convertKeysToCamelCase(response.data.rows)
+    };
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   // Batch SQL operations
   async dbBatch(statements, mode = "write") {
-    return this.post(`/api/db/${this.projectId}/batch`, { statements, mode });
+    const response = await this.post(`/api/db/${this.projectId}/batch`, { statements, mode });
+    const convertedData = {
+      ...response.data,
+      results: response.data.results.map((result) => ({
+        ...result,
+        rows: convertKeysToCamelCase(result.rows)
+      }))
+    };
+    return {
+      ...response,
+      data: convertedData
+    };
   }
   /**
    * Upload file with progress tracking

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinkdotnew/sdk",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Blink TypeScript SDK for client-side applications - Zero-boilerplate CRUD + auth + AI + analytics + notifications for modern SaaS/AI apps",
   "keywords": [
     "blink",