@fluxbase/sdk 0.0.1-rc.14 → 0.0.1-rc.16

package/dist/index.cjs

@@ -604,22 +604,55 @@ var RealtimeChannel = class {
   }
   /**
    * Subscribe to the channel
+   * @param callback - Optional status callback (Supabase-compatible)
+   * @param _timeout - Optional timeout in milliseconds (currently unused)
    */
-  subscribe() {
+  subscribe(callback, _timeout) {
     this.connect();
+    if (callback) {
+      const checkConnection = () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          callback("SUBSCRIBED");
+        } else if (this.ws && this.ws.readyState === WebSocket.CLOSED) {
+          callback("CHANNEL_ERROR", new Error("Failed to connect"));
+        } else {
+          setTimeout(checkConnection, 100);
+        }
+      };
+      setTimeout(checkConnection, 100);
+    }
     return this;
   }
   /**
    * Unsubscribe from the channel
-   */
-  unsubscribe() {
-    if (this.ws) {
-      this.send({
-        type: "unsubscribe",
-        channel: this.channelName
-      });
-      this.disconnect();
-    }
+   * @param timeout - Optional timeout in milliseconds
+   * @returns Promise resolving to status string (Supabase-compatible)
+   */
+  async unsubscribe(timeout) {
+    return new Promise((resolve) => {
+      if (this.ws) {
+        this.send({
+          type: "unsubscribe",
+          channel: this.channelName
+        });
+        const startTime = Date.now();
+        const maxWait = timeout || 5e3;
+        const checkDisconnect = () => {
+          if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            this.disconnect();
+            resolve("ok");
+          } else if (Date.now() - startTime > maxWait) {
+            this.disconnect();
+            resolve("timed out");
+          } else {
+            setTimeout(checkDisconnect, 100);
+          }
+        };
+        setTimeout(checkDisconnect, 100);
+      } else {
+        resolve("ok");
+      }
+    });
   }
   /**
    * Internal: Connect to WebSocket
@@ -708,13 +741,22 @@ var RealtimeChannel = class {
    * Internal: Handle broadcast message
    */
   handleBroadcast(payload) {
-    const callbacks = this.callbacks.get(payload.type);
+    const supabasePayload = {
+      eventType: payload.type || payload.eventType,
+      schema: payload.schema,
+      table: payload.table,
+      commit_timestamp: payload.timestamp || payload.commit_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      new: payload.new_record || payload.new || {},
+      old: payload.old_record || payload.old || {},
+      errors: payload.errors || null
+    };
+    const callbacks = this.callbacks.get(supabasePayload.eventType);
     if (callbacks) {
-      callbacks.forEach((callback) => callback(payload));
+      callbacks.forEach((callback) => callback(supabasePayload));
     }
     const wildcardCallbacks = this.callbacks.get("*");
     if (wildcardCallbacks) {
-      wildcardCallbacks.forEach((callback) => callback(payload));
+      wildcardCallbacks.forEach((callback) => callback(supabasePayload));
     }
   }
   /**
@@ -744,7 +786,9 @@ var RealtimeChannel = class {
     }
     this.reconnectAttempts++;
     const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-    console.log(`[Fluxbase Realtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    console.log(
+      `[Fluxbase Realtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`
+    );
     setTimeout(() => {
       this.connect();
     }, delay);
@@ -812,7 +856,7 @@ var StorageBucket = class {
       if (options?.upsert !== void 0) {
         formData.append("upsert", String(options.upsert));
       }
-      const data = await this.fetch.request(
+      const response = await this.fetch.request(
         `/api/v1/storage/${this.bucketName}/${path}`,
         {
           method: "POST",
@@ -821,7 +865,14 @@ var StorageBucket = class {
           // Let browser set Content-Type for FormData
         }
       );
-      return { data, error: null };
+      return {
+        data: {
+          id: response.id || response.key || path,
+          path,
+          fullPath: `${this.bucketName}/${path}`
+        },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -849,13 +900,24 @@ var StorageBucket = class {
   }
   /**
    * List files in the bucket
-   * @param options - List options (prefix, limit, offset)
+   * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
+   * @param pathOrOptions - The folder path or list options
+   * @param maybeOptions - List options when first param is a path
    */
