pbtsdb 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,9 +1,106 @@
-import { createCollection } from '@tanstack/db';
+import { createCollection as createCollection$1 } from '@tanstack/react-db';
 import { queryCollectionOptions } from '@tanstack/query-db-collection';
+import { parseWhereExpression, parseOrderByExpression } from '@tanstack/db';
 import { createContext, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // src/collection.ts
+function escapeValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  if (value instanceof Date) {
+    return `"${value.toISOString()}"`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(escapeValue).join(",")}]`;
+  }
+  return `"${String(value)}"`;
+}
+function fieldPathToString(path) {
+  return path.join(".");
+}
+function convertToPocketBaseFilter(where) {
+  if (!where) {
+    return void 0;
+  }
+  const result = parseWhereExpression(where, {
+    handlers: {
+      eq: (field, value) => {
+        return `${fieldPathToString(field)} = ${escapeValue(value)}`;
+      },
+      gt: (field, value) => {
+        return `${fieldPathToString(field)} > ${escapeValue(value)}`;
+      },
+      gte: (field, value) => {
+        return `${fieldPathToString(field)} >= ${escapeValue(value)}`;
+      },
+      lt: (field, value) => {
+        return `${fieldPathToString(field)} < ${escapeValue(value)}`;
+      },
+      lte: (field, value) => {
+        return `${fieldPathToString(field)} <= ${escapeValue(value)}`;
+      },
+      and: (...conditions) => {
+        if (conditions.length === 0) return "";
+        if (conditions.length === 1) return conditions[0];
+        return `(${conditions.join(" && ")})`;
+      },
+      or: (...conditions) => {
+        if (conditions.length === 0) return "";
+        if (conditions.length === 1) return conditions[0];
+        return `(${conditions.join(" || ")})`;
+      },
+      not: (condition) => {
+        return `!(${condition})`;
+      },
+      in: (field, values) => {
+        const valueArray = Array.isArray(values) ? values : [values];
+        const uniqueValues = [...new Set(valueArray)];
+        const fieldStr = fieldPathToString(field);
+        const conditions = uniqueValues.map((v) => `${fieldStr} = ${escapeValue(v)}`);
+        return conditions.length > 1 ? `(${conditions.join(" || ")})` : conditions[0];
+      },
+      like: (field, value) => {
+        return `${fieldPathToString(field)} ~ ${escapeValue(value)}`;
+      },
+      isNull: (field) => {
+        return `${fieldPathToString(field)} = null`;
+      },
+      isUndefined: (field) => {
+        return `${fieldPathToString(field)} = null`;
+      }
+    },
+    onUnknownOperator: (operator, args) => {
+      throw new Error(
+        `Unsupported operator '${operator}' for PocketBase filter conversion. Supported operators: eq, gt, gte, lt, lte, in, like, and, or, not, isNull, isUndefined`
+      );
+    }
+  });
+  return result || void 0;
+}
+function convertToPocketBaseSort(orderBy) {
+  if (!orderBy) {
+    return void 0;
+  }
+  const sorts = parseOrderByExpression(orderBy);
+  if (sorts.length === 0) {
+    return void 0;
+  }
+  return sorts.map((sort) => {
+    const field = fieldPathToString(sort.field);
+    return sort.direction === "desc" ? `-${field}` : field;
+  }).join(",");
+}
 
 // src/logger.ts
 var defaultLogger = {
@@ -12,6 +109,9 @@ var defaultLogger = {
       console.log(`[pbtsdb] ${msg}`, context || "");
     }
   },
+  info: (msg, context) => {
+    console.info(`[pbtsdb] ${msg}`, context || "");
+  },
   warn: (msg, context) => {
     console.warn(`[pbtsdb] ${msg}`, context || "");
   },
@@ -22,6 +122,7 @@ var defaultLogger = {
 var currentLogger = defaultLogger;
 var logger = {
   debug: (msg, context) => currentLogger.debug(msg, context),
+  info: (msg, context) => currentLogger.info(msg, context),
   warn: (msg, context) => currentLogger.warn(msg, context),
   error: (msg, context) => currentLogger.error(msg, context)
 };
@@ -32,42 +133,94 @@ function resetLogger() {
   currentLogger = defaultLogger;
 }
 
-// src/subscription-manager.ts
-var SUBSCRIPTION_CONFIG = {
-  MAX_RECONNECT_ATTEMPTS: 5,
-  BASE_RECONNECT_DELAY_MS: 1e3,
-  DEFAULT_WAIT_TIMEOUT_MS: 5e3,
-  CLEANUP_DELAY_MS: 5e3
-};
-function hasId(record) {
-  return typeof record === "object" && record !== null && "id" in record && typeof record.id === "string";
-}
-function createPendingSubscriptionState(recordId) {
-  return {
-    unsubscribe: async () => {
-    },
-    recordId,
-    reconnectAttempts: 0,
-    isReconnecting: false
-  };
-}
-function getSubscriptionKey(recordId) {
-  return recordId || "*";
-}
-var SubscriptionManager = class {
-  constructor(pocketbase) {
-    this.pocketbase = pocketbase;
-    this.subscriptions = /* @__PURE__ */ new Map();
-    this.subscriptionPromises = /* @__PURE__ */ new Map();
-    this.cleanupTimers = /* @__PURE__ */ new Map();
-    this.subscriberCounts = /* @__PURE__ */ new Map();
-  }
-  // ============================================================================
-  // Internal Helpers
-  // ============================================================================
-  async setupSubscription(collectionName, collection, recordId) {
-    const subscriptionKey = getSubscriptionKey(recordId);
-    const eventHandler = (event) => {
+// src/collection.ts
+function createCollection(pb, queryClient) {
+  return (collectionName, options) => {
+    const expandStores = options?.expand;
+    const expandString = expandStores ? Object.keys(expandStores).sort().join(",") : void 0;
+    async function fetchRecords(loadOptions) {
+      const filter = convertToPocketBaseFilter(loadOptions?.where);
+      const sort = convertToPocketBaseSort(loadOptions?.orderBy);
+      const limit = loadOptions?.limit;
+      let items;
+      if (!filter && !sort && !limit && !expandString) {
+        items = await pb.collection(collectionName).getFullList();
+      } else {
+        const result = await pb.collection(collectionName).getList(1, limit || 500, {
+          filter,
+          sort,
+          expand: expandString
+        });
+        items = result.items;
+      }
+      if (expandStores) {
+        for (const record of items) {
+          const expandData = record.expand;
+          if (!expandData) continue;
+          for (const [key, value] of Object.entries(expandData)) {
+            const targetStore = expandStores[key];
+            if (!targetStore.utils) continue;
+            if (!targetStore.isReady()) {
+              if (targetStore.config?.syncMode === "on-demand") {
+                await targetStore._sync.startSync();
+              } else {
+                logger.warn(`not syncing ${key} on ${collectionName} because store is not yet ready`);
+                continue;
+              }
+            }
+            const values = Array.isArray(value) ? value : [value];
+            targetStore.utils.writeUpsert(values);
+          }
+        }
+      }
+      return items;
+    }
+    const collectionOptions = queryCollectionOptions({
+      queryClient,
+      queryKey: [collectionName],
+      syncMode: options?.syncMode ?? "eager",
+      queryFn: async (ctx) => {
+        return fetchRecords(ctx.meta?.loadSubsetOptions);
+      },
+      getKey: (item) => {
+        const record = item;
+        if (!record || typeof record !== "object" || !("id" in record)) {
+          throw new Error(`Record in collection '${collectionName}' is missing required 'id' field. Received: ${JSON.stringify(item)}`);
+        }
+        return record.id;
+      },
+      onInsert: options?.onInsert === false ? void 0 : options?.onInsert ?? (async ({ transaction }) => {
+        await Promise.all(
+          transaction.mutations.map(async (mutation) => {
+            const { created, updated, collectionId, collectionName: _, ...data } = mutation.modified;
+            await pb.collection(collectionName).create(data);
+          })
+        );
+      }),
+      onUpdate: options?.onUpdate === false ? void 0 : options?.onUpdate ?? (async ({ transaction }) => {
+        await Promise.all(
+          transaction.mutations.map(async (mutation) => {
+            const recordWithId = mutation.original;
+            await pb.collection(collectionName).update(recordWithId.id, mutation.changes);
+          })
+        );
+      }),
+      onDelete: options?.onDelete === false ? void 0 : options?.onDelete ?? (async ({ transaction }) => {
+        await Promise.all(
+          transaction.mutations.map(async (mutation) => {
+            const recordWithId = mutation.original;
+            await pb.collection(collectionName).delete(recordWithId.id);
+          })
+        );
+      })
+    });
+    const collection = createCollection$1(collectionOptions);
+    let unsubscribeFn = null;
+    let isSubscribed = false;
+    let subscriptionPromise = null;
+    let subscriptionResolve = null;
+    const handleRealtimeEvent = (event) => {
+      if (!collection.utils) return;
       collection.utils.writeBatch(() => {
         switch (event.action) {
           case "create":
@@ -77,469 +230,119 @@ var SubscriptionManager = class {
             collection.utils.writeUpdate(event.record);
             break;
           case "delete":
-            if (!hasId(event.record)) {
-              logger.error("Delete event record missing id field", {
-                collectionName,
-                record: event.record
-              });
-              return;
+            if (event.record && "id" in event.record) {
+              collection.utils.writeDelete(event.record.id);
             }
-            collection.utils.writeDelete(event.record.id);
             break;
         }
       });
     };
-    const unsubscribe = await this.pocketbase.collection(collectionName).subscribe(subscriptionKey, eventHandler);
-    logger.debug("Subscription established", { collectionName, subscriptionKey });
-    return unsubscribe;
-  }
-  async handleReconnection(collectionName, collection, recordId) {
-    const collectionSubs = this.subscriptions.get(collectionName);
-    if (!collectionSubs) return;
-    const subscriptionKey = getSubscriptionKey(recordId);
-    const state = collectionSubs.get(subscriptionKey);
-    if (!state || state.isReconnecting) return;
-    state.isReconnecting = true;
-    logger.warn("Starting reconnection attempts", { collectionName, subscriptionKey });
-    while (state.reconnectAttempts < SUBSCRIPTION_CONFIG.MAX_RECONNECT_ATTEMPTS) {
-      const delay = SUBSCRIPTION_CONFIG.BASE_RECONNECT_DELAY_MS * Math.pow(2, state.reconnectAttempts);
-      logger.debug(`Reconnection attempt ${state.reconnectAttempts + 1}, waiting ${delay}ms`, {
-        collectionName,
-        subscriptionKey
-      });
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      try {
-        const newUnsubscribe = await this.setupSubscription(
-          collectionName,
-          collection,
-          recordId
-        );
-        state.unsubscribe = newUnsubscribe;
-        state.reconnectAttempts = 0;
-        state.isReconnecting = false;
-        logger.debug("Reconnection successful", { collectionName, subscriptionKey });
-        return;
-      } catch (error) {
-        state.reconnectAttempts++;
-        logger.warn(`Reconnection attempt ${state.reconnectAttempts} failed`, {
-          collectionName,
-          subscriptionKey,
-          error
+    const startSubscription = async () => {
+      if (isSubscribed) return;
+      if (!subscriptionPromise) {
+        subscriptionPromise = new Promise((resolve) => {
+          subscriptionResolve = resolve;
         });
       }
-    }
-    logger.error("Max reconnection attempts reached", {
-      collectionName,
-      subscriptionKey,
-      attempts: state.reconnectAttempts
-    });
-    state.isReconnecting = false;
-    collectionSubs.delete(subscriptionKey);
-  }
-  // ============================================================================
-  // Core Subscription Methods
-  // ============================================================================
-  /**
-   * Subscribe to real-time updates for a collection.
-   * Returns a promise that resolves when the subscription is fully established.
-   *
-   * @param collectionName - The PocketBase collection name
-   * @param collection - The TanStack DB collection to sync with
-   * @param recordId - Optional: Subscribe to specific record, or omit for collection-wide updates
-   */
-  async subscribe(collectionName, collection, recordId) {
-    if (!this.subscriptions.has(collectionName)) {
-      this.subscriptions.set(collectionName, /* @__PURE__ */ new Map());
-    }
-    if (!this.subscriptionPromises.has(collectionName)) {
-      this.subscriptionPromises.set(collectionName, /* @__PURE__ */ new Map());
-    }
-    const collectionSubs = this.subscriptions.get(collectionName);
-    const collectionPromises = this.subscriptionPromises.get(collectionName);
-    const subscriptionKey = getSubscriptionKey(recordId);
-    if (collectionSubs.has(subscriptionKey)) {
-      logger.debug("Already subscribed, skipping", { collectionName, subscriptionKey });
-      return;
-    }
-    const existingPromise = collectionPromises.get(subscriptionKey);
-    if (existingPromise) {
-      logger.debug("Pending subscription found, waiting", { collectionName, subscriptionKey });
-      return existingPromise;
-    }
-    collectionSubs.set(subscriptionKey, createPendingSubscriptionState(recordId));
-    const subscriptionPromise = (async () => {
       try {
-        const unsubscribe = await this.setupSubscription(collectionName, collection, recordId);
-        const state = collectionSubs.get(subscriptionKey);
-        if (state) {
-          state.unsubscribe = unsubscribe;
+        unsubscribeFn = await pb.collection(collectionName).subscribe("*", handleRealtimeEvent);
+        isSubscribed = true;
+        logger.debug("Subscription started", { collectionName });
+        if (subscriptionResolve) {
+          subscriptionResolve();
         }
       } catch (error) {
-        collectionSubs.delete(subscriptionKey);
-        collectionPromises.delete(subscriptionKey);
-        logger.error("Subscription failed", { collectionName, subscriptionKey, error });
-        await this.handleReconnection(collectionName, collection, recordId);
-        throw error;
-      }
-    })();
-    collectionPromises.set(subscriptionKey, subscriptionPromise);
-    try {
-      await subscriptionPromise;
-    } catch (_error) {
-    }
-  }
-  /**
-   * Unsubscribe from real-time updates.
-   *
-   * @param collectionName - The PocketBase collection name
-   * @param recordId - Optional: Unsubscribe from specific record, or omit for collection-wide
-   */
-  unsubscribe(collectionName, recordId) {
-    const collectionSubs = this.subscriptions.get(collectionName);
-    if (!collectionSubs) return;
-    const subscriptionKey = getSubscriptionKey(recordId);
-    const state = collectionSubs.get(subscriptionKey);
-    if (state) {
-      const unsubPromise = state.unsubscribe();
-      if (unsubPromise && typeof unsubPromise.catch === "function") {
-        unsubPromise.catch((error) => {
-          logger.debug("Unsubscribe failed (expected if connection closed)", {
-            collectionName,
-            subscriptionKey,
-            error
-          });
-        });
+        logger.error("Failed to start subscription", { collectionName, error });
       }
-      collectionSubs.delete(subscriptionKey);
-      logger.debug("Unsubscribed", { collectionName, subscriptionKey });
-    }
-    const collectionPromises = this.subscriptionPromises.get(collectionName);
-    if (collectionPromises) {
-      collectionPromises.delete(subscriptionKey);
-      if (collectionPromises.size === 0) {
-        this.subscriptionPromises.delete(collectionName);
+    };
+    const stopSubscription = async () => {
+      if (!isSubscribed || !unsubscribeFn) return;
+      try {
+        await unsubscribeFn();
+        unsubscribeFn = null;
+        isSubscribed = false;
+        subscriptionPromise = null;
+        subscriptionResolve = null;
+        logger.debug("Subscription stopped", { collectionName });
+      } catch (error) {
+        logger.debug("Unsubscribe failed (expected if connection closed)", { collectionName, error });
       }
-    }
-    if (collectionSubs.size === 0) {
-      this.subscriptions.delete(collectionName);
-    }
-  }
-  /**
-   * Unsubscribe from all subscriptions for a collection.
-   *
-   * @param collectionName - The PocketBase collection name
-   */
-  unsubscribeAll(collectionName) {
-    const collectionSubs = this.subscriptions.get(collectionName);
-    if (!collectionSubs) return;
-    logger.debug("Unsubscribing from all subscriptions", { collectionName, count: collectionSubs.size });
-    for (const state of collectionSubs.values()) {
-      const unsubPromise = state.unsubscribe();
-      if (unsubPromise && typeof unsubPromise.catch === "function") {
-        unsubPromise.catch((error) => {
-          logger.debug("Unsubscribe failed (expected if connection closed)", {
-            collectionName,
-            error
-          });
+    };
+    const waitForSubscription = async (timeout = 5e3) => {
+      if (isSubscribed) return;
+      if (!subscriptionPromise) {
+        await new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            if (subscriptionPromise) {
+              clearInterval(checkInterval);
+              resolve();
+            }
+          }, 10);
+          setTimeout(() => {
+            clearInterval(checkInterval);
+            resolve();
+          }, timeout);
         });
       }
-    }
-    this.subscriptions.delete(collectionName);
-    this.subscriptionPromises.delete(collectionName);
-  }
-  // ============================================================================
-  // State Queries
-  // ============================================================================
-  /**
-   * Check if subscribed to a collection.
-   *
-   * @param collectionName - The PocketBase collection name
-   * @param recordId - Optional: Check specific record subscription, or omit for collection-wide
-   */
-  isSubscribed(collectionName, recordId) {
-    const collectionSubs = this.subscriptions.get(collectionName);
-    if (!collectionSubs) return false;
-    const subscriptionKey = getSubscriptionKey(recordId);
-    return collectionSubs.has(subscriptionKey);
-  }
-  /**
-   * Wait for a subscription to be fully established (useful for testing).
-   *
-   * @param collectionName - The collection name
-   * @param recordId - Optional specific record ID
-   * @param timeoutMs - Timeout in milliseconds
-   */
-  async waitForSubscription(collectionName, recordId, timeoutMs = SUBSCRIPTION_CONFIG.DEFAULT_WAIT_TIMEOUT_MS) {
-    const subscriptionKey = getSubscriptionKey(recordId);
-    const collectionSubs = this.subscriptions.get(collectionName);
-    if (collectionSubs?.has(subscriptionKey)) {
-      const collectionPromises2 = this.subscriptionPromises.get(collectionName);
-      if (!collectionPromises2?.has(subscriptionKey)) {
-        return;
+      if (subscriptionPromise) {
+        await Promise.race([
+          subscriptionPromise,
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Subscription timeout")), timeout)
+          )
+        ]);
       }
-    }
-    const collectionPromises = this.subscriptionPromises.get(collectionName);
-    const promise = collectionPromises?.get(subscriptionKey);
-    if (!promise) {
-      const isSubscribed = collectionSubs?.has(subscriptionKey);
-      if (!isSubscribed) {
-        throw new Error(`No subscription found for ${collectionName}:${subscriptionKey}`);
+    };
+    collection.on("subscribers:change", (event) => {
+      const newCount = event.subscriberCount;
+      const previousCount = event.previousSubscriberCount;
+      if (newCount > 0 && previousCount === 0) {
+        startSubscription().catch(() => {
+        });
+      } else if (newCount === 0 && previousCount > 0) {
+        stopSubscription().catch(() => {
+        });
       }
-      return;
-    }
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error(`Subscription timeout after ${timeoutMs}ms`)), timeoutMs);
     });
-    await Promise.race([promise, timeoutPromise]);
-  }
-  // ============================================================================
-  // Lifecycle Management
-  // ============================================================================
-  /**
-   * Track subscriber addition for a collection.
-   * Automatically subscribes when first subscriber is added.
-   *
-   * @param collectionName - The PocketBase collection name
-   * @param collection - The TanStack DB collection to sync with
-   */
-  async addSubscriber(collectionName, collection) {
-    const currentCount = this.subscriberCounts.get(collectionName) || 0;
-    const newCount = currentCount + 1;
-    this.subscriberCounts.set(collectionName, newCount);
-    logger.debug("Subscriber added", { collectionName, count: newCount });
-    const cleanupTimer = this.cleanupTimers.get(collectionName);
-    if (cleanupTimer) {
-      clearTimeout(cleanupTimer);
-      this.cleanupTimers.delete(collectionName);
-      logger.debug("Cleanup timer cancelled", { collectionName });
-    }
-    if (newCount === 1 && !this.isSubscribed(collectionName)) {
-      logger.debug("First subscriber - starting subscription", { collectionName });
-      await this.subscribe(collectionName, collection);
-    }
-  }
-  /**
-   * Track subscriber removal for a collection.
-   * Automatically unsubscribes (with delay) when last subscriber is removed.
-   *
-   * @param collectionName - The PocketBase collection name
-   */
-  removeSubscriber(collectionName) {
-    const currentCount = this.subscriberCounts.get(collectionName) || 0;
-    const newCount = Math.max(0, currentCount - 1);
-    this.subscriberCounts.set(collectionName, newCount);
-    logger.debug("Subscriber removed", { collectionName, count: newCount });
-    if (newCount === 0) {
-      const existingTimer = this.cleanupTimers.get(collectionName);
-      if (existingTimer) {
-        clearTimeout(existingTimer);
-      }
-      const cleanupTimer = setTimeout(() => {
-        const finalCount = this.subscriberCounts.get(collectionName) || 0;
-        if (finalCount === 0) {
-          logger.debug("Cleanup timer fired - unsubscribing", { collectionName });
-          this.unsubscribeAll(collectionName);
-          this.subscriberCounts.delete(collectionName);
-        }
-        this.cleanupTimers.delete(collectionName);
-      }, SUBSCRIPTION_CONFIG.CLEANUP_DELAY_MS);
-      this.cleanupTimers.set(collectionName, cleanupTimer);
-      logger.debug("Cleanup timer scheduled", {
-        collectionName,
-        delayMs: SUBSCRIPTION_CONFIG.CLEANUP_DELAY_MS
-      });
-    }
-  }
-  /**
-   * Get the current subscriber count for a collection.
-   * Useful for debugging and testing.
-   *
-   * @param collectionName - The PocketBase collection name
-   * @returns Current subscriber count
-   */
-  getSubscriberCount(collectionName) {
-    return this.subscriberCounts.get(collectionName) || 0;
-  }
-};
-var CollectionsContext = createContext(null);
-function CollectionsProvider({ collections, children }) {
-  return /* @__PURE__ */ jsx(CollectionsContext.Provider, { value: collections, children });
-}
-function useStore(key) {
-  const context = useContext(CollectionsContext);
-  if (!context) {
-    throw new Error("useStore must be used within a CollectionsProvider");
-  }
-  if (!(key in context)) {
-    throw new Error(`Collection "${key}" not found in CollectionsProvider`);
-  }
-  return context[key];
+    Object.assign(collection, {
+      collectionName,
+      waitForSubscription,
+      isSubscribed: () => isSubscribed
+    });
+    return collection;
+  };
 }
-function useStores(keys) {
-  const context = useContext(CollectionsContext);
-  if (!context) {
-    throw new Error("useStores must be used within a CollectionsProvider");
-  }
-  const collections = keys.map((key) => {
-    if (!(key in context)) {
-      throw new Error(`Collection "${key}" not found in CollectionsProvider`);
+function createReactProvider(collections) {
+  const Context = createContext(null);
+  const Provider = ({ children }) => /* @__PURE__ */ jsx(Context.Provider, { value: collections, children });
+  function useStore(...keys) {
+    const context = useContext(Context);
+    if (!context) {
+      throw new Error("useStore must be used within the Provider returned by createReactProvider");
     }
-    return context[key];
-  });
-  return collections;
-}
-
-// src/collection.ts
-var CollectionFactory = class {
-  constructor(pocketbase, queryClient) {
-    this.pocketbase = pocketbase;
-    this.queryClient = queryClient;
-    this.subscriptionManager = new SubscriptionManager(pocketbase);
-  }
-  /**
-   * Setup automatic subscription lifecycle management.
-   * Hooks into TanStack DB's subscriber events to manage real-time subscriptions.
-   */
-  setupSubscriptionLifecycle(collectionName, baseCollection) {
-    baseCollection.on("subscribers:change", (event) => {
-      const newCount = event.subscriberCount;
-      const previousCount = event.previousSubscriberCount;
-      if (newCount > previousCount) {
-        this.subscriptionManager.addSubscriber(collectionName, baseCollection).catch(() => {
-        });
-      } else if (newCount < previousCount) {
-        this.subscriptionManager.removeSubscriber(collectionName);
+    return keys.map((key) => {
+      if (!(key in context)) {
+        throw new Error(`Collection "${String(key)}" not found in collections`);
       }
+      return context[key];
     });
   }
-  /**
-   * Create a TanStack DB collection from a PocketBase collection.
-   *
-   * Collections are lazy by default - they don't fetch data or subscribe until queried.
-   * Real-time subscriptions automatically start when the first query becomes active
-   * and stop when the last query unmounts (with a cleanup delay to prevent thrashing).
-   *
-   * @param collection - The name of the collection
-   * @param options - Optional configuration including relations and expand
-   *
-   * @example
-   * Basic usage with automatic lifecycle management:
-   * ```ts
-   * const jobsCollection = factory.create('jobs');
-   *
-   * // In your component - subscription starts automatically
-   * const { data } = useLiveQuery((q) =>
-   *     q.from({ jobs: jobsCollection })
-   * );
-   * // Subscription stops automatically when component unmounts
-   * ```
-   *
-   * @example
-   * With query operators (filters, sorting):
-   * ```ts
-   * const jobsCollection = factory.create('jobs');
-   *
-   * // In your component:
-   * const { data } = useLiveQuery((q) =>
-   *     q.from({ jobs: jobsCollection })
-   *      .where(({ jobs }) => and(
-   *          eq(jobs.status, 'ACTIVE'),
-   *          gt(jobs.created, new Date('2025-01-01'))
-   *      ))
-   *      .orderBy(({ jobs }) => jobs.created, 'desc')
-   * );
-   * ```
-   *
-   * @example
-   * With relation expansion:
-   * ```ts
-   * const jobsCollection = factory.create('jobs', {
-   *     expand: 'customer,location'
-   * });
-   *
-   * // Expanded relations available in record.expand
-   * ```
-   *
-   * @example
-   * With relations (for manual joins):
-   * ```ts
-   * const customersCollection = factory.create('customers');
-   * const jobsCollection = factory.create('jobs', {
-   *     relations: { customer: customersCollection }
-   * });
-   *
-   * // In your component, manually build joins:
-   * const { data } = useLiveQuery((q) =>
-   *     q.from({ job: jobsCollection })
-   *      .join(
-   *          { customer: customersCollection },
-   *          ({ job, customer }) => eq(job.customer, customer.id),
-   *          "left"
-   *      )
-   *      .select(({ job, customer }) => ({
-   *          ...job,
-   *          expand: {
-   *              customer: customer ? { ...customer } : undefined
-   *          }
-   *      }))
-   * );
-   * ```
-   *
-   * @example
-   * Manual subscription control (advanced):
-   * ```ts
-   * const jobsCollection = factory.create('jobs');
-   *
-   * // Manually subscribe to specific record (bypasses automatic lifecycle)
-   * await jobsCollection.subscribe('record_id_123');
-   *
-   * // Check subscription status
-   * const isSubbed = jobsCollection.isSubscribed('record_id_123');
-   *
-   * // Manually unsubscribe
-   * jobsCollection.unsubscribe('record_id_123');
-   * ```
-   */
-  create(collection, options) {
-    const baseCollection = createCollection(
-      queryCollectionOptions({
-        queryKey: [collection],
-        queryFn: async () => {
-          const queryOptions = {};
-          if (options?.expand) {
-            queryOptions.expand = options.expand;
-          }
-          const result = await this.pocketbase.collection(collection).getFullList(queryOptions);
-          return result;
-        },
-        queryClient: this.queryClient,
-        getKey: (item) => item.id,
-        startSync: options?.startSync ?? false
-      })
-    );
-    const subscribableCollection = Object.assign(baseCollection, {
-      subscribe: async (recordId) => {
-        await this.subscriptionManager.subscribe(collection, baseCollection, recordId);
-      },
-      unsubscribe: (recordId) => {
-        this.subscriptionManager.unsubscribe(collection, recordId);
-      },
-      unsubscribeAll: () => {
-        this.subscriptionManager.unsubscribeAll(collection);
-      },
-      isSubscribed: (recordId) => {
-        return this.subscriptionManager.isSubscribed(collection, recordId);
-      },
-      waitForSubscription: async (recordId, timeoutMs) => {
-        await this.subscriptionManager.waitForSubscription(collection, recordId, timeoutMs);
-      },
-      relations: options?.relations || {}
-    });
-    this.setupSubscriptionLifecycle(collection, baseCollection);
-    return subscribableCollection;
+  return {
+    Provider,
+    useStore
+  };
+}
+
+// src/util.ts
+function newRecordId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 15; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
   }
-};
+  return result;
+}
 
-export { CollectionFactory, CollectionsProvider, SUBSCRIPTION_CONFIG, SubscriptionManager, resetLogger, setLogger, useStore, useStores };
+export { createCollection, createReactProvider, newRecordId, resetLogger, setLogger };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map