@pol-studios/db 1.0.54 → 1.0.56

package/dist/{chunk-BZSAPFFB.js → chunk-N4KK5G5T.js}

@@ -3,17 +3,20 @@ import {
   createAdapterRegistry,
   createSupabaseAdapter,
   stripSchemaPrefix
-} from "./chunk-2XS2PM62.js";
+} from "./chunk-DDL63KLQ.js";
 import {
   DataLayerContext,
   DataLayerCoreContext,
+  DataLayerNestingContext,
   DataLayerStatusContext
-} from "./chunk-WQLIGVQR.js";
+} from "./chunk-GWYTROSD.js";
+import {
+  QueryExecutor
+} from "./chunk-YRIPM2AN.js";
 import {
-  QueryExecutor,
   extractRelationNames,
   parseSelect
-} from "./chunk-HZIVE5AZ.js";
+} from "./chunk-W7PERM66.js";
 import {
   useSupabase
 } from "./chunk-DMVUEJG2.js";
@@ -1104,19 +1107,27 @@ function transformWithRelations(row, schema, tableName) {
 }
 
 // src/adapters/powersync-adapter.ts
+import stringify from "fast-json-stable-stringify";
+var DEFAULT_MAX_SUBSCRIPTIONS = 100;
 var PowerSyncAdapter = class {
   /**
    * Create a new PowerSyncAdapter
    *
    * @param db - PowerSync database instance
    * @param schema - Database schema for relationship resolution
-   * @param tableNameResolver - Optional custom resolver for table names to PowerSync aliases
+   * @param options - Optional configuration (tableNameResolver, maxSubscriptions)
    */
-  constructor(db, schema, tableNameResolver) {
+  constructor(db, schema, options) {
     this.db = db;
     this.schema = schema;
     this.executor = new QueryExecutor(db, schema);
-    this.tableNameResolver = tableNameResolver;
+    if (typeof options === "function") {
+      this.tableNameResolver = options;
+      this.maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS;
+    } else {
+      this.tableNameResolver = options?.tableNameResolver;
+      this.maxSubscriptions = options?.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS;
+    }
   }
   /**
    * Unique identifier for this adapter type
@@ -1140,6 +1151,31 @@ var PowerSyncAdapter = class {
    * If not provided, uses default auto-alias generation.
    */
   tableNameResolver;
+  /**
+   * Maximum number of subscriptions to keep in the registry.
+   */
+  maxSubscriptions;
+  /**
+   * Subscription deduplication registry.
+   * Maps cache keys (table + serialized options) to shared subscription entries.
+   * This prevents duplicate PowerSync watch() calls when multiple components
+   * subscribe to the same query.
+   *
+   * Uses Map insertion order for LRU eviction - most recently accessed entries
+   * are moved to the end by deleting and re-adding.
+   */
+  subscriptionRegistry = /* @__PURE__ */ new Map();
+  /**
+   * Move a subscription entry to the end of the Map for LRU tracking.
+   * The most recently accessed entries are at the end; oldest are at the start.
+   *
+   * @param key - The subscription cache key
+   * @param entry - The subscription entry to touch
+   */
+  touchSubscription(key, entry) {
+    this.subscriptionRegistry.delete(key);
+    this.subscriptionRegistry.set(key, entry);
+  }
   /**
    * Resolve a table name to its PowerSync alias.
    * Schema-qualified names like "chat.Conversation" become "Conversation" (schema stripped).
@@ -1193,12 +1229,31 @@ var PowerSyncAdapter = class {
     }
     return transformWithRelations(rawResult, this.schema, table);
   }
+  /**
+   * Generate a unique cache key for subscription deduplication.
+   * Combines table name and serialized options to identify identical queries.
+   * Uses sorted keys to ensure consistent serialization regardless of property order.
+   *
+   * @param table - The table name
+   * @param options - Query options
+   * @returns A unique string key for the subscription registry
+   */
+  generateSubscriptionKey(table, options) {
+    return `${table}:${stringify(options)}`;
+  }
   /**
    * Subscribe to changes on a query using PowerSync's native watch() API.
    *
    * This uses PowerSync's reactive query watching which efficiently detects
    * changes to the underlying data and re-executes the query only when needed.
    *
+   * Subscription Deduplication:
+   * Multiple components subscribing to the same query (same table + options)
+   * will share a single underlying PowerSync watch. This optimization:
+   * - Reduces database load by avoiding duplicate watches
+   * - Provides instant data to new subscribers from cached results
+   * - Properly cleans up when all subscribers unsubscribe
+   *
    * If the database doesn't support watch(), falls back to polling every 5 seconds.
    *
    * @param table - The table name to watch
@@ -1211,6 +1266,33 @@ var PowerSyncAdapter = class {
     if (!this.db.watch) {
       return this.subscribeWithPolling(table, options, callback);
     }
+    const cacheKey = this.generateSubscriptionKey(resolvedTable, options);
+    const existingEntry = this.subscriptionRegistry.get(cacheKey);
+    if (existingEntry) {
+      existingEntry.subscribers.add(callback);
+      this.touchSubscription(cacheKey, existingEntry);
+      return () => {
+        existingEntry.subscribers.delete(callback);
+        if (existingEntry.subscribers.size === 0) {
+          existingEntry.unsubscribe();
+          this.subscriptionRegistry.delete(cacheKey);
+        }
+      };
+    }
+    if (this.subscriptionRegistry.size >= this.maxSubscriptions) {
+      let evicted = false;
+      for (const [key, entry2] of this.subscriptionRegistry) {
+        if (entry2.subscribers.size === 0) {
+          entry2.unsubscribe();
+          this.subscriptionRegistry.delete(key);
+          evicted = true;
+          break;
+        }
+      }
+      if (!evicted && typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(`[PowerSyncAdapter] Subscription registry exceeded max (${this.maxSubscriptions}) but all entries have active subscribers. Registry size: ${this.subscriptionRegistry.size + 1}`);
+      }
+    }
     const abortController = new AbortController();
     const parsed = parseSelect(options.select ?? "*");
     const builder = this.executor.getBuilder();
@@ -1225,16 +1307,22 @@ var PowerSyncAdapter = class {
     });
     let watchTables = [resolvedTable];
     if (options.select && options.select !== "*") {
-      const parsed2 = parseSelect(options.select);
-      const relationNames = extractRelationNames(parsed2);
+      const relationNames = extractRelationNames(parsed);
       watchTables = [resolvedTable, ...relationNames.map((r) => this.resolveTableName(r))];
     }
+    const entry = {
+      subscribers: /* @__PURE__ */ new Set([callback]),
+      unsubscribe: () => abortController.abort()
+    };
+    this.subscriptionRegistry.set(cacheKey, entry);
     const schema = this.schema;
     this.db.watch(sql, params, {
       onResult: (results) => {
         const rawData = results.rows?._array ?? [];
         const data = transformResultsFromStorage(rawData, schema, table);
-        callback(data);
+        for (const subscriber of entry.subscribers) {
+          subscriber(data);
+        }
       },
       onError: (error) => {
         console.error(`PowerSync subscription error for ${resolvedTable}:`, error);
@@ -1246,7 +1334,11 @@ var PowerSyncAdapter = class {
       // Throttle to prevent excessive re-queries
     });
     return () => {
-      abortController.abort();
+      entry.subscribers.delete(callback);
+      if (entry.subscribers.size === 0) {
+        entry.unsubscribe();
+        this.subscriptionRegistry.delete(cacheKey);
+      }
     };
   }
   /**
@@ -1407,7 +1499,7 @@ function createPowerSyncAdapter(db, schema) {
 }
 
 // src/providers/DataLayerProvider.tsx
-import { useState, useEffect, useMemo, useCallback, useRef } from "react";
+import { useState, useEffect, useMemo, useCallback, useRef, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
 var defaultSyncStatus = {
   isConnected: false,
@@ -1454,6 +1546,12 @@ function DataLayerProvider({
   powerSyncSyncStatus,
   syncControl: externalSyncControl
 }) {
+  const isNested = useContext(DataLayerNestingContext);
+  const hasWarnedNesting = useRef(false);
+  if (isNested && !hasWarnedNesting.current && typeof __DEV__ !== "undefined" && __DEV__) {
+    hasWarnedNesting.current = true;
+    console.warn("[DataLayerProvider] Nested DataLayerProvider detected! This usually indicates a setup issue where DataLayerProvider is wrapped twice. Each DataLayerProvider creates its own registry, which can cause:\n  - Queries using wrong adapter (e.g., Supabase instead of PowerSync)\n  - Inconsistent cache state\n  - Unexpected behavior with sync status\n\nCommon causes:\n  - Using both DataLayerWrapper and OfflineDataProvider (OfflineDataProvider already includes DataLayerProvider)\n  - Accidentally wrapping layout twice\n\nFix: Remove the outer DataLayerProvider wrapper.");
+  }
   const [registry] = useState(() => createAdapterRegistry(config));
   const powerSyncInstanceRef = useRef(powerSyncInstance);
   powerSyncInstanceRef.current = powerSyncInstance;
@@ -1699,7 +1797,7 @@ function DataLayerProvider({
   const resolvedCore = coreContextValue ?? pendingCoreContextValue;
   const resolvedStatus = statusContextValue ?? pendingStatusContextValue;
   const resolvedContext = contextValue ?? pendingContextValue;
-  return /* @__PURE__ */ jsx(DataLayerContext.Provider, { value: resolvedContext, children: /* @__PURE__ */ jsx(DataLayerCoreContext.Provider, { value: resolvedCore, children: /* @__PURE__ */ jsx(DataLayerStatusContext.Provider, { value: resolvedStatus, children }) }) });
+  return /* @__PURE__ */ jsx(DataLayerNestingContext.Provider, { value: true, children: /* @__PURE__ */ jsx(DataLayerContext.Provider, { value: resolvedContext, children: /* @__PURE__ */ jsx(DataLayerCoreContext.Provider, { value: resolvedCore, children: /* @__PURE__ */ jsx(DataLayerStatusContext.Provider, { value: resolvedStatus, children }) }) }) });
 }
 
 // src/storage/use-supabase-upload.tsx
@@ -4630,9 +4728,9 @@ function _temp(err) {
 
 // src/conflicts/useConflictState.ts
 import { c as _c2 } from "react/compiler-runtime";
-import { useContext } from "react";
+import { useContext as useContext2 } from "react";
 function useConflictState() {
-  const context = useContext(ConflictContext);
+  const context = useContext2(ConflictContext);
   if (!context) {
     throw new Error("useConflictState must be used within a ConflictProvider. Wrap your app with <ConflictProvider> to enable conflict management.");
   }
@@ -4640,7 +4738,7 @@ function useConflictState() {
 }
 function usePendingConflicts() {
   const $ = _c2(2);
-  const context = useContext(ConflictContext);
+  const context = useContext2(ConflictContext);
   let t0;
   if ($[0] !== context?.pendingConflicts) {
     t0 = context?.pendingConflicts ?? [];
@@ -4652,7 +4750,7 @@ function usePendingConflicts() {
   return t0;
 }
 function useHasConflicts() {
-  const context = useContext(ConflictContext);
+  const context = useContext2(ConflictContext);
   return context?.hasConflicts ?? false;
 }
 function useConflictForRecord(table, recordId) {
@@ -4968,4 +5066,4 @@ object-assign/index.js:
   @license MIT
   *)
 */
-//# sourceMappingURL=chunk-BZSAPFFB.js.map
+//# sourceMappingURL=chunk-N4KK5G5T.js.map