@tspvivek/baasix-sdk 0.1.0-alpha.9 → 0.1.1

package/README.md

@@ -558,6 +558,7 @@ await baasix.schemas.create({
 
 ```typescript
 // Many-to-One (BelongsTo)
+// Auto-creates index on foreign key column
 await baasix.schemas.createRelationship('products', {
   type: 'M2O',
   target: 'categories',
@@ -566,14 +567,40 @@ await baasix.schemas.createRelationship('products', {
 });
 
 // Many-to-Many
+// Auto-generates junction table: products_tags_tags_junction
 await baasix.schemas.createRelationship('products', {
   type: 'M2M',
   target: 'tags',
   name: 'tags',
   alias: 'products',
 });
+
+// Many-to-Many with custom junction table name
+// Useful when auto-generated name exceeds PostgreSQL's 63 char limit
+await baasix.schemas.createRelationship('products', {
+  type: 'M2M',
+  target: 'tags',
+  name: 'tags',
+  alias: 'products',
+  through: 'product_tags', // Custom junction table name (max 63 chars)
+});
+
+// Many-to-Any (Polymorphic)
+await baasix.schemas.createRelationship('comments', {
+  type: 'M2A',
+  name: 'commentable',
+  tables: ['posts', 'products'],
+  alias: 'comments',
+  through: 'comment_refs', // Optional custom junction table name
+});
 ```
 
+#### Junction Tables (M2M/M2A)
+- **Auto-generated name**: `{source}_{target}_{name}_junction`
+- **Custom name**: Use `through` property (max 63 characters for PostgreSQL)
+- **Schema property**: Junction tables have `isJunction: true` in their schema
+- **Auto-indexed**: Foreign key columns are automatically indexed
+
 ### Indexes
 
 ```typescript

package/dist/{client-B7CU_tr7.d.ts → client-DeXa-R9w.d.ts}

@@ -374,6 +374,11 @@ interface SchemaDefinition {
     name: string;
     timestamps?: boolean;
     paranoid?: boolean;
+    /**
+     * True for M2M/M2A junction tables (system-generated)
+     * Junction tables are auto-created when defining M2M or M2A relationships
+     */
+    isJunction?: boolean;
     fields: Record<string, FieldDefinition>;
     indexes?: IndexDefinition[];
 }
@@ -390,8 +395,15 @@ interface RelationshipDefinition {
     target: string;
     name: string;
     alias?: string;
+    /**
+     * Custom junction table name for M2M/M2A relationships (max 63 chars for PostgreSQL)
+     * If not provided, auto-generated as: {source}_{target}_{name}_junction
+     * @example "product_tags" or "comment_refs"
+     */
+    through?: string;
     onDelete?: "CASCADE" | "RESTRICT" | "SET NULL";
     onUpdate?: "CASCADE" | "RESTRICT" | "SET NULL";
+    /** Target tables for M2A (polymorphic) relationships */
     tables?: string[];
 }
 interface SchemaInfo {
@@ -425,6 +437,8 @@ interface UploadOptions {
     isPublic?: boolean;
     metadata?: Record<string, unknown>;
     onProgress?: (progress: number) => void;
+    /** Request timeout in milliseconds (default: 30000). Set to 0 for no timeout. */
+    timeout?: number;
 }
 interface AssetTransformOptions {
     width?: number;

package/dist/{client-BCNmu9xC.d.cts → client-VT7NckyI.d.cts}

@@ -374,6 +374,11 @@ interface SchemaDefinition {
     name: string;
     timestamps?: boolean;
     paranoid?: boolean;
+    /**
+     * True for M2M/M2A junction tables (system-generated)
+     * Junction tables are auto-created when defining M2M or M2A relationships
+     */
+    isJunction?: boolean;
     fields: Record<string, FieldDefinition>;
     indexes?: IndexDefinition[];
 }
@@ -390,8 +395,15 @@ interface RelationshipDefinition {
     target: string;
     name: string;
     alias?: string;
+    /**
+     * Custom junction table name for M2M/M2A relationships (max 63 chars for PostgreSQL)
+     * If not provided, auto-generated as: {source}_{target}_{name}_junction
+     * @example "product_tags" or "comment_refs"
+     */
+    through?: string;
     onDelete?: "CASCADE" | "RESTRICT" | "SET NULL";
     onUpdate?: "CASCADE" | "RESTRICT" | "SET NULL";
+    /** Target tables for M2A (polymorphic) relationships */
     tables?: string[];
 }
 interface SchemaInfo {
@@ -425,6 +437,8 @@ interface UploadOptions {
     isPublic?: boolean;
     metadata?: Record<string, unknown>;
     onProgress?: (progress: number) => void;
+    /** Request timeout in milliseconds (default: 30000). Set to 0 for no timeout. */
+    timeout?: number;
 }
 interface AssetTransformOptions {
     width?: number;

package/dist/index.cjs

@@ -1770,7 +1770,10 @@ var FilesModule = class {
     const response = await this.client.upload(
       "/files",
       formData,
-      { onProgress: options?.onProgress }
+      {
+        onProgress: options?.onProgress,
+        timeout: options?.timeout
+      }
     );
     return response.data;
   }
@@ -3030,6 +3033,9 @@ var RealtimeModule = class {
   socketPath;
   subscriptions = /* @__PURE__ */ new Map();
   workflowCallbacks = /* @__PURE__ */ new Map();
+  roomCallbacks = /* @__PURE__ */ new Map();
+  // room -> event -> callbacks
+  roomUserCallbacks = /* @__PURE__ */ new Map();
   connectionCallbacks = /* @__PURE__ */ new Set();
   reconnecting = false;
   connectionPromise = null;
@@ -3037,7 +3043,7 @@ var RealtimeModule = class {
     this.client = config.client;
     this.storage = config.storage;
     this.socketUrl = config.socketUrl || "";
-    this.socketPath = config.socketPath || "/socket";
+    this.socketPath = config.socketPath || "/realtime";
   }
   /**
    * Set the socket.io client instance
@@ -3139,6 +3145,26 @@ var RealtimeModule = class {
         this.socket.on("workflow:execution:complete", (data) => {
           this.handleWorkflowUpdate({ ...data, status: "complete" });
         });
+        this.socket.on("room:user:joined", (data) => {
+          const callbacks = this.roomUserCallbacks.get(data.room);
+          callbacks?.joined.forEach((cb) => {
+            try {
+              cb(data);
+            } catch (e) {
+              console.error("[Baasix Realtime] Error in room user joined callback:", e);
+            }
+          });
+        });
+        this.socket.on("room:user:left", (data) => {
+          const callbacks = this.roomUserCallbacks.get(data.room);
+          callbacks?.left.forEach((cb) => {
+            try {
+              cb(data);
+            } catch (e) {
+              console.error("[Baasix Realtime] Error in room user left callback:", e);
+            }
+          });
+        });
         this.socket.connect();
       } catch (error) {
         this.connectionPromise = null;
@@ -3166,6 +3192,8 @@ var RealtimeModule = class {
     }
     this.subscriptions.clear();
     this.workflowCallbacks.clear();
+    this.roomCallbacks.clear();
+    this.roomUserCallbacks.clear();
   }
   /**
    * Check if connected to the realtime server
@@ -3382,6 +3410,214 @@ var RealtimeModule = class {
     }
   }
   // ===================
+  // Custom Rooms API
+  // ===================
+  /**
+   * Join a custom room for real-time communication
+   * 
+   * @example
+   * ```typescript
+   * // Join a room
+   * await baasix.realtime.joinRoom('game:lobby');
+   * 
+   * // Listen for messages
+   * baasix.realtime.onRoomMessage('game:lobby', 'chat', (data) => {
+   *   console.log(`${data.sender.userId}: ${data.payload.text}`);
+   * });
+   * ```
+   */
+  async joinRoom(roomName) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("room:join", { room: roomName }, (response) => {
+        if (response.status === "success") {
+          this.setupRoomListeners(roomName);
+          resolve();
+        } else {
+          reject(new Error(response.message || "Failed to join room"));
+        }
+      });
+    });
+  }
+  /**
+   * Leave a custom room
+   * 
+   * @example
+   * ```typescript
+   * await baasix.realtime.leaveRoom('game:lobby');
+   * ```
+   */
+  async leaveRoom(roomName) {
+    if (!this.socket?.connected) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("room:leave", { room: roomName }, (response) => {
+        if (response.status === "success") {
+          this.cleanupRoomListeners(roomName);
+          resolve();
+        } else {
+          reject(new Error(response.message || "Failed to leave room"));
+        }
+      });
+    });
+  }
+  /**
+   * Send a message to a room
+   * 
+   * @example
+   * ```typescript
+   * // Send a chat message
+   * await baasix.realtime.sendToRoom('game:lobby', 'chat', { text: 'Hello!' });
+   * 
+   * // Send a game event
+   * await baasix.realtime.sendToRoom('game:123', 'move', { x: 10, y: 20 });
+   * ```
+   */
+  async sendToRoom(roomName, event, payload) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit(
+        "room:message",
+        { room: roomName, event, payload },
+        (response) => {
+          if (response.status === "success") {
+            resolve();
+          } else {
+            reject(new Error(response.message || "Failed to send message"));
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Listen for messages in a room with a specific event type
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = baasix.realtime.onRoomMessage('game:lobby', 'chat', (data) => {
+   *   console.log(`${data.sender.userId}: ${data.payload.text}`);
+   * });
+   * 
+   * // Later
+   * unsubscribe();
+   * ```
+   */
+  onRoomMessage(roomName, event, callback) {
+    if (!this.roomCallbacks.has(roomName)) {
+      this.roomCallbacks.set(roomName, /* @__PURE__ */ new Map());
+    }
+    const roomEvents = this.roomCallbacks.get(roomName);
+    if (!roomEvents.has(event)) {
+      roomEvents.set(event, /* @__PURE__ */ new Set());
+    }
+    roomEvents.get(event).add(callback);
+    return () => {
+      const events = this.roomCallbacks.get(roomName);
+      if (events) {
+        const callbacks = events.get(event);
+        if (callbacks) {
+          callbacks.delete(callback);
+          if (callbacks.size === 0) {
+            events.delete(event);
+          }
+        }
+        if (events.size === 0) {
+          this.roomCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * Listen for users joining a room
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = baasix.realtime.onRoomUserJoined('game:lobby', (data) => {
+   *   console.log(`User ${data.userId} joined the room`);
+   * });
+   * ```
+   */
+  onRoomUserJoined(roomName, callback) {
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+    this.roomUserCallbacks.get(roomName).joined.add(callback);
+    return () => {
+      const callbacks = this.roomUserCallbacks.get(roomName);
+      if (callbacks) {
+        callbacks.joined.delete(callback);
+        if (callbacks.joined.size === 0 && callbacks.left.size === 0) {
+          this.roomUserCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * Listen for users leaving a room
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = baasix.realtime.onRoomUserLeft('game:lobby', (data) => {
+   *   console.log(`User ${data.userId} left the room`);
+   * });
+   * ```
+   */
+  onRoomUserLeft(roomName, callback) {
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+    this.roomUserCallbacks.get(roomName).left.add(callback);
+    return () => {
+      const callbacks = this.roomUserCallbacks.get(roomName);
+      if (callbacks) {
+        callbacks.left.delete(callback);
+        if (callbacks.joined.size === 0 && callbacks.left.size === 0) {
+          this.roomUserCallbacks.delete(roomName);
+        }
+      }
+    };
+  }
+  /**
+   * Invoke a custom server-side handler
+   * 
+   * @example
+   * ```typescript
+   * const result = await baasix.realtime.invoke('game:roll-dice', { sides: 6 });
+   * console.log('Dice result:', result);
+   * ```
+   */
+  async invoke(event, payload) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket.emit("custom", { event, payload }, (response) => {
+        if (response.status === "success") {
+          resolve(response);
+        } else {
+          reject(new Error(response.message || "Custom event failed"));
+        }
+      });
+    });
+  }
+  setupRoomListeners(roomName) {
+    if (!this.roomCallbacks.has(roomName)) {
+      this.roomCallbacks.set(roomName, /* @__PURE__ */ new Map());
+    }
+    if (!this.roomUserCallbacks.has(roomName)) {
+      this.roomUserCallbacks.set(roomName, { joined: /* @__PURE__ */ new Set(), left: /* @__PURE__ */ new Set() });
+    }
+  }
+  cleanupRoomListeners(roomName) {
+    this.roomCallbacks.delete(roomName);
+    this.roomUserCallbacks.delete(roomName);
+  }
+  // ===================
   // Channel (Room) API - Supabase-style
   // ===================
   /**
@@ -4097,7 +4333,8 @@ var Baasix = class {
       ...config,
       url: normalizedUrl,
       authMode: config.authMode || "jwt",
-      timeout: config.timeout || 3e4,
+      timeout: config.timeout || 6e5,
+      // 10 minutes default
       autoRefresh: config.autoRefresh !== false
     };
     this.storage = config.storage || getDefaultStorage();