-  async list(options) {
+  async list(pathOrOptions, maybeOptions) {
     try {
       const params = new URLSearchParams();
-      if (options?.prefix) {
-        params.set("prefix", options.prefix);
+      let prefix;
+      let options;
+      if (typeof pathOrOptions === "string") {
+        prefix = pathOrOptions;
+        options = maybeOptions;
+      } else {
+        options = pathOrOptions;
+        prefix = options?.prefix;
+      }
+      if (prefix) {
+        params.set("prefix", prefix);
       }
       if (options?.limit) {
         params.set("limit", String(options.limit));
@@ -865,8 +927,17 @@ var StorageBucket = class {
       }
       const queryString = params.toString();
       const path = `/api/v1/storage/${this.bucketName}${queryString ? `?${queryString}` : ""}`;
-      const data = await this.fetch.get(path);
-      return { data: data.files || [], error: null };
+      const response = await this.fetch.get(path);
+      const files = (response.files || []).map((file) => ({
+        name: file.key || file.name,
+        id: file.id,
+        bucket_id: file.bucket || this.bucketName,
+        created_at: file.last_modified || file.created_at,
+        updated_at: file.updated_at,
+        last_accessed_at: file.last_accessed_at,
+        metadata: file.metadata
+      }));
+      return { data: files, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -877,10 +948,15 @@ var StorageBucket = class {
    */
   async remove(paths) {
     try {
+      const removedFiles = [];
       for (const path of paths) {
         await this.fetch.delete(`/api/v1/storage/${this.bucketName}/${path}`);
+        removedFiles.push({
+          name: path,
+          bucket_id: this.bucketName
+        });
       }
-      return { data: null, error: null };
+      return { data: removedFiles, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -917,14 +993,17 @@ var StorageBucket = class {
    */
   async move(fromPath, toPath) {
     try {
-      const data = await this.fetch.post(
+      await this.fetch.post(
         `/api/v1/storage/${this.bucketName}/move`,
         {
           from_path: fromPath,
           to_path: toPath
         }
       );
-      return { data, error: null };
+      return {
+        data: { message: "Successfully moved" },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -936,14 +1015,17 @@ var StorageBucket = class {
    */
   async copy(fromPath, toPath) {
     try {
-      const data = await this.fetch.post(
+      await this.fetch.post(
         `/api/v1/storage/${this.bucketName}/copy`,
         {
           from_path: fromPath,
           to_path: toPath
         }
       );
-      return { data, error: null };
+      return {
+        data: { path: toPath },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -1026,7 +1108,7 @@ var FluxbaseStorage = class {
   async createBucket(bucketName) {
     try {
       await this.fetch.post(`/api/v1/storage/buckets/${bucketName}`);
-      return { data: null, error: null };
+      return { data: { name: bucketName }, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -1038,7 +1120,7 @@ var FluxbaseStorage = class {
   async deleteBucket(bucketName) {
     try {
       await this.fetch.delete(`/api/v1/storage/buckets/${bucketName}`);
-      return { data: null, error: null };
+      return { data: { message: "Successfully deleted" }, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -1055,13 +1137,13 @@ var FluxbaseStorage = class {
         return { data: null, error: listError };
       }
       if (objects && objects.length > 0) {
-        const paths = objects.map((obj) => obj.key);
+        const paths = objects.map((obj) => obj.name);
         const { error: removeError } = await bucket.remove(paths);
         if (removeError) {
           return { data: null, error: removeError };
         }
       }
-      return { data: null, error: null };
+      return { data: { message: "Successfully emptied" }, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -1095,6 +1177,208 @@ var FluxbaseStorage = class {
   }
 };
 
+// src/functions.ts
+var FluxbaseFunctions = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Invoke an edge function
+   *
+   * This method is fully compatible with Supabase's functions.invoke() API.
+   *
+   * @param functionName - The name of the function to invoke
+   * @param options - Invocation options including body, headers, and HTTP method
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * // Simple invocation
+   * const { data, error } = await client.functions.invoke('hello', {
+   *   body: { name: 'World' }
+   * })
+   *
+   * // With GET method
+   * const { data, error } = await client.functions.invoke('get-data', {
+   *   method: 'GET'
+   * })
+   *
+   * // With custom headers
+   * const { data, error } = await client.functions.invoke('api-proxy', {
+   *   body: { query: 'search' },
+   *   headers: { 'Authorization': 'Bearer token' },
+   *   method: 'POST'
+   * })
+   * ```
+   */
+  async invoke(functionName, options) {
+    try {
+      const method = options?.method || "POST";
+      const headers = options?.headers || {};
+      const body = options?.body;
+      const endpoint = `/api/v1/functions/${functionName}/invoke`;
+      let response;
+      switch (method) {
+        case "GET":
+          response = await this.fetch.get(endpoint, { headers });
+          break;
+        case "DELETE":
+          response = await this.fetch.delete(endpoint, { headers });
+          break;
+        case "PUT":
+          response = await this.fetch.put(endpoint, body, { headers });
+          break;
+        case "PATCH":
+          response = await this.fetch.patch(endpoint, body, { headers });
+          break;
+        case "POST":
+        default:
+          response = await this.fetch.post(endpoint, body, { headers });
+          break;
+      }
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new edge function
+   *
+   * @param request - Function configuration and code
+   * @returns Promise resolving to { data, error } tuple with created function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.create({
+   *   name: 'my-function',
+   *   code: 'export default async function handler(req) { return { hello: "world" } }',
+   *   enabled: true
+   * })
+   * ```
+   */
+  async create(request) {
+    try {
+      const data = await this.fetch.post("/api/v1/functions", request);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all edge functions
+   *
+   * @returns Promise resolving to { data, error } tuple with array of functions
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.list()
+   * if (data) {
+   *   console.log('Functions:', data.map(f => f.name))
+   * }
+   * ```
+   */
+  async list() {
+    try {
+      const data = await this.fetch.get("/api/v1/functions");
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific edge function
+   *
+   * @param name - Function name
+   * @returns Promise resolving to { data, error } tuple with function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.get('my-function')
+   * if (data) {
+   *   console.log('Function version:', data.version)
+   * }
+   * ```
+   */
+  async get(name) {
+    try {
+      const data = await this.fetch.get(`/api/v1/functions/${name}`);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an existing edge function
+   *
+   * @param name - Function name
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.update('my-function', {
+   *   enabled: false,
+   *   description: 'Updated description'
+   * })
+   * ```
+   */
+  async update(name, updates) {
+    try {
+      const data = await this.fetch.put(`/api/v1/functions/${name}`, updates);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete an edge function
+   *
+   * @param name - Function name
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.delete('my-function')
+   * ```
+   */
+  async delete(name) {
+    try {
+      await this.fetch.delete(`/api/v1/functions/${name}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution history for an edge function
+   *
+   * @param name - Function name
+   * @param limit - Maximum number of executions to return (optional)
+   * @returns Promise resolving to { data, error } tuple with execution records
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.getExecutions('my-function', 10)
+   * if (data) {
+   *   data.forEach(exec => {
+   *     console.log(`${exec.executed_at}: ${exec.status} (${exec.duration_ms}ms)`)
+   *   })
+   * }
+   * ```
+   */
+  async getExecutions(name, limit) {
+    try {
+      const params = limit ? `?limit=${limit}` : "";
+      const data = await this.fetch.get(
+        `/api/v1/functions/${name}/executions${params}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
 // src/settings.ts
 var SystemSettingsManager = class {
   constructor(fetch2) {
@@ -3684,8 +3968,12 @@ var FluxbaseClient = class {
     if (options.auth?.token) {
       this.fetch.setAuthToken(options.auth.token);
     }
-    this.realtime = new FluxbaseRealtime(options.url, options.auth?.token || null);
+    this.realtime = new FluxbaseRealtime(
+      options.url,
+      options.auth?.token || null
+    );
     this.storage = new FluxbaseStorage(this.fetch);
+    this.functions = new FluxbaseFunctions(this.fetch);
     this.admin = new FluxbaseAdmin(this.fetch);
     this.management = new FluxbaseManagement(this.fetch);
     this.setupAuthSync();
@@ -3740,7 +4028,10 @@ var FluxbaseClient = class {
    */
   async rpc(functionName, params) {
     try {
-      const data = await this.fetch.post(`/api/v1/rpc/${functionName}`, params || {});
+      const data = await this.fetch.post(
+        `/api/v1/rpc/${functionName}`,
+        params || {}
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -3780,6 +4071,36 @@ var FluxbaseClient = class {
     this.fetch.setAuthToken(token);
     this.realtime.setToken(token);
   }
+  /**
+   * Create or get a realtime channel (Supabase-compatible alias)
+   *
+   * This is a convenience method that delegates to client.realtime.channel().
+   * Both patterns work identically:
+   * - client.channel('room-1') - Supabase-style
+   * - client.realtime.channel('room-1') - Fluxbase-style
+   *
+   * @param name - Channel name
+   * @returns RealtimeChannel instance
+   *
+   * @example
+   * ```typescript
+   * // Supabase-compatible usage
+   * const channel = client.channel('room-1')
+   *   .on('postgres_changes', {
+   *     event: '*',
+   *     schema: 'public',
+   *     table: 'messages'
+   *   }, (payload) => {
+   *     console.log('Change:', payload)
+   *   })
+   *   .subscribe()
+   * ```
+   *
+   * @category Realtime
+   */
+  channel(name) {
+    return this.realtime.channel(name);
+  }
   /**
    * Get the internal HTTP client
    *
@@ -3812,6 +4133,7 @@ exports.FluxbaseAdmin = FluxbaseAdmin;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
+exports.FluxbaseFunctions = FluxbaseFunctions;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;
 exports.FluxbaseRealtime = FluxbaseRealtime